Add 300 CheckerBench tasks, dataset card, and restoration tools (part 4)

tasks/csa159/pair_135405/post_functions.txt

@@ -0,0 +1,144 @@
+### File: src/ext-cmd.c
+```c
+static int select_read(int sockfd, char buffer[], int bufsize, struct timeval *tv)
+{
+	fd_set rfds;
+	int retval;
+
+	FD_ZERO(&rfds);
+	FD_SET(sockfd, &rfds);
+
+	retval = select(sockfd + 1, &rfds, NULL, NULL, tv);
+
+	if (retval == -1) {
+		// Error
+		return -1;
+	} else if (retval) {
+		// Data available
+		return read(sockfd, buffer, bufsize);
+	} else {
+		// Timeout reached
+		return 0;
+	}
+}
+
+static int append_strings(char buf[], size_t bufsize, int argc, char *argv[])
+{
+	int i;
+	int len;
+
+	// Check input length
+	len = 0;
+	for (i = 0; i < argc; ++i) {
+		len += 1 + strlen(argv[i]);
+		if(len >= bufsize) {
+			return EXIT_FAILURE;
+		}
+	}
+
+	// Concatenate strings
+	buf[0] = '\0';
+	for (i = 0; i < argc; ++i) {
+		if (i) {
+			strcat(buf, " ");
+		}
+		strcat(buf, argv[i]);
+	}
+	strcat(buf, "\n");
+
+	return EXIT_SUCCESS;
+}
+
+int cmd_client(int argc, char *argv[])
+{
+	char buffer[256];
+	const char *path;
+	struct sockaddr_un addr;
+	struct timeval tv;
+	ssize_t size;
+	int sock;
+
+	// Default unix socket path
+	path = CMD_PATH;
+
+	// Skip program name
+	argc -= 1;
+	argv += 1;
+
+	if (argc >= 1) {
+		if (strcmp(argv[0], "-h") == 0) {
+			fprintf(stdout, "%s", g_client_usage);
+			return 0;
+		} else if (strcmp(argv[0], "-p") == 0) {
+			if (argc >= 2) {
+				path = argv[1];
+				// Skip option and path
+				argc -= 2;
+				argv += 2;
+			} else {
+				fprintf(stderr, "Path is missing!\n");
+				return 1;
+			}
+		}
+	}
+
+	if (EXIT_FAILURE == append_strings(buffer, sizeof(buffer), argc, argv)) {
+		fprintf(stderr, "Input to long\n");
+		return EXIT_FAILURE;
+	}
+
+	sock = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (sock < 0) {
+		fprintf(stderr, "socket(): %s\n", strerror(errno));
+		return EXIT_FAILURE;
+	}
+
+	addr.sun_family = AF_LOCAL;
+	strcpy(addr.sun_path, path);
+
+	if (connect(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+		fprintf(stderr, "Failed to connect to '%s': %s\n", path, strerror(errno));
+		goto error;
+	}
+
+	/* Set receive timeout: 200ms */
+	tv.tv_sec = 0;
+	tv.tv_usec = 200000;
+
+#ifndef __CYGWIN__
+	if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) < 0) {
+		fprintf(stderr, "setsockopt(): %s\n", strerror(errno));
+		goto error;
+	}
+#endif
+
+	// Send request
+	send(sock, buffer, strlen(buffer), 0);
+
+	while (1) {
+		// Receive replies
+#ifdef __CYGWIN__
+		size = select_read(sock, buffer, strlen(buffer), &tv);
+#else
+		size = read(sock, buffer, strlen(buffer));
+#endif
+		if (size <= 0) {
+			break;
+		}
+
+		buffer[size] = '\0';
+		printf("%s", buffer);
+	}
+
+	close(sock);
+
+	return EXIT_SUCCESS;
+
+error:
+	if (sock > 0) {
+		close(sock);
+	}
+
+	return EXIT_FAILURE;
+}
+```

tasks/csa159/pair_135405/pre_functions.txt

@@ -0,0 +1,123 @@
+### File: src/ext-cmd.c
+```c
+static int select_read(int sockfd, char buffer[], int bufsize, struct timeval *tv)
+{
+	fd_set rfds;
+	int retval;
+
+	FD_ZERO(&rfds);
+	FD_SET(sockfd, &rfds);
+
+	retval = select(sockfd + 1, &rfds, NULL, NULL, tv);
+
+	if (retval == -1) {
+		// Error
+		return -1;
+	} else if (retval) {
+		// Data available
+		return read(sockfd, buffer, bufsize);
+	} else {
+		// Timeout reached
+		return 0;
+	}
+}
+
+int cmd_client(int argc, char *argv[])
+{
+	char buffer[256];
+	const char *path;
+	struct sockaddr_un addr;
+	struct timeval tv;
+	ssize_t size;
+	int sock;
+	size_t i;
+
+	// Default unix socket path
+	path = CMD_PATH;
+
+	// Skip program name
+	argc -= 1;
+	argv += 1;
+
+	if (argc >= 1) {
+		if (strcmp(argv[0], "-h") == 0) {
+			fprintf(stdout, "%s", g_client_usage);
+			return 0;
+		} else if (strcmp(argv[0], "-p") == 0) {
+			if (argc >= 2) {
+				path = argv[1];
+				// Skip option and path
+				argc -= 2;
+				argv += 2;
+			} else {
+				fprintf(stderr, "Path is missing!\n");
+				return 1;
+			}
+		}
+	}
+
+	// Construct request string from args
+	buffer[0] = '\0';
+	for (i = 0; i < argc; ++i) {
+		if (i) {
+			strcat(buffer, " ");
+		}
+		strcat(buffer, argv[i]);
+	}
+	strcat(buffer, "\n");
+
+	sock = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (sock < 0) {
+		fprintf(stderr, "socket(): %s\n", strerror(errno));
+		return EXIT_FAILURE;
+	}
+
+	addr.sun_family = AF_LOCAL;
+	strcpy(addr.sun_path, path);
+
+	if (connect(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+		fprintf(stderr, "Failed to connect to '%s': %s\n", path, strerror(errno));
+		goto error;
+	}
+
+	/* Set receive timeout: 200ms */
+	tv.tv_sec = 0;
+	tv.tv_usec = 200000;
+
+#ifndef __CYGWIN__
+	if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) < 0) {
+		fprintf(stderr, "setsockopt(): %s\n", strerror(errno));
+		goto error;
+	}
+#endif
+
+	// Send request
+	send(sock, buffer, strlen(buffer), 0);
+
+	while (1) {
+		// Receive replies
+#ifdef __CYGWIN__
+		size = select_read(sock, buffer, strlen(buffer), &tv);
+#else
+		size = read(sock, buffer, strlen(buffer));
+#endif
+		if (size <= 0) {
+			break;
+		}
+
+		buffer[size] = '\0';
+		printf("%s", buffer);
+	}
+
+	close(sock);
+
+	return EXIT_SUCCESS;
+
+error:
+	if (sock > 0) {
+		close(sock);
+	}
+
+	return EXIT_FAILURE;
+}
+```

tasks/csa159/pair_135405/task_prompt.md

@@ -0,0 +1,383 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `control_flow`
+
+### Current failure diagnosis
+
+- The prior rollout did not prove that a candidate condition constrains the accumulated output length; it accepted any relational comparison with an operand at least as large as the capacity.
+- Source-order precedence was substituted for reachability and dominance, so a guard on another branch or a bypassable guard could incorrectly suppress a real overflow.
+- Termination was recognized without proving comparison orientation or which successor reaches the writes; accepting arbitrary return, goto, break, or continue constructs made the safe condition unsound.
+- Treating every nonliteral source as unbounded ignored the cumulative semantics of repeated concatenation, including argument lengths, separators, newline, and the terminating null byte.
+- Process quality remained below threshold because validation included working-directory mistakes, an avoidable CSA API type error, unreliable scans with compile errors, and some weakly evidenced recovery steps.
+
+### Preserve from prior rollouts
+
+- The new synthesis must compile successfully and pass before/after validation and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Maintain the semantic score at or above the configured threshold while correcting the semantic mechanism.
+- Remain independent of patch anchors such as changed line numbers or exact diff locations.
+- Remain free of patch-local hardcoding, including project-specific function, variable, file, or macro names.
+
+### Required semantic proof
+
+- Report only when repeated unbounded string writes can reach a fixed-capacity destination without a proven bound on the total required bytes.
+- Relate the checked quantity to the same accumulated length consumed by the writes, accounting for each source length, inserted separators, the final newline, and null termination.
+- A suppressing guard must compare that accumulated requirement against the destination capacity with the correct operator and operand orientation.
+- Prove through the CFG that the rejecting successor exits before every relevant write and that every path reaching those writes passed through the safe successor.
+- For the patched structure, establish that completion of the length-accumulation loop and the condition len >= capacity imply len < capacity on all paths entering the later concatenation loop.
+- Do not infer safety merely from a nonliteral source being preceded by some capacity-like comparison; absence or presence of the precise length-to-capacity relation controls the diagnostic.
+
+### Implementation constraints
+
+- Use check::PreCall, or an equivalently local pre-write callback, for strcat/strcpy so destination and source arguments are available and the diagnostic is emitted at the unsafe call.
+- Recover the destination extent from CSA region and type information, including an inlined caller's fixed array when observable, rather than from spelling or a literal capacity value.
+- Use the enclosing AnalysisDeclContext CFG and dominance or equivalent all-path reachability reasoning; SourceManager ordering alone is insufficient.
+- Identify the length accumulator by its data dependencies on strlen-derived source lengths and added delimiter costs, not by its identifier.
+- Accept a guard only when its safe CFG edge dominates the relevant writes and its rejecting edge cannot rejoin before them.
+- Resolve a size parameter to a concrete destination capacity only through semantic argument/type relationships such as sizeof of the same destination; do not guess from parameter position or value alone.
+- Keep scope project-general around fixed-capacity destinations and standard unbounded string-copy or concatenation sinks, with no special treatment of ext-cmd.c, cmd_client, append_strings, buffer, len, bufsize, argv, or 256.
+- Avoid persistent ProgramState traits or cross-function fact propagation unless CFG and call-context facts demonstrably cannot establish the required relation.
+
+### Validation checklist
+
+- Build the new checker against the supplied LLVM/Clang API with no diagnostics and verify registration and loading before scanning.
+- Run scans from verified working directories with the supplied include flags; reject any result in which either source version has a compile error or skipped file.
+- Confirm exactly the relevant vulnerable-version diagnostic is produced and the patched version is clean, preserving N_buggy=1 and N_patched=0.
+- Confirm the vulnerable diagnostic is located on the length-unknown strcat in cmd_client, at zero or comparably minimal distance from the changed vulnerable operation.
+- Add focused negative tests showing that an unrelated large-constant comparison, reversed or permissive comparison, terminating wrong branch, source-ordered but bypassable guard, or nondominating guard does not establish safety.
+- Add a positive safety test matching the patch semantics: accumulated strlen plus delimiter costs is rejected at or above the same buffer capacity before all concatenations.
+- Run code verification and ensure no warnings disappear only in non-patched functions and no unrelated strcpy to a struct field is newly diagnosed outside the declared scope.
+- Complete refinement with an accepted or clean outcome and retain objective gate G6 and the configured semantic-score threshold.
+
+### Avoid and forbidden regressions
+
+- Do not reuse the failed heuristic of collecting arbitrary preceding IfStmt nodes and accepting any capacity-sized operand plus any syntactically nested terminator.
+- Do not equate lexical source order with dominance, path reachability, or enforcement of a guard.
+- Do not suppress on a comparison unless the checker proves accumulator identity, comparison direction, rejecting successor, and the path relationship to every sink.
+- Do not use a pure strcat/strcpy syntax match or fixed-array plus nonliteral-source match; those patterns cannot distinguish the patched helper from the vulnerability.
+- Do not introduce unnecessary caller-to-callee dataflow or symbolic-state machinery merely to recover a literal value when semantic CFG and argument relationships suffice.
+- Do not rely on file paths, source lines, patch anchors, project identifiers, exact variable names, or the literal capacity 256.
+- Do not count scans with parse failures, missing headers, invalid flags, or unverified recovery commands as validation evidence.

tasks/csa159/pair_135446/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_135446/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "openSUSE_libsolv",
+  "before_commit": "926244b99d3261b3f60bd974612999a9c781a7ab",
+  "after_commit": "0077ef29eb46d2e1df2f230fc95a1d9748d49dec",
+  "repo_path": "/workspace/repo/openSUSE/libsolv",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openSUSE_libsolv/7046fb004987c7f1b3722628d9a4ca1c67577188/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openSUSE_libsolv/7046fb004987c7f1b3722628d9a4ca1c67577188/compile_commands.json",
+  "changed_files": [
+    "ext/testcase.c"
+  ],
+  "commit_message": "testcase_read: error out if repos are added or the system is changed too late\n\nWe must not add new solvables after the considered map was created, the solver\nwas created, or jobs were added. We may not changed the system after jobs have\nbeen added.\n\n(Jobs may point inside the whatproviedes array, so we must not invalidate this\narea.)",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_135446/patch.diff

@@ -0,0 +1,46 @@
+diff --git a/ext/testcase.c b/ext/testcase.c
+index 0be7a213..8fb6d793 100644
+--- a/ext/testcase.c
++++ b/ext/testcase.c
+@@ -1991,6 +1991,7 @@ testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **res
+   Id *genid = 0;
+   int ngenid = 0;
+   Queue autoinstq;
++  int oldjobsize = job ? job->count : 0;
+ 
+   if (resultp)
+     *resultp = 0;
+@@ -2065,6 +2066,21 @@ testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **res
+ 	  int prio, subprio;
+ 	  const char *rdata;
+ 
++	  if (pool->considered)
++	    {
++	      pool_error(pool, 0, "testcase_read: cannot add repos after packages were disabled");
++	      continue;
++	    }
++	  if (solv)
++	    {
++	      pool_error(pool, 0, "testcase_read: cannot add repos after the solver was created");
++	      continue;
++	    }
++	  if (job && job->count != oldjobsize)
++	    {
++	      pool_error(pool, 0, "testcase_read: cannot add repos after jobs have been created");
++	      continue;
++	    }
+ 	  prepared = 0;
+           if (!poolflagsreset)
+ 	    {
+@@ -2125,6 +2141,11 @@ testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **res
+ 	  int i;
+ 
+ 	  /* must set the disttype before the arch */
++	  if (job && job->count != oldjobsize)
++	    {
++	      pool_error(pool, 0, "testcase_read: cannot change the system after jobs have been created");
++	      continue;
++	    }
+ 	  prepared = 0;
+ 	  if (strcmp(pieces[2], "*") != 0)
+ 	    {

tasks/csa159/pair_135446/post_functions.txt

@@ -0,0 +1,313 @@
+### File: ext/testcase.c
+```c
+Solver *
+testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **resultp, int *resultflagsp)
+{
+  Solver *solv;
+  char *buf, *bufp;
+  int bufl;
+  char *testcasedir, *s;
+  int l;
+  char **pieces = 0;
+  int npieces = 0;
+  int prepared = 0;
+  int closefp = !fp;
+  int poolflagsreset = 0;
+  int missing_features = 0;
+  Id *genid = 0;
+  int ngenid = 0;
+  Queue autoinstq;
+  int oldjobsize = job ? job->count : 0;
+
+  if (resultp)
+    *resultp = 0;
+  if (resultflagsp)
+    *resultflagsp = 0;
+  if (!fp && !(fp = fopen(testcase, "r")))
+    {
+      pool_error(pool, 0, "testcase_read: could not open '%s'", testcase);
+      return 0;
+    }
+  testcasedir = solv_strdup(testcase);
+  s = strrchr(testcasedir, '/');
+#ifdef _WIN32
+  buf = strrchr(testcasedir, '\\');
+  if (!s || (buf && buf > s))
+    s = buf;
+#endif
+  if (s)
+    s[1] = 0;
+  else
+    *testcasedir = 0;
+  bufl = 1024;
+  buf = solv_malloc(bufl);
+  bufp = buf;
+  solv = 0;
+  queue_init(&autoinstq);
+  for (;;)
+    {
+      if (bufp - buf + 16 > bufl)
+	{
+	  bufl = bufp - buf;
+	  buf = solv_realloc(buf, bufl + 512);
+	  bufp = buf + bufl;
+          bufl += 512;
+	}
+      if (!fgets(bufp, bufl - (bufp - buf), fp))
+	break;
+      bufp = buf;
+      l = strlen(buf);
+      if (!l || buf[l - 1] != '\n')
+	{
+	  bufp += l;
+	  continue;
+	}
+      buf[--l] = 0;
+      s = buf;
+      while (*s && (*s == ' ' || *s == '\t'))
+	s++;
+      if (!*s || *s == '#')
+	continue;
+      npieces = 0;
+      /* split it in pieces */
+      for (;;)
+	{
+	  while (*s == ' ' || *s == '\t')
+	    s++;
+	  if (!*s)
+	    break;
+	  pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
+	  pieces[npieces++] = s;
+	  while (*s && *s != ' ' && *s != '\t')
+	    s++;
+	  if (*s)
+	    *s++ = 0;
+	}
+      pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
+      pieces[npieces] = 0;
+      if (!strcmp(pieces[0], "repo") && npieces >= 4)
+	{
+	  Repo *repo = repo_create(pool, pieces[1]);
+	  FILE *rfp;
+	  int prio, subprio;
+	  const char *rdata;
+
+	  if (pool->considered)
+	    {
+	      pool_error(pool, 0, "testcase_read: cannot add repos after packages were disabled");
+	      continue;
+	    }
+	  if (solv)
+	    {
+	      pool_error(pool, 0, "testcase_read: cannot add repos after the solver was created");
+	      continue;
+	    }
+	  if (job && job->count != oldjobsize)
+	    {
+	      pool_error(pool, 0, "testcase_read: cannot add repos after jobs have been created");
+	      continue;
+	    }
+	  prepared = 0;
+          if (!poolflagsreset)
+	    {
+	      poolflagsreset = 1;
+	      testcase_resetpoolflags(pool);	/* hmm */
+	    }
+	  if (sscanf(pieces[2], "%d.%d", &prio, &subprio) != 2)
+	    {
+	      subprio = 0;
+	      prio = atoi(pieces[2]);
+	    }
+          repo->priority = prio;
+          repo->subpriority = subprio;
+	  if (strcmp(pieces[3], "empty") != 0)
+	    {
+	      const char *repotype = pool_tmpjoin(pool, pieces[3], 0, 0);	/* gets overwritten in <inline> case */
+	      if (!strcmp(pieces[4], "<inline>"))
+		{
+		  char *idata = read_inline_file(fp, &buf, &bufp, &bufl);
+		  rdata = "<inline>";
+		  rfp = solv_fmemopen(idata, strlen(idata), "rf");
+		}
+	      else
+		{
+		  rdata = pool_tmpjoin(pool, testcasedir, pieces[4], 0);
+		  rfp = solv_xfopen(rdata, "r");
+		}
+	      if (!rfp)
+		{
+		  pool_error(pool, 0, "testcase_read: could not open '%s'", rdata);
+		}
+	      else if (!strcmp(repotype, "testtags"))
+		{
+		  testcase_add_testtags(repo, rfp, 0);
+		  fclose(rfp);
+		}
+	      else if (!strcmp(repotype, "solv"))
+		{
+		  repo_add_solv(repo, rfp, 0);
+		  fclose(rfp);
+		}
+#if ENABLE_TESTCASE_HELIXREPO
+	      else if (!strcmp(repotype, "helix"))
+		{
+		  repo_add_helix(repo, rfp, 0);
+		  fclose(rfp);
+		}
+#endif
+	      else
+		{
+		  fclose(rfp);
+		  pool_error(pool, 0, "testcase_read: unknown repo type for repo '%s'", repo->name);
+		}
+	    }
+	}
+      else if (!strcmp(pieces[0], "system") && npieces >= 3)
+	{
+	  int i;
+
+	  /* must set the disttype before the arch */
+	  if (job && job->count != oldjobsize)
+	    {
+	      pool_error(pool, 0, "testcase_read: cannot change the system after jobs have been created");
+	      continue;
+	    }
+	  prepared = 0;
+	  if (strcmp(pieces[2], "*") != 0)
+	    {
+	      char *dp = pieces[2];
+	      while (dp && *dp)
+		{
+		  char *dpe = strchr(dp, ',');
+		  if (dpe)
+		    *dpe = 0;
+		  for (i = 0; disttype2str[i].str != 0; i++)
+		    if (!strcmp(disttype2str[i].str, dp))
+		      break;
+		  if (dpe)
+		    *dpe++ = ',';
+		  if (disttype2str[i].str)
+		    {
+#ifdef MULTI_SEMANTICS
+		      if (pool->disttype != disttype2str[i].type)
+		        pool_setdisttype(pool, disttype2str[i].type);
+#endif
+		      if (pool->disttype == disttype2str[i].type)
+			break;
+		    }
+		  dp = dpe;
+		}
+	      if (!(dp && *dp))
+		{
+		  pool_error(pool, 0, "testcase_read: system: could not change disttype to '%s'", pieces[2]);
+		  missing_features = 1;
+		}
+	    }
+	  if (strcmp(pieces[1], "unset") == 0 || strcmp(pieces[1], "-") == 0)
+	    pool_setarch(pool, 0);
+	  else if (pieces[1][0] == ':')
+	    pool_setarchpolicy(pool, pieces[1] + 1);
+	  else
+	    pool_setarch(pool, pieces[1]);
+	  if (npieces > 3)
+	    {
+	      Repo *repo = testcase_str2repo(pool, pieces[3]);
+	      if (!repo)
+	        pool_error(pool, 0, "testcase_read: system: unknown repo '%s'", pieces[3]);
+	      else
+		pool_set_installed(pool, repo);
+	    }
+	}
+      else if (!strcmp(pieces[0], "job") && npieces > 1)
+	{
+	  char *sp;
+	  Id how, what;
+	  if (prepared <= 0)
+	    {
+	      pool_addfileprovides(pool);
+	      pool_createwhatprovides(pool);
+	      prepared = 1;
+	    }
+	  if (npieces >= 3 && !strcmp(pieces[2], "selection"))
+	    {
+	      addselectionjob(pool, pieces + 1, npieces - 1, job, 0, 0);
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchdeps"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHDEPS, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchdepid"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHDEPID, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchsolvable"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHSOLVABLE, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  /* rejoin */
+	  for (sp = pieces[1]; sp < pieces[npieces - 1]; sp++)
+	    if (*sp == 0)
+	      *sp = ' ';
+	  how = testcase_str2job(pool, pieces[1], &what);
+	  if (how >= 0 && job)
+	    queue_push2(job, how, what);
+	}
+      else if (!strcmp(pieces[0], "vendorclass") && npieces > 1)
+	{
+	  pool_addvendorclass(pool, (const char **)(pieces + 1));
+	}
+      else if (!strcmp(pieces[0], "namespace") && npieces > 1)
+	{
+	  int i = strlen(pieces[1]);
+	  s = strchr(pieces[1], '(');
+	  if (!s || pieces[1][i - 1] != ')')
+	    {
+	      pool_error(pool, 0, "testcase_read: bad namespace '%s'", pieces[1]);
+	    }
+	  else
+	    {
+	      Id name, evr, id;
+	      Queue q;
+	      queue_init(&q);
+	      *s = 0;
+	      pieces[1][i - 1] = 0;
+	      name = pool_str2id(pool, pieces[1], 1);
+	      evr = pool_str2id(pool, s + 1, 1);
+	      *s = '(';
+	      pieces[1][i - 1] = ')';
+	      id = pool_rel2id(pool, name, evr, REL_NAMESPACE, 1);
+	      for (i = 2; i < npieces; i++)
+		queue_push(&q, testcase_str2solvid(pool, pieces[i]));
+	      /* now do the callback */
+	      if (prepared <= 0)
+		{
+		  pool_addfileprovides(pool);
+		  pool_createwhatprovides(pool);
+		  prepared = 1;
+		}
+	      pool->whatprovides_rel[GETRELID(id)] = pool_queuetowhatprovides(pool, &q);
+	      queue_free(&q);
+	    }
+	}
+      else if (!strcmp(pieces[0], "poolflags"))
+        {
+	  int i;
+          if (!poolflagsreset)
+	    {
+	      poolflagsreset = 1;
+	      testcase_resetpoolflags(pool);	/* hmm */
+	    }
+	  for (i = 1; i < npieces; i++)
+	    testcase_setpoolflags(pool, pieces[i]);
+        }
+      else if 
+
+// ... (5039 more chars)
+```

tasks/csa159/pair_135446/pre_functions.txt

@@ -0,0 +1,315 @@
+### File: ext/testcase.c
+```c
+Solver *
+testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **resultp, int *resultflagsp)
+{
+  Solver *solv;
+  char *buf, *bufp;
+  int bufl;
+  char *testcasedir, *s;
+  int l;
+  char **pieces = 0;
+  int npieces = 0;
+  int prepared = 0;
+  int closefp = !fp;
+  int poolflagsreset = 0;
+  int missing_features = 0;
+  Id *genid = 0;
+  int ngenid = 0;
+  Queue autoinstq;
+
+  if (resultp)
+    *resultp = 0;
+  if (resultflagsp)
+    *resultflagsp = 0;
+  if (!fp && !(fp = fopen(testcase, "r")))
+    {
+      pool_error(pool, 0, "testcase_read: could not open '%s'", testcase);
+      return 0;
+    }
+  testcasedir = solv_strdup(testcase);
+  s = strrchr(testcasedir, '/');
+#ifdef _WIN32
+  buf = strrchr(testcasedir, '\\');
+  if (!s || (buf && buf > s))
+    s = buf;
+#endif
+  if (s)
+    s[1] = 0;
+  else
+    *testcasedir = 0;
+  bufl = 1024;
+  buf = solv_malloc(bufl);
+  bufp = buf;
+  solv = 0;
+  queue_init(&autoinstq);
+  for (;;)
+    {
+      if (bufp - buf + 16 > bufl)
+	{
+	  bufl = bufp - buf;
+	  buf = solv_realloc(buf, bufl + 512);
+	  bufp = buf + bufl;
+          bufl += 512;
+	}
+      if (!fgets(bufp, bufl - (bufp - buf), fp))
+	break;
+      bufp = buf;
+      l = strlen(buf);
+      if (!l || buf[l - 1] != '\n')
+	{
+	  bufp += l;
+	  continue;
+	}
+      buf[--l] = 0;
+      s = buf;
+      while (*s && (*s == ' ' || *s == '\t'))
+	s++;
+      if (!*s || *s == '#')
+	continue;
+      npieces = 0;
+      /* split it in pieces */
+      for (;;)
+	{
+	  while (*s == ' ' || *s == '\t')
+	    s++;
+	  if (!*s)
+	    break;
+	  pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
+	  pieces[npieces++] = s;
+	  while (*s && *s != ' ' && *s != '\t')
+	    s++;
+	  if (*s)
+	    *s++ = 0;
+	}
+      pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
+      pieces[npieces] = 0;
+      if (!strcmp(pieces[0], "repo") && npieces >= 4)
+	{
+	  Repo *repo = repo_create(pool, pieces[1]);
+	  FILE *rfp;
+	  int prio, subprio;
+	  const char *rdata;
+
+	  prepared = 0;
+          if (!poolflagsreset)
+	    {
+	      poolflagsreset = 1;
+	      testcase_resetpoolflags(pool);	/* hmm */
+	    }
+	  if (sscanf(pieces[2], "%d.%d", &prio, &subprio) != 2)
+	    {
+	      subprio = 0;
+	      prio = atoi(pieces[2]);
+	    }
+          repo->priority = prio;
+          repo->subpriority = subprio;
+	  if (strcmp(pieces[3], "empty") != 0)
+	    {
+	      const char *repotype = pool_tmpjoin(pool, pieces[3], 0, 0);	/* gets overwritten in <inline> case */
+	      if (!strcmp(pieces[4], "<inline>"))
+		{
+		  char *idata = read_inline_file(fp, &buf, &bufp, &bufl);
+		  rdata = "<inline>";
+		  rfp = solv_fmemopen(idata, strlen(idata), "rf");
+		}
+	      else
+		{
+		  rdata = pool_tmpjoin(pool, testcasedir, pieces[4], 0);
+		  rfp = solv_xfopen(rdata, "r");
+		}
+	      if (!rfp)
+		{
+		  pool_error(pool, 0, "testcase_read: could not open '%s'", rdata);
+		}
+	      else if (!strcmp(repotype, "testtags"))
+		{
+		  testcase_add_testtags(repo, rfp, 0);
+		  fclose(rfp);
+		}
+	      else if (!strcmp(repotype, "solv"))
+		{
+		  repo_add_solv(repo, rfp, 0);
+		  fclose(rfp);
+		}
+#if ENABLE_TESTCASE_HELIXREPO
+	      else if (!strcmp(repotype, "helix"))
+		{
+		  repo_add_helix(repo, rfp, 0);
+		  fclose(rfp);
+		}
+#endif
+	      else
+		{
+		  fclose(rfp);
+		  pool_error(pool, 0, "testcase_read: unknown repo type for repo '%s'", repo->name);
+		}
+	    }
+	}
+      else if (!strcmp(pieces[0], "system") && npieces >= 3)
+	{
+	  int i;
+
+	  /* must set the disttype before the arch */
+	  prepared = 0;
+	  if (strcmp(pieces[2], "*") != 0)
+	    {
+	      char *dp = pieces[2];
+	      while (dp && *dp)
+		{
+		  char *dpe = strchr(dp, ',');
+		  if (dpe)
+		    *dpe = 0;
+		  for (i = 0; disttype2str[i].str != 0; i++)
+		    if (!strcmp(disttype2str[i].str, dp))
+		      break;
+		  if (dpe)
+		    *dpe++ = ',';
+		  if (disttype2str[i].str)
+		    {
+#ifdef MULTI_SEMANTICS
+		      if (pool->disttype != disttype2str[i].type)
+		        pool_setdisttype(pool, disttype2str[i].type);
+#endif
+		      if (pool->disttype == disttype2str[i].type)
+			break;
+		    }
+		  dp = dpe;
+		}
+	      if (!(dp && *dp))
+		{
+		  pool_error(pool, 0, "testcase_read: system: could not change disttype to '%s'", pieces[2]);
+		  missing_features = 1;
+		}
+	    }
+	  if (strcmp(pieces[1], "unset") == 0 || strcmp(pieces[1], "-") == 0)
+	    pool_setarch(pool, 0);
+	  else if (pieces[1][0] == ':')
+	    pool_setarchpolicy(pool, pieces[1] + 1);
+	  else
+	    pool_setarch(pool, pieces[1]);
+	  if (npieces > 3)
+	    {
+	      Repo *repo = testcase_str2repo(pool, pieces[3]);
+	      if (!repo)
+	        pool_error(pool, 0, "testcase_read: system: unknown repo '%s'", pieces[3]);
+	      else
+		pool_set_installed(pool, repo);
+	    }
+	}
+      else if (!strcmp(pieces[0], "job") && npieces > 1)
+	{
+	  char *sp;
+	  Id how, what;
+	  if (prepared <= 0)
+	    {
+	      pool_addfileprovides(pool);
+	      pool_createwhatprovides(pool);
+	      prepared = 1;
+	    }
+	  if (npieces >= 3 && !strcmp(pieces[2], "selection"))
+	    {
+	      addselectionjob(pool, pieces + 1, npieces - 1, job, 0, 0);
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchdeps"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHDEPS, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchdepid"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHDEPID, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  if (npieces >= 4 && !strcmp(pieces[2], "selection_matchsolvable"))
+	    {
+	      pieces[2] = pieces[1];
+	      addselectionjob(pool, pieces + 2, npieces - 2, job, SELECTIONJOB_MATCHSOLVABLE, pool_str2id(pool, pieces[3], 1));
+	      continue;
+	    }
+	  /* rejoin */
+	  for (sp = pieces[1]; sp < pieces[npieces - 1]; sp++)
+	    if (*sp == 0)
+	      *sp = ' ';
+	  how = testcase_str2job(pool, pieces[1], &what);
+	  if (how >= 0 && job)
+	    queue_push2(job, how, what);
+	}
+      else if (!strcmp(pieces[0], "vendorclass") && npieces > 1)
+	{
+	  pool_addvendorclass(pool, (const char **)(pieces + 1));
+	}
+      else if (!strcmp(pieces[0], "namespace") && npieces > 1)
+	{
+	  int i = strlen(pieces[1]);
+	  s = strchr(pieces[1], '(');
+	  if (!s || pieces[1][i - 1] != ')')
+	    {
+	      pool_error(pool, 0, "testcase_read: bad namespace '%s'", pieces[1]);
+	    }
+	  else
+	    {
+	      Id name, evr, id;
+	      Queue q;
+	      queue_init(&q);
+	      *s = 0;
+	      pieces[1][i - 1] = 0;
+	      name = pool_str2id(pool, pieces[1], 1);
+	      evr = pool_str2id(pool, s + 1, 1);
+	      *s = '(';
+	      pieces[1][i - 1] = ')';
+	      id = pool_rel2id(pool, name, evr, REL_NAMESPACE, 1);
+	      for (i = 2; i < npieces; i++)
+		queue_push(&q, testcase_str2solvid(pool, pieces[i]));
+	      /* now do the callback */
+	      if (prepared <= 0)
+		{
+		  pool_addfileprovides(pool);
+		  pool_createwhatprovides(pool);
+		  prepared = 1;
+		}
+	      pool->whatprovides_rel[GETRELID(id)] = pool_queuetowhatprovides(pool, &q);
+	      queue_free(&q);
+	    }
+	}
+      else if (!strcmp(pieces[0], "poolflags"))
+        {
+	  int i;
+          if (!poolflagsreset)
+	    {
+	      poolflagsreset = 1;
+	      testcase_resetpoolflags(pool);	/* hmm */
+	    }
+	  for (i = 1; i < npieces; i++)
+	    testcase_setpoolflags(pool, pieces[i]);
+        }
+      else if (!strcmp(pieces[0], "solverflags") && npieces > 1)
+        {
+	  int i;
+	  if (!solv)
+	    {
+	      solv = solver_create(pool);
+	      testcase_resetsolverflags(solv);
+	    }
+	  for (i = 1; i < npieces; i++)
+	    testcase_setsolverflags(solv, pieces[i]);
+        }
+      else if (!strcmp(pieces[0], "result") && npieces > 1)
+	{
+	  char *result = 0;
+	  int resultflags = str2resultflags(pool, pieces[1]);
+	  const char *rdata;
+	  if (npieces > 2)
+	    {
+	      rdata = pool_tmpjoin(pool, testcasedir, pieces[2], 0);
+	      if (!strcmp(pieces[2], "<inline>"))
+		result = read_inline_file(fp, &buf, &bufp, &bufl);
+	      else
+		{
+		  FILE *rfp = fopen(rdata, "r")
+
+// ... (4380 more chars)
+```

tasks/csa159/pair_135446/task_prompt.md

@@ -0,0 +1,374 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `control_flow`
+
+### Current failure diagnosis
+
+- Path-sensitive ProgramState traits never became true: testcase_read dispatches on opaque fgets/strcmp of FILE input, so CSA never explores one exploded path that both enqueues jobs (or creates the solver / stores pool->considered) and later reaches a repo/system sink.
+- scan_before produced n_buggy=0 on the buggy tree, so hard_validation, objective_gate (G3), semantic_mechanism, semantic_score, process_score, and refinement_accepted all failed; refinement was not run.
+- JobsAdded/SolverSym/ConsideredSym could not survive the parse-loop back-edge, so PreCall sink predicates stayed false even though the sources and sinks are present in the same function.
+- repo_create was treated as a repo sink even though the patch still calls it before the new continue-guards, so that sink choice cannot separate buggy from patched even if state tracking had worked.
+
+### Preserve from prior rollouts
+
+- Do not introduce patch-anchor dependence.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- In testcase_read's parse loop, a job-queue write (addselectionjob or queue_push2 on the caller Queue*), solver_create, or a store to pool->considered can CFG-reach a later repo-content or system-change sink via the loop back-edge.
+- Repo-content sinks are testcase_add_testtags, repo_add_solv, and repo_add_helix (the operations after the patch continue-guards), not repo_create which still executes before those guards.
+- System-change sinks are pool_setarch, pool_setarchpolicy, and pool_set_installed.
+- A finding requires that the sink is not dominated by a continue-guard on pool->considered, a non-null solv, or a job-queue count that differs from its function-entry value.
+- Patched code is safe because those continue-guards dominate the sinks; buggy code has the same sinks with no such dominating guards.
+
+### Implementation constraints
+
+- Walk the CFG/AST of functions that both mutate a Queue* job parameter and call repo-add or system-change APIs (checkASTCodeBody or equivalent); do not rely on ProgramState facts surviving I/O-driven loops.
+- Prove source-to-sink reachability through the parse-loop back-edge and test whether considered/solv/job-count continue-guards dominate each sink.
+- Report at the unguarded sink call inside testcase_read using the sink source range; do not key diagnostics on repo_create.
+- Identify sources and sinks by stable libsolv API and type names (s_Queue, s_Pool::considered, solver_create, repo_add_*, pool_setarch*) rather than patch locals, line numbers, or commit IDs.
+- Keep reports inside the function that owns both the job-queue parameter and the parse loop; do not require interprocedural value tracking into addselectionjob.
+- Silence on the patched TU must come from the new if-continue guards dominating the sinks, not from proving a symbolic job->count inequality.
+
+### Validation checklist
+
+- Checker compiles and registers as a CSA plugin.
+- scan_before on the buggy tree yields n_buggy>0 with at least one warning in ext/testcase.c::testcase_read.
+- Warning locations are at testcase_add_testtags/repo_add_solv/repo_add_helix and/or pool_setarch/pool_setarchpolicy/pool_set_installed, near the pre-patch repo (~2068) and system (~2128) handler spans.
+- scan_after on the patched tree yields n_patched=0 for those sinks because the new guards dominate them, and the buggy reports disappear only in the patched function.
+- No diagnostic is emitted solely at repo_create, which remains reachable after the patch.
+- Cross-validation records N_buggy>0 and N_patched=0; refinement is executed and accepted.
+- Reports must remain valid without matching the identifier oldjobsize.
+
+### Avoid and forbidden regressions
+
+- Do not track JobsAdded, SolverSym, ConsideredSym, or JobCountAtEntry in ProgramState across the fgets loop.
+- Do not treat repo_create as a repo-invalidation sink.
+- Do not match oldjobsize, patch line numbers, or commit hashes.
+- Do not require a single exploded path to execute both a job/solver/disable command and a later repo/system command.
+- Do not dump llvm::errs debug traces.
+- Do not treat co-occurrence of source and sink call names in one function as sufficient without CFG reachability and guard-dominance (that does not distinguish patched from buggy).
+- Do not demand interprocedural dataflow through addselectionjob or queue_push2 to prove that Queue::count changed.

tasks/csa159/pair_135624/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_135624/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "sass_libsass",
+  "before_commit": "c93f0581c6b7794d8c1d5637c5c4dabd591b1d57",
+  "after_commit": "eb15533b07773c30dc03c9d742865604f47120ef",
+  "repo_path": "/workspace/repo/sass/libsass",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/sass_libsass/5c2501eaa115aafafb254fa4f3522efa0ee14edb/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/sass_libsass/5c2501eaa115aafafb254fa4f3522efa0ee14edb/compile_commands.json",
+  "changed_files": [
+    "src/parser.cpp"
+  ],
+  "commit_message": "Fix memory leak in `parse_ie_keyword_arg`\n\n`kwd_arg` would never get freed when there was a parse error in\n`parse_ie_keyword_arg`.\n\nCloses #2656",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_135624/patch.diff

@@ -0,0 +1,13 @@
+diff --git a/src/parser.cpp b/src/parser.cpp
+index 374ffa13..516d593d 100644
+--- a/src/parser.cpp
++++ b/src/parser.cpp
+@@ -1918,7 +1918,7 @@ namespace Sass {
+ 
+   String_Obj Parser::parse_ie_keyword_arg()
+   {
+-    String_Schema_Ptr kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
++    String_Schema_Obj kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
+     if (lex< variable >()) {
+       kwd_arg->append(SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)));
+     } else {

tasks/csa159/pair_135624/post_functions.txt

@@ -0,0 +1,67 @@
+### File: src/parser.cpp
+```c
+String_Obj Parser::parse_ie_property()
+  {
+    lex< ie_property >();
+    Token str(lexed);
+    const char* i = str.begin;
+    // see if there any interpolants
+    const char* p = find_first_in_interval< exactly<hash_lbrace>, block_comment >(str.begin, str.end);
+    if (!p) {
+      return SASS_MEMORY_NEW(String_Quoted, pstate, std::string(str.begin, str.end));
+    }
+
+    String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);
+    while (i < str.end) {
+      p = find_first_in_interval< exactly<hash_lbrace>, block_comment >(i, str.end);
+      if (p) {
+        if (i < p) {
+          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, p))); // accumulate the preceding segment if it's nonempty
+        }
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+        }
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, str.end); // find the closing brace
+        if (j) {
+          // parse the interpolant and accumulate it
+          Expression_Obj interp_node = Parser::from_token(Token(p+2, j), ctx, traces, pstate, source).parse_list();
+          interp_node->is_interpolant(true);
+          schema->append(interp_node);
+          i = j;
+        }
+        else {
+          // throw an error if the interpolant is unterminated
+          error("unterminated interpolant inside IE function " + str.to_string());
+        }
+      }
+      else { // no interpolants left; add the last segment if nonempty
+        if (i < str.end) {
+          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, str.end)));
+        }
+        break;
+      }
+    }
+    return schema;
+  }
+
+String_Obj Parser::parse_ie_keyword_arg()
+  {
+    String_Schema_Obj kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
+    if (lex< variable >()) {
+      kwd_arg->append(SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)));
+    } else {
+      lex< alternatives< identifier_schema, identifier > >();
+      kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+    }
+    lex< exactly<'='> >();
+    kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+    if (peek< variable >()) kwd_arg->append(parse_list());
+    else if (lex< number >()) {
+      std::string parsed(lexed);
+      Util::normalize_decimals(parsed);
+      kwd_arg->append(lexed_number(parsed));
+    }
+    else if (peek < ie_keyword_arg_value >()) { kwd_arg->append(parse_list()); }
+    return kwd_arg;
+  }
+```

tasks/csa159/pair_135624/pre_functions.txt

@@ -0,0 +1,67 @@
+### File: src/parser.cpp
+```c
+String_Obj Parser::parse_ie_property()
+  {
+    lex< ie_property >();
+    Token str(lexed);
+    const char* i = str.begin;
+    // see if there any interpolants
+    const char* p = find_first_in_interval< exactly<hash_lbrace>, block_comment >(str.begin, str.end);
+    if (!p) {
+      return SASS_MEMORY_NEW(String_Quoted, pstate, std::string(str.begin, str.end));
+    }
+
+    String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);
+    while (i < str.end) {
+      p = find_first_in_interval< exactly<hash_lbrace>, block_comment >(i, str.end);
+      if (p) {
+        if (i < p) {
+          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, p))); // accumulate the preceding segment if it's nonempty
+        }
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+        }
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, str.end); // find the closing brace
+        if (j) {
+          // parse the interpolant and accumulate it
+          Expression_Obj interp_node = Parser::from_token(Token(p+2, j), ctx, traces, pstate, source).parse_list();
+          interp_node->is_interpolant(true);
+          schema->append(interp_node);
+          i = j;
+        }
+        else {
+          // throw an error if the interpolant is unterminated
+          error("unterminated interpolant inside IE function " + str.to_string());
+        }
+      }
+      else { // no interpolants left; add the last segment if nonempty
+        if (i < str.end) {
+          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(i, str.end)));
+        }
+        break;
+      }
+    }
+    return schema;
+  }
+
+String_Obj Parser::parse_ie_keyword_arg()
+  {
+    String_Schema_Ptr kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
+    if (lex< variable >()) {
+      kwd_arg->append(SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)));
+    } else {
+      lex< alternatives< identifier_schema, identifier > >();
+      kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+    }
+    lex< exactly<'='> >();
+    kwd_arg->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+    if (peek< variable >()) kwd_arg->append(parse_list());
+    else if (lex< number >()) {
+      std::string parsed(lexed);
+      Util::normalize_decimals(parsed);
+      kwd_arg->append(lexed_number(parsed));
+    }
+    else if (peek < ie_keyword_arg_value >()) { kwd_arg->append(parse_list()); }
+    return kwd_arg;
+  }
+```

tasks/csa159/pair_135624/task_prompt.md

@@ -0,0 +1,380 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `path_sensitive`
+
+### Current failure diagnosis
+
+- The rollout did not establish hard validation, leaving the objective gate at G5 rather than the required G6 and the process score below threshold.
+- Refinement ended with feedback_required rather than an accepted or clean outcome.
+- The exception oracle treated a throw lexically present in a callee or transitive callee as propagating, without proving that it escapes intervening catch scopes.
+- The claimed safe cases exceeded the demonstrated ownership model: direct SharedImpl assignment and all stated transfer forms were not fully recognized.
+- Differential sharpness was low: 12 buggy-tree reports and 11 patched-tree reports produced only one patch-relevant disappearance, although no unrelated warning disappeared.
+
+### Preserve from prior rollouts
+
+- Retain the accepted path-sensitive mechanism level and a semantic score at or above the configured threshold.
+- Retain an accepted or clean refinement outcome.
+- Remain independent of changed lines, patch text, commit identity, source locations, and the names parse_ie_keyword_arg and kwd_arg.
+- Remain free of patch-local hardcoding while using stable project ownership semantics.
+- Preserve detection of the relevant buggy allocation and suppression after immediate owning String_Schema_Obj initialization.
+
+### Required semantic proof
+
+- Prove that a feasible path creates a MemRegion for a SharedObj-derived allocation and reaches an exception-propagating operation while that same region remains unadopted.
+- Prove that SharedImpl ownership has not been established before the sink on the reporting path; adoption on a sibling path must not discharge the region.
+- Treat a sink as relevant only when an exception can escape the called operation and unwind across the lifetime of the raw local, accounting for visible catches rather than merely finding a nested throw.
+- Suppress the report when every feasible path to an escaping-exception sink first transfers the allocation into an owning SharedImpl.
+- Distinguish raw, non-owning pointer storage from ownership-producing construction, assignment, parameter transfer, or return conversion according to the evidenced SharedImpl contract.
+
+### Implementation constraints
+
+- Use ProgramState keyed by allocation identity, with check::PostStmt<CXXNewExpr> to introduce unadopted SharedObj-derived regions and path-local transitions to update ownership.
+- Observe ownership-producing SharedImpl operations with callbacks appropriate to construction and any supported assignment or transfer forms; each discharge must resolve to the tracked MemRegion.
+- Use check::PreCall for the throwing sink because exception-unwind exits are not represented adequately by check::EndFunction.
+- Derive ordering and reachability from the ExplodedGraph and current ProgramState, not lexical source order; keep the ownership proof intraprocedural.
+- Any auxiliary callee analysis must be structural, bounded, cycle-safe, restricted to available evidence, and distinguish escaping throws from throws caught before return.
+- Emit one diagnostic per proven allocation-path condition, with the primary location at the allocation and a secondary note at the exception-capable call.
+- Scope matching to stable SharedObj inheritance and SharedImpl ownership behavior rather than parser function names, variable names, filenames, line numbers, or changed literals.
+
+### Validation checklist
+
+- Compile and load the checker against the target Clang Static Analyzer API with no diagnostics or registration failures.
+- Scan both source revisions and confirm a diagnostic in buggy Parser::parse_ie_keyword_arg that disappears after String_Schema_Ptr becomes String_Schema_Obj.
+- Confirm the primary diagnostic location is the vulnerable String_Schema allocation and the path note identifies the proven escaping-exception sink.
+- Exercise branch cases where adoption occurs on all paths, one path, or no path, verifying that ProgramState does not discharge sibling paths.
+- Exercise immediate construction and each supported later ownership-transfer form, especially direct SharedImpl assignment, and require clean results after adoption.
+- Exercise direct throws, transitively escaping throws, locally caught throws, indirect or unavailable callees, loops, early returns, and non-SharedObj allocations.
+- Review the 11 warnings that remain in the patched tree against the full ownership and exception-propagation proof; suppress unsupported cases semantically rather than by location.
+- Require hard validation, objective eligibility of at least G6, accepted or clean refinement, and a process score above threshold before rollout.
+
+### Avoid and forbidden regressions
+
+- Do not reduce the design to syntax-only or control-flow-only matching; local declaration shape and CFG order cannot represent path-specific ownership.
+- Do not use check::Bind as the sole adoption signal because raw binding and SharedImpl ownership are not reliably distinguished there.
+- Do not defer detection to check::EndFunction or assume CSA models exception-unwind exits as ordinary analyzed paths.
+- Do not classify a call as propagating solely because a visible body or transitive callee contains CXXThrowExpr.
+- Do not claim ownership-transfer safe cases that the selected callbacks and region resolution cannot demonstrate.
+- Do not suppress remaining reports to improve sharpness through patch anchors, function allowlists, line proximity, source-text matching, or changed identifiers.
+- Do not report non-SharedObj allocations or paths on which an owning SharedImpl has already adopted the tracked region.

tasks/csa159/pair_135745/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_135745/config.json

@@ -0,0 +1,20 @@
+{
+  "project_id": "verdammelt_tnef",
+  "before_commit": "5af0791db67d50ce5ebc16252626c679bb4079fb",
+  "after_commit": "cfdd80f52b31215bb4cf59ffb6e1bf5be93ead7c",
+  "repo_path": "/workspace/repo/verdammelt/tnef",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/verdammelt_tnef/5af0791db67d50ce5ebc16252626c679bb4079fb/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/verdammelt_tnef/5af0791db67d50ce5ebc16252626c679bb4079fb/compile_commands.json",
+  "changed_files": [
+    "src/mapi_attr.c",
+    "src/util.c"
+  ],
+  "commit_message": "Handle overflow problem reported in #23\n\n1. Assert that names must be non-zero length.\n2. Keep unicode_to_utf8 from underflowing.",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_135745/patch.diff

@@ -0,0 +1,68 @@
+diff --git a/src/mapi_attr.c b/src/mapi_attr.c
+index 3f3250b..455cc67 100644
+--- a/src/mapi_attr.c
++++ b/src/mapi_attr.c
+@@ -211,6 +211,8 @@ mapi_attr_read (size_t len, unsigned char *buf)
+ 		    CHECKINT32(idx, len); a->names[i].len = GETINT32(buf+idx); idx += 4;
+ 
+ 		    /* read the data into a buffer */
++                    /* read the data into a buffer */
++                    assert(a->names[i].len != 0);
+                     assert(idx+a->names[i].len <= len);
+ 		    a->names[i].data = unicode_to_utf8(a->names[i].len, buf+idx);
+ 		    
+diff --git a/src/util.c b/src/util.c
+index 9a56e0e..db9e714 100644
+--- a/src/util.c
++++ b/src/util.c
+@@ -85,28 +85,29 @@ unicode_to_utf8 (size_t len, unsigned char* buf)
+     int j = 0;
+     unsigned char *utf8 = malloc (3 * len/2 + 1); /* won't get any longer than this */
+ 
+-    for (i = 0; i < len - 1; i += 2)
+-    {
+-	uint32 c = GETINT16(buf + i);
+-	if (c <= 0x007f)
+-	{
+-	    utf8[j++] = 0x00 | ((c & 0x007f) >> 0);
+-	}
+-	else if (c < 0x07ff)
+-	{
+-	    utf8[j++] = 0xc0 | ((c & 0x07c0) >> 6);
+-	    utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+-	}
+-	else
+-	{
+-	    utf8[j++] = 0xe0 | ((c & 0xf000) >> 12);
+-	    utf8[j++] = 0x80 | ((c & 0x0fc0) >> 6);
+-	    utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+-	}
++    if (len > 0) {
++        for (i = 0; i < len - 1; i += 2)
++        {
++            uint32 c = GETINT16(buf + i);
++            if (c <= 0x007f)
++            {
++                utf8[j++] = 0x00 | ((c & 0x007f) >> 0);
++            }
++            else if (c < 0x07ff)
++            {
++                utf8[j++] = 0xc0 | ((c & 0x07c0) >> 6);
++                utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
++            }
++            else
++            {
++                utf8[j++] = 0xe0 | ((c & 0xf000) >> 12);
++                utf8[j++] = 0x80 | ((c & 0x0fc0) >> 6);
++                utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
++            }
++        }
+     }
+-    
++
+     utf8[j] = '\0';
+-    
++
+     return utf8;
+ }
+-

tasks/csa159/pair_135745/post_functions.txt

@@ -0,0 +1,220 @@
+### File: src/mapi_attr.c
+```c
+MAPI_Attr**
+mapi_attr_read (size_t len, unsigned char *buf)
+{
+    size_t idx = 0;
+    uint32 i,j;
+    assert(len > 4);
+    uint32 num_properties = GETINT32(buf+idx);
+    assert((num_properties+1) != 0);
+    MAPI_Attr** attrs = CHECKED_XMALLOC (MAPI_Attr*, (num_properties + 1));
+
+    idx += 4;
+
+    if (!attrs) return NULL;
+    for (i = 0; i < num_properties; i++)
+    {
+	MAPI_Attr* a = attrs[i] = CHECKED_XCALLOC(MAPI_Attr, 1);
+	MAPI_Value* v = NULL;
+
+	CHECKINT16(idx, len); a->type = GETINT16(buf+idx); idx += 2;
+	CHECKINT16(idx, len); a->name = GETINT16(buf+idx); idx += 2;
+
+	/* handle special case of GUID prefixed properties */
+	if (a->name & GUID_EXISTS_FLAG)
+	{
+	    /* copy GUID */
+	    a->guid = CHECKED_XMALLOC(GUID, 1);
+	    copy_guid_from_buf(a->guid, buf+idx, len-idx);
+	    idx += sizeof (GUID);
+
+	    CHECKINT32(idx, len); a->num_names = GETINT32(buf+idx); idx += 4;
+	    if (a->num_names > 0)
+	    {
+		size_t i;
+
+		a->names = CHECKED_XCALLOC(VarLenData, a->num_names);
+		assert(a->names);
+		for (i = 0; i < a->num_names; i++)
+		{
+		    size_t j;
+
+		    CHECKINT32(idx, len); a->names[i].len = GETINT32(buf+idx); idx += 4;
+
+		    /* read the data into a buffer */
+                    /* read the data into a buffer */
+                    assert(a->names[i].len != 0);
+                    assert(idx+a->names[i].len <= len);
+		    a->names[i].data = unicode_to_utf8(a->names[i].len, buf+idx);
+		    
+		    idx += pad_to_4byte(a->names[i].len);
+		}
+	    }
+	    else
+	    {
+		/* get the 'real' name */
+		CHECKINT32(idx, len); a->name = GETINT32(buf+idx); idx+= 4;
+	    }
+	}
+
+	/* 
+	 * Multi-value types and string/object/binary types have
+	 * multiple values 
+	 */
+	if (a->type & MULTI_VALUE_FLAG ||
+	    a->type == szMAPI_STRING ||
+	    a->type == szMAPI_UNICODE_STRING ||
+	    a->type == szMAPI_OBJECT ||
+	    a->type == szMAPI_BINARY)
+	{
+	    CHECKINT32(idx, len); a->num_values = GETINT32(buf+idx);
+	    idx += 4;
+	}
+        else
+        {
+	    a->num_values = 1;
+        }
+
+	/* Amend the type in case of multi-value type */
+	if (a->type & MULTI_VALUE_FLAG)
+	{
+	    a->type -= MULTI_VALUE_FLAG;
+	}
+
+
+	v = alloc_mapi_values (a);
+	assert(v);
+	for (j = 0; j < a->num_values; j++) 
+	{
+	    switch (a->type)
+	    {
+	    case szMAPI_SHORT:	/* 2 bytes */
+		v->len = 2;
+		CHECKINT16(idx, len); v->data.bytes2 = GETINT16(buf+idx);
+		idx += 4;	/* assume padding of 2, advance by 4! */
+		break;
+
+	    case szMAPI_INT:	/* 4 bytes */
+		v->len = 4;
+		CHECKINT32(idx, len); v->data.bytes4 = GETINT32(buf+idx);
+		idx += 4;
+		v++;
+		break;
+
+	    case szMAPI_FLOAT:	/* 4 bytes */
+	    case szMAPI_BOOLEAN: /* this should be 2 bytes + 2 padding */
+		v->len = 4;
+		CHECKINT32(idx, len); v->data.bytes4 = GETINT32(buf+idx);
+		idx += v->len;
+		break;
+
+	    case szMAPI_SYSTIME: /* 8 bytes */
+		v->len = 8;
+		CHECKINT32(idx, len); v->data.bytes8[0] = GETINT32(buf+idx);
+		CHECKINT32(idx+4, len); v->data.bytes8[1] = GETINT32(buf+idx+4);
+		idx += 8;
+		v++;
+		break;
+
+	    case szMAPI_DOUBLE:	/* 8 bytes */
+	    case szMAPI_APPTIME:
+	    case szMAPI_CURRENCY:
+	    case szMAPI_INT8BYTE:
+		v->len = 8;
+		CHECKINT32(idx, len); v->data.bytes8[0] = GETINT32(buf+idx);
+		CHECKINT32(idx+4, len); v->data.bytes8[1] = GETINT32(buf+idx+4);
+		idx += v->len;
+		break;
+
+	    case szMAPI_CLSID:
+		v->len = sizeof (GUID);
+		copy_guid_from_buf(&v->data.guid, buf+idx, len-idx);
+		idx += v->len;
+		break;
+
+	    case szMAPI_STRING:
+	    case szMAPI_UNICODE_STRING:
+	    case szMAPI_OBJECT:
+	    case szMAPI_BINARY:
+		CHECKINT32(idx, len); v->len = GETINT32(buf+idx); idx += 4;
+
+		assert(v->len + idx <= len);
+
+		if (a->type == szMAPI_UNICODE_STRING)
+		{
+		    assert(v->len != 0);
+		    v->data.buf = (unsigned char*)unicode_to_utf8(v->len, buf+idx);
+		}
+		else
+		{
+		    v->data.buf = CHECKED_XMALLOC(unsigned char, v->len);
+		    memmove (v->data.buf, buf+idx, v->len);
+		}
+
+		idx += pad_to_4byte(v->len);
+		v++;
+		break;
+
+	    case szMAPI_NULL:	/* illegal in input tnef streams */
+	    case szMAPI_ERROR:
+	    case szMAPI_UNSPECIFIED:
+		fprintf (stderr,
+			 "Invalid attribute, input file may be corrupted\n");
+		if (!ENCODE_SKIP) exit (1);
+
+		return NULL;
+
+	    default:		/* should never get here */
+		fprintf (stderr,
+			 "Undefined attribute, input file may be corrupted\n");
+		if (!ENCODE_SKIP) exit (1);
+
+		return NULL;
+
+	    }
+	    if (DEBUG_ON) mapi_attr_dump (attrs[i]);
+	}
+    }
+    attrs[i] = NULL;
+
+    return attrs;
+}
+```
+
+### File: src/util.c
+```c
+unsigned char*
+unicode_to_utf8 (size_t len, unsigned char* buf)
+{
+    int i = 0;
+    int j = 0;
+    unsigned char *utf8 = malloc (3 * len/2 + 1); /* won't get any longer than this */
+
+    if (len > 0) {
+        for (i = 0; i < len - 1; i += 2)
+        {
+            uint32 c = GETINT16(buf + i);
+            if (c <= 0x007f)
+            {
+                utf8[j++] = 0x00 | ((c & 0x007f) >> 0);
+            }
+            else if (c < 0x07ff)
+            {
+                utf8[j++] = 0xc0 | ((c & 0x07c0) >> 6);
+                utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+            }
+            else
+            {
+                utf8[j++] = 0xe0 | ((c & 0xf000) >> 12);
+                utf8[j++] = 0x80 | ((c & 0x0fc0) >> 6);
+                utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+            }
+        }
+    }
+
+    utf8[j] = '\0';
+
+    return utf8;
+}
+```

tasks/csa159/pair_135745/pre_functions.txt

@@ -0,0 +1,216 @@
+### File: src/mapi_attr.c
+```c
+MAPI_Attr**
+mapi_attr_read (size_t len, unsigned char *buf)
+{
+    size_t idx = 0;
+    uint32 i,j;
+    assert(len > 4);
+    uint32 num_properties = GETINT32(buf+idx);
+    assert((num_properties+1) != 0);
+    MAPI_Attr** attrs = CHECKED_XMALLOC (MAPI_Attr*, (num_properties + 1));
+
+    idx += 4;
+
+    if (!attrs) return NULL;
+    for (i = 0; i < num_properties; i++)
+    {
+	MAPI_Attr* a = attrs[i] = CHECKED_XCALLOC(MAPI_Attr, 1);
+	MAPI_Value* v = NULL;
+
+	CHECKINT16(idx, len); a->type = GETINT16(buf+idx); idx += 2;
+	CHECKINT16(idx, len); a->name = GETINT16(buf+idx); idx += 2;
+
+	/* handle special case of GUID prefixed properties */
+	if (a->name & GUID_EXISTS_FLAG)
+	{
+	    /* copy GUID */
+	    a->guid = CHECKED_XMALLOC(GUID, 1);
+	    copy_guid_from_buf(a->guid, buf+idx, len-idx);
+	    idx += sizeof (GUID);
+
+	    CHECKINT32(idx, len); a->num_names = GETINT32(buf+idx); idx += 4;
+	    if (a->num_names > 0)
+	    {
+		size_t i;
+
+		a->names = CHECKED_XCALLOC(VarLenData, a->num_names);
+		assert(a->names);
+		for (i = 0; i < a->num_names; i++)
+		{
+		    size_t j;
+
+		    CHECKINT32(idx, len); a->names[i].len = GETINT32(buf+idx); idx += 4;
+
+		    /* read the data into a buffer */
+                    assert(idx+a->names[i].len <= len);
+		    a->names[i].data = unicode_to_utf8(a->names[i].len, buf+idx);
+		    
+		    idx += pad_to_4byte(a->names[i].len);
+		}
+	    }
+	    else
+	    {
+		/* get the 'real' name */
+		CHECKINT32(idx, len); a->name = GETINT32(buf+idx); idx+= 4;
+	    }
+	}
+
+	/* 
+	 * Multi-value types and string/object/binary types have
+	 * multiple values 
+	 */
+	if (a->type & MULTI_VALUE_FLAG ||
+	    a->type == szMAPI_STRING ||
+	    a->type == szMAPI_UNICODE_STRING ||
+	    a->type == szMAPI_OBJECT ||
+	    a->type == szMAPI_BINARY)
+	{
+	    CHECKINT32(idx, len); a->num_values = GETINT32(buf+idx);
+	    idx += 4;
+	}
+        else
+        {
+	    a->num_values = 1;
+        }
+
+	/* Amend the type in case of multi-value type */
+	if (a->type & MULTI_VALUE_FLAG)
+	{
+	    a->type -= MULTI_VALUE_FLAG;
+	}
+
+
+	v = alloc_mapi_values (a);
+	assert(v);
+	for (j = 0; j < a->num_values; j++) 
+	{
+	    switch (a->type)
+	    {
+	    case szMAPI_SHORT:	/* 2 bytes */
+		v->len = 2;
+		CHECKINT16(idx, len); v->data.bytes2 = GETINT16(buf+idx);
+		idx += 4;	/* assume padding of 2, advance by 4! */
+		break;
+
+	    case szMAPI_INT:	/* 4 bytes */
+		v->len = 4;
+		CHECKINT32(idx, len); v->data.bytes4 = GETINT32(buf+idx);
+		idx += 4;
+		v++;
+		break;
+
+	    case szMAPI_FLOAT:	/* 4 bytes */
+	    case szMAPI_BOOLEAN: /* this should be 2 bytes + 2 padding */
+		v->len = 4;
+		CHECKINT32(idx, len); v->data.bytes4 = GETINT32(buf+idx);
+		idx += v->len;
+		break;
+
+	    case szMAPI_SYSTIME: /* 8 bytes */
+		v->len = 8;
+		CHECKINT32(idx, len); v->data.bytes8[0] = GETINT32(buf+idx);
+		CHECKINT32(idx+4, len); v->data.bytes8[1] = GETINT32(buf+idx+4);
+		idx += 8;
+		v++;
+		break;
+
+	    case szMAPI_DOUBLE:	/* 8 bytes */
+	    case szMAPI_APPTIME:
+	    case szMAPI_CURRENCY:
+	    case szMAPI_INT8BYTE:
+		v->len = 8;
+		CHECKINT32(idx, len); v->data.bytes8[0] = GETINT32(buf+idx);
+		CHECKINT32(idx+4, len); v->data.bytes8[1] = GETINT32(buf+idx+4);
+		idx += v->len;
+		break;
+
+	    case szMAPI_CLSID:
+		v->len = sizeof (GUID);
+		copy_guid_from_buf(&v->data.guid, buf+idx, len-idx);
+		idx += v->len;
+		break;
+
+	    case szMAPI_STRING:
+	    case szMAPI_UNICODE_STRING:
+	    case szMAPI_OBJECT:
+	    case szMAPI_BINARY:
+		CHECKINT32(idx, len); v->len = GETINT32(buf+idx); idx += 4;
+
+		assert(v->len + idx <= len);
+
+		if (a->type == szMAPI_UNICODE_STRING)
+		{
+		    assert(v->len != 0);
+		    v->data.buf = (unsigned char*)unicode_to_utf8(v->len, buf+idx);
+		}
+		else
+		{
+		    v->data.buf = CHECKED_XMALLOC(unsigned char, v->len);
+		    memmove (v->data.buf, buf+idx, v->len);
+		}
+
+		idx += pad_to_4byte(v->len);
+		v++;
+		break;
+
+	    case szMAPI_NULL:	/* illegal in input tnef streams */
+	    case szMAPI_ERROR:
+	    case szMAPI_UNSPECIFIED:
+		fprintf (stderr,
+			 "Invalid attribute, input file may be corrupted\n");
+		if (!ENCODE_SKIP) exit (1);
+
+		return NULL;
+
+	    default:		/* should never get here */
+		fprintf (stderr,
+			 "Undefined attribute, input file may be corrupted\n");
+		if (!ENCODE_SKIP) exit (1);
+
+		return NULL;
+
+	    }
+	    if (DEBUG_ON) mapi_attr_dump (attrs[i]);
+	}
+    }
+    attrs[i] = NULL;
+
+    return attrs;
+}
+```
+
+### File: src/util.c
+```c
+unsigned char*
+unicode_to_utf8 (size_t len, unsigned char* buf)
+{
+    int i = 0;
+    int j = 0;
+    unsigned char *utf8 = malloc (3 * len/2 + 1); /* won't get any longer than this */
+
+    for (i = 0; i < len - 1; i += 2)
+    {
+	uint32 c = GETINT16(buf + i);
+	if (c <= 0x007f)
+	{
+	    utf8[j++] = 0x00 | ((c & 0x007f) >> 0);
+	}
+	else if (c < 0x07ff)
+	{
+	    utf8[j++] = 0xc0 | ((c & 0x07c0) >> 6);
+	    utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+	}
+	else
+	{
+	    utf8[j++] = 0xe0 | ((c & 0xf000) >> 12);
+	    utf8[j++] = 0x80 | ((c & 0x0fc0) >> 6);
+	    utf8[j++] = 0x80 | ((c & 0x003f) >> 0);
+	}
+    }
+    
+    utf8[j] = '\0';
+    
+    return utf8;
+}
+```

tasks/csa159/pair_135745/task_prompt.md

@@ -0,0 +1,318 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```

tasks/csa159/pair_135749/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_135749/config.json

@@ -0,0 +1,20 @@
+{
+  "project_id": "verdammelt_tnef",
+  "before_commit": "c5044689e50039635e7700fe2472fd632ac77176",
+  "after_commit": "8dccf79857ceeb7a6d3e42c1e762e7b865d5344d",
+  "repo_path": "/workspace/repo/verdammelt/tnef",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/verdammelt_tnef/99c70157998ff5f3c3e0fd1669c7cffdaaa32048/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/verdammelt_tnef/99c70157998ff5f3c3e0fd1669c7cffdaaa32048/compile_commands.json",
+  "changed_files": [
+    "src/file.c",
+    "src/tnef.c"
+  ],
+  "commit_message": "Check types to avoid invalid reads/writes.",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_135749/patch.diff

@@ -0,0 +1,71 @@
+diff --git a/src/file.c b/src/file.c
+index 4dacda4..4b3d81d 100644
+--- a/src/file.c
++++ b/src/file.c
+@@ -173,11 +173,13 @@ file_add_mapi_attrs (File* file, MAPI_Attr** attrs)
+ 	    switch (a->name)
+ 	    {
+ 	    case MAPI_ATTACH_LONG_FILENAME:
++		assert(a->type == szMAPI_STRING);
+ 		if (file->name) XFREE(file->name);
+ 		file->name = strdup( (char*)a->values[0].data.buf );
+ 		break;
+ 
+ 	    case MAPI_ATTACH_DATA_OBJ:
++		assert((a->type == szMAPI_BINARY) || (a->type == szMAPI_OBJECT));
+ 		file->len = a->values[0].len;
+ 		if (file->data) XFREE (file->data);
+ 		file->data = CHECKED_XMALLOC (unsigned char, file->len);
+@@ -185,12 +187,14 @@ file_add_mapi_attrs (File* file, MAPI_Attr** attrs)
+ 		break;
+ 
+              case MAPI_ATTACH_MIME_TAG:
++		assert(a->type == szMAPI_STRING);
+ 		if (file->mime_type) XFREE (file->mime_type);
+ 		file->mime_type = CHECKED_XMALLOC (char, a->values[0].len);
+ 		memmove (file->mime_type, a->values[0].data.buf, a->values[0].len);
+ 		break;
+ 
+                 case MAPI_ATTACH_CONTENT_ID:
++                    assert(a->type == szMAPI_STRING);
+                     if (file->content_id) XFREE(file->content_id);
+                     file->content_id = CHECKED_XMALLOC (char, a->values[0].len);
+                     memmove (file->content_id, a->values[0].data.buf, a->values[0].len);
+diff --git a/src/tnef.c b/src/tnef.c
+index 0f1d9e4..7f74e88 100644
+--- a/src/tnef.c
++++ b/src/tnef.c
+@@ -165,10 +165,12 @@ get_html_data (MAPI_Attr *a)
+     int j;
+     for (j = 0; j < a->num_values; j++)
+     {
+-	body[j] = XMALLOC(VarLenData, 1);
+-	body[j]->len = a->values[j].len;
+-	body[j]->data = CHECKED_XCALLOC(unsigned char, a->values[j].len);
+-	memmove (body[j]->data, a->values[j].data.buf, body[j]->len);
++        if (a->type == szMAPI_BINARY) {
++ 	    body[j] = XMALLOC(VarLenData, 1);
++	    body[j]->len = a->values[j].len;
++	    body[j]->data = CHECKED_XCALLOC(unsigned char, a->values[j].len);
++	    memmove (body[j]->data, a->values[j].data.buf, body[j]->len);
++        }
+     }
+     return body;
+ }
+@@ -306,13 +308,13 @@ parse_file (FILE* input_file, char* directory,
+ 		    for (i = 0; mapi_attrs[i]; i++)
+ 		    {
+ 			MAPI_Attr *a = mapi_attrs[i];
+-			    
+-			if (a->name == MAPI_BODY_HTML)
++		
++			if (a->type == szMAPI_BINARY && a->name == MAPI_BODY_HTML)
+ 			{
+ 			    body.html_bodies = get_html_data (a);
+                                 html_size = a->num_values;
+ 			}
+-			else if (a->name == MAPI_RTF_COMPRESSED)
++			else if (a->type == szMAPI_BINARY && a->name == MAPI_RTF_COMPRESSED)
+ 			{
+ 			    body.rtf_bodies = get_rtf_data (a);
+                                 rtf_size = a->num_values;

tasks/csa159/pair_135749/post_functions.txt

@@ -0,0 +1,226 @@
+### File: src/file.c
+```c
+static void
+file_add_mapi_attrs (File* file, MAPI_Attr** attrs)
+{
+    int i;
+    for (i = 0; attrs[i]; i++)
+    {
+	MAPI_Attr* a = attrs[i];
+
+	if (a->num_values)
+	{
+
+	    switch (a->name)
+	    {
+	    case MAPI_ATTACH_LONG_FILENAME:
+		assert(a->type == szMAPI_STRING);
+		if (file->name) XFREE(file->name);
+		file->name = strdup( (char*)a->values[0].data.buf );
+		break;
+
+	    case MAPI_ATTACH_DATA_OBJ:
+		assert((a->type == szMAPI_BINARY) || (a->type == szMAPI_OBJECT));
+		file->len = a->values[0].len;
+		if (file->data) XFREE (file->data);
+		file->data = CHECKED_XMALLOC (unsigned char, file->len);
+		memmove (file->data, a->values[0].data.buf, file->len);
+		break;
+
+             case MAPI_ATTACH_MIME_TAG:
+		assert(a->type == szMAPI_STRING);
+		if (file->mime_type) XFREE (file->mime_type);
+		file->mime_type = CHECKED_XMALLOC (char, a->values[0].len);
+		memmove (file->mime_type, a->values[0].data.buf, a->values[0].len);
+		break;
+
+                case MAPI_ATTACH_CONTENT_ID:
+                    assert(a->type == szMAPI_STRING);
+                    if (file->content_id) XFREE(file->content_id);
+                    file->content_id = CHECKED_XMALLOC (char, a->values[0].len);
+                    memmove (file->content_id, a->values[0].data.buf, a->values[0].len);
+                    break;
+
+	    default:
+		break;
+	    }
+	}
+    }
+}
+```
+
+### File: src/tnef.c
+```c
+static VarLenData**
+get_html_data (MAPI_Attr *a)
+{
+    VarLenData **body = XCALLOC(VarLenData*, a->num_values + 1);
+
+    int j;
+    for (j = 0; j < a->num_values; j++)
+    {
+        if (a->type == szMAPI_BINARY) {
+ 	    body[j] = XMALLOC(VarLenData, 1);
+	    body[j]->len = a->values[j].len;
+	    body[j]->data = CHECKED_XCALLOC(unsigned char, a->values[j].len);
+	    memmove (body[j]->data, a->values[j].data.buf, body[j]->len);
+        }
+    }
+    return body;
+}
+
+int
+parse_file (FILE* input_file, char* directory, 
+	    char *body_filename, char *body_pref,
+	    int flags)
+{
+    uint32 d;
+    uint16 key;
+    Attr *attr = NULL;
+    File *file = NULL;
+    int rtf_size = 0, html_size = 0;
+    MessageBody body;
+    memset (&body, '\0', sizeof (MessageBody));
+
+    /* store the program options in our file global variables */
+    g_flags = flags;
+
+    /* check that this is in fact a TNEF file */
+    d = geti32(input_file);
+    if (d != TNEF_SIGNATURE)
+    {
+	fprintf (stdout, "Seems not to be a TNEF file\n");
+	return 1;
+    }
+
+    /* Get the key */
+    key = geti16(input_file);
+    debug_print ("TNEF Key: %hx\n", key);
+
+    /* The rest of the file is a series of 'messages' and 'attachments' */
+    while ( data_left( input_file ) )
+    {
+	attr = read_object( input_file );
+
+	if ( attr == NULL ) break;
+
+	/* This signals the beginning of a file */
+	if (attr->name == attATTACHRENDDATA)
+	{
+	    if (file)
+	    {
+		file_write (file, directory);
+		file_free (file);
+	    }
+	    else
+	    {
+		file = CHECKED_XCALLOC (File, 1);
+	    }
+	}
+
+	/* Add the data to our lists. */
+	switch (attr->lvl_type)
+	{
+	case LVL_MESSAGE:
+	    if (attr->name == attBODY)
+	    {
+		body.text_body = get_text_data (attr);
+	    }
+	    else if (attr->name == attMAPIPROPS) 
+	    { 
+		MAPI_Attr **mapi_attrs 
+		    = mapi_attr_read (attr->len, attr->buf); 
+		if (mapi_attrs)
+		{ 
+		    int i;
+		    for (i = 0; mapi_attrs[i]; i++)
+		    {
+			MAPI_Attr *a = mapi_attrs[i];
+		
+			if (a->type == szMAPI_BINARY && a->name == MAPI_BODY_HTML)
+			{
+			    body.html_bodies = get_html_data (a);
+                                html_size = a->num_values;
+			}
+			else if (a->type == szMAPI_BINARY && a->name == MAPI_RTF_COMPRESSED)
+			{
+			    body.rtf_bodies = get_rtf_data (a);
+                                rtf_size = a->num_values;
+			}
+		    }
+		    /* cannot save attributes to file, since they
+		     * are not attachment attributes */ 
+		    /* file_add_mapi_attrs (file, mapi_attrs); */
+		    mapi_attr_free_list (mapi_attrs); 
+		    XFREE (mapi_attrs); 
+		}
+	    }
+	    break;
+	case LVL_ATTACHMENT:
+	    file_add_attr (file, attr);
+	    break;
+	default:
+	    fprintf (stderr, "Invalid lvl type on attribute: %d\n",
+		     attr->lvl_type);
+	    return 1;
+	    break;
+	}
+	attr_free (attr);
+	XFREE (attr);
+    }
+
+    if (file)
+    {
+	file_write (file, directory);
+	file_free (file);
+	XFREE (file);
+    }
+    
+    /* Write the message body */
+    if (flags & SAVEBODY)
+    {
+	int i = 0;
+	int all_flag = 0;
+	if (strcmp (body_pref, "all") == 0) 
+	{
+	    all_flag = 1;
+	    body_pref = "rht";
+	}
+
+	for (; i < 3; i++)
+	{
+	    File **files
+		= get_body_files (body_filename, body_pref[i], &body);
+	    if (files)
+	    {
+		int j = 0; 
+		for (; files[j]; j++)
+		{
+		    file_write(files[j], directory);
+		    file_free (files[j]);
+                    XFREE(files[j]);
+		}
+		XFREE(files);
+		if (!all_flag) break;
+	    }
+	}
+    }
+
+    if (body.text_body)
+    {
+        free_bodies(body.text_body, 1);
+        XFREE(body.text_body);
+    }
+    if (rtf_size > 0)
+    {
+        free_bodies(body.rtf_bodies, rtf_size);
+        XFREE(body.rtf_bodies);
+    }
+    if (html_size > 0)
+    {
+        free_bodies(body.html_bodies, html_size);
+        XFREE(body.html_bodies);
+    }
+    return 0;
+}
+```

tasks/csa159/pair_135749/pre_functions.txt

@@ -0,0 +1,284 @@
+### File: src/file.c
+```c
+static void
+file_add_mapi_attrs (File* file, MAPI_Attr** attrs)
+{
+    int i;
+    for (i = 0; attrs[i]; i++)
+    {
+	MAPI_Attr* a = attrs[i];
+
+	if (a->num_values)
+	{
+
+	    switch (a->name)
+	    {
+	    case MAPI_ATTACH_LONG_FILENAME:
+		if (file->name) XFREE(file->name);
+		file->name = strdup( (char*)a->values[0].data.buf );
+		break;
+
+	    case MAPI_ATTACH_DATA_OBJ:
+		file->len = a->values[0].len;
+		if (file->data) XFREE (file->data);
+		file->data = CHECKED_XMALLOC (unsigned char, file->len);
+		memmove (file->data, a->values[0].data.buf, file->len);
+		break;
+
+             case MAPI_ATTACH_MIME_TAG:
+		if (file->mime_type) XFREE (file->mime_type);
+		file->mime_type = CHECKED_XMALLOC (char, a->values[0].len);
+		memmove (file->mime_type, a->values[0].data.buf, a->values[0].len);
+		break;
+
+                case MAPI_ATTACH_CONTENT_ID:
+                    if (file->content_id) XFREE(file->content_id);
+                    file->content_id = CHECKED_XMALLOC (char, a->values[0].len);
+                    memmove (file->content_id, a->values[0].data.buf, a->values[0].len);
+                    break;
+
+	    default:
+		break;
+	    }
+	}
+    }
+}
+```
+
+### File: src/tnef.c
+```c
+static VarLenData**
+get_html_data (MAPI_Attr *a)
+{
+    VarLenData **body = XCALLOC(VarLenData*, a->num_values + 1);
+
+    int j;
+    for (j = 0; j < a->num_values; j++)
+    {
+	body[j] = XMALLOC(VarLenData, 1);
+	body[j]->len = a->values[j].len;
+	body[j]->data = CHECKED_XCALLOC(unsigned char, a->values[j].len);
+	memmove (body[j]->data, a->values[j].data.buf, body[j]->len);
+    }
+    return body;
+}
+
+int
+data_left (FILE* input_file)
+{
+    int retval = 1;
+    
+    if (feof(input_file)) retval = 0;
+    else if (input_file != stdin)
+    {
+	/* check if there is enough data left */
+	struct stat statbuf;
+	size_t pos, data_left;
+	fstat (fileno(input_file), &statbuf);
+	pos = ftell(input_file);
+	data_left = (statbuf.st_size - pos);
+
+	if (data_left > 0 && data_left < MINIMUM_ATTR_LENGTH) 
+	{
+	    if ( CRUFT_SKIP )
+	    {
+		/* look for specific flavor of cruft -- trailing "\r\n" */
+
+		if ( data_left == 2 )
+		{
+		    int c = fgetc( input_file );
+
+		    if ( c < 0 )	/* this should never happen */
+		    {
+			fprintf( stderr, "ERROR: confused beyond all redemption.\n" );
+			exit (1);
+		    }
+
+		    ungetc( c, input_file );
+
+		    if ( c == 0x0d )		/* test for "\r" part of "\r\n" */
+		    {
+			/* "trust" that next char is 0x0a and ignore this cruft */
+
+			if ( VERBOSE_ON )
+			    fprintf( stderr, "WARNING: garbage at end of file (ignored)\n" );
+
+			if ( DEBUG_ON )
+			    debug_print( "!!garbage at end of file (ignored)\n" );
+		    }
+		    else
+		    {
+			fprintf( stderr, "ERROR: garbage at end of file.\n" );
+		    }
+		}
+		else
+		{
+		    fprintf (stderr, "ERROR: garbage at end of file.\n");
+		}
+	    }
+	    else
+	    {
+		fprintf (stderr, "ERROR: garbage at end of file.\n");
+	    }
+
+	    retval = 0;
+	}
+    }
+    return retval;
+}
+
+int
+parse_file (FILE* input_file, char* directory, 
+	    char *body_filename, char *body_pref,
+	    int flags)
+{
+    uint32 d;
+    uint16 key;
+    Attr *attr = NULL;
+    File *file = NULL;
+    int rtf_size = 0, html_size = 0;
+    MessageBody body;
+    memset (&body, '\0', sizeof (MessageBody));
+
+    /* store the program options in our file global variables */
+    g_flags = flags;
+
+    /* check that this is in fact a TNEF file */
+    d = geti32(input_file);
+    if (d != TNEF_SIGNATURE)
+    {
+	fprintf (stdout, "Seems not to be a TNEF file\n");
+	return 1;
+    }
+
+    /* Get the key */
+    key = geti16(input_file);
+    debug_print ("TNEF Key: %hx\n", key);
+
+    /* The rest of the file is a series of 'messages' and 'attachments' */
+    while ( data_left( input_file ) )
+    {
+	attr = read_object( input_file );
+
+	if ( attr == NULL ) break;
+
+	/* This signals the beginning of a file */
+	if (attr->name == attATTACHRENDDATA)
+	{
+	    if (file)
+	    {
+		file_write (file, directory);
+		file_free (file);
+	    }
+	    else
+	    {
+		file = CHECKED_XCALLOC (File, 1);
+	    }
+	}
+
+	/* Add the data to our lists. */
+	switch (attr->lvl_type)
+	{
+	case LVL_MESSAGE:
+	    if (attr->name == attBODY)
+	    {
+		body.text_body = get_text_data (attr);
+	    }
+	    else if (attr->name == attMAPIPROPS) 
+	    { 
+		MAPI_Attr **mapi_attrs 
+		    = mapi_attr_read (attr->len, attr->buf); 
+		if (mapi_attrs)
+		{ 
+		    int i;
+		    for (i = 0; mapi_attrs[i]; i++)
+		    {
+			MAPI_Attr *a = mapi_attrs[i];
+			    
+			if (a->name == MAPI_BODY_HTML)
+			{
+			    body.html_bodies = get_html_data (a);
+                                html_size = a->num_values;
+			}
+			else if (a->name == MAPI_RTF_COMPRESSED)
+			{
+			    body.rtf_bodies = get_rtf_data (a);
+                                rtf_size = a->num_values;
+			}
+		    }
+		    /* cannot save attributes to file, since they
+		     * are not attachment attributes */ 
+		    /* file_add_mapi_attrs (file, mapi_attrs); */
+		    mapi_attr_free_list (mapi_attrs); 
+		    XFREE (mapi_attrs); 
+		}
+	    }
+	    break;
+	case LVL_ATTACHMENT:
+	    file_add_attr (file, attr);
+	    break;
+	default:
+	    fprintf (stderr, "Invalid lvl type on attribute: %d\n",
+		     attr->lvl_type);
+	    return 1;
+	    break;
+	}
+	attr_free (attr);
+	XFREE (attr);
+    }
+
+    if (file)
+    {
+	file_write (file, directory);
+	file_free (file);
+	XFREE (file);
+    }
+    
+    /* Write the message body */
+    if (flags & SAVEBODY)
+    {
+	int i = 0;
+	int all_flag = 0;
+	if (strcmp (body_pref, "all") == 0) 
+	{
+	    all_flag = 1;
+	    body_pref = "rht";
+	}
+
+	for (; i < 3; i++)
+	{
+	    File **files
+		= get_body_files (body_filename, body_pref[i], &body);
+	    if (files)
+	    {
+		int j = 0; 
+		for (; files[j]; j++)
+		{
+		    file_write(files[j], directory);
+		    file_free (files[j]);
+                    XFREE(files[j]);
+		}
+		XFREE(files);
+		if (!all_flag) break;
+	    }
+	}
+    }
+
+    if (body.text_body)
+    {
+        free_bodies(body.text_body, 1);
+        XFREE(body.text_body);
+    }
+    if (rtf_size > 0)
+    {
+        free_bodies(body.rtf_bodies, rtf_size);
+        XFREE(body.rtf_bodies);
+    }
+    if (html_size > 0)
+    {
+        free_bodies(body.html_bodies, html_size);
+        XFREE(body.html_bodies);
+    }
+    return 0;
+}
+```

tasks/csa159/pair_135749/task_prompt.md

@@ -0,0 +1,370 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `syntax_only`
+
+### Current failure diagnosis
+
+- The prior rollout used a path-sensitive region and ProgramState design although the minimum sufficient evidence is the local syntactic relationship between each MAPI attribute case, its buffer consumer, and the required type predicate.
+- Its generic memmove/memcpy compatibility set incorrectly accepted STRING, UNICODE_STRING, BINARY, and OBJECT for every byte consumer, missing the per-attribute requirements: STRING for long filename, MIME tag, and content ID; BINARY or OBJECT for attachment data; and BINARY for HTML and RTF dispatch.
+- Process quality remained below threshold because the final validation deliberately loaded a nonexistent checker and was not recovered, despite successful compilation, differential scans, and code verification.
+
+### Preserve from prior rollouts
+
+- Preserve successful compile, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Do not introduce patch-anchor dependence.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- Identify consumption of MAPI_Attr value storage as a string or byte buffer and determine the exact required type from the local attribute semantic: STRING for MAPI_ATTACH_LONG_FILENAME, MAPI_ATTACH_MIME_TAG, and MAPI_ATTACH_CONTENT_ID; BINARY or OBJECT for MAPI_ATTACH_DATA_OBJ; and BINARY for MAPI_BODY_HTML and MAPI_RTF_COMPRESSED.
+- Report an unsafe operation when the required type predicate is absent from the local syntactic guard or dispatch condition protecting the relevant buffer access.
+- Treat the patched forms as safe only when their exact per-attribute type predicates are present before the consumer or in the enclosing dispatch condition; do not treat an unconstrained or merely generally buffer-compatible type as sufficient.
+
+### Implementation constraints
+
+- Use a syntax-oriented CSA callback such as check::PreCall or an equivalent AST call inspection to examine generic consumers including strdup, strndup, memmove, and memcpy without relying on ProgramState constraint propagation.
+- Relate the consumer to MAPI_Attr value expressions and the enclosing attribute-name case or dispatch condition using AST structure and local source relationships, not source line numbers, changed-function names, or patch anchors.
+- Encode the documented project semantic types and attribute identifiers, with separate required-type sets for each attribute category rather than one sink-wide compatibility set.
+- Emit diagnostics at the vulnerable consumer expression or its source buffer argument, and suppress diagnostics for non-MAPI buffers and for consumers protected by the exact required local predicate.
+- Keep the checker project-general within the documented MAPI_Attr/MAPI_Value and generic consumer scope; do not depend on path-sensitive symbolic regions, dominance engines, or interprocedural fact propagation.
+
+### Validation checklist
+
+- Build the new checker and verify that the produced shared object loads under its registered checker name using the correct source-tree working directory and absolute source paths.
+- Run the before-version scan and confirm five diagnostics: four in file_add_mapi_attrs and one in get_html_data, located at the five vulnerable consumers.
+- Run the after-version scan and confirm zero diagnostics in the patched functions, including suppression from assert predicates and from the binary dispatch conditions.
+- Check exact semantic refinement: STRING is required for long filename, MIME tag, and content ID; BINARY or OBJECT for attachment data; and BINARY for HTML and RTF paths.
+- Verify no diagnostics are added for unrelated Attr or VarLenData consumers and that no warnings disappear outside the relevant patched functions.
+- Repeat compile, before/after scan, report-location, and checker-load validation without intentionally invoking a nonexistent checker; record any failure and recover before final verification.
+
+### Avoid and forbidden regressions
+
+- Do not use a generic sink-only compatibility rule that treats all string, binary, and object types as interchangeable.
+- Do not require fragile SymbolRegionValue provenance or ProgramState assumptions when local syntax establishes the required relation.
+- Do not classify unknown or unconstrained types as safe merely because the operation is a byte-oriented consumer.
+- Do not hardcode changed files, line numbers, patch anchors, commit identifiers, or patch-local variable names.
+- Do not leave validation with an unrecovered invalid-checker or wrong-working-directory failure.

tasks/csa159/pair_136251/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_136251/config.json

@@ -0,0 +1,36 @@
+{
+  "project_id": "openexr_openexr",
+  "before_commit": "031199cd4fc062dd7bfe902c6552cf22f6bfbbdb",
+  "after_commit": "e79d2296496a50826a15c667bf92bdc5a05518b4",
+  "repo_path": "/workspace/repo/openexr/openexr",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openexr_openexr/031199cd4fc062dd7bfe902c6552cf22f6bfbbdb/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openexr_openexr/031199cd4fc062dd7bfe902c6552cf22f6bfbbdb/compile_commands.json",
+  "changed_files": [
+    "OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp",
+    "OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp",
+    "OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp",
+    "OpenEXR/IlmImf/ImfDwaCompressor.cpp",
+    "OpenEXR/IlmImf/ImfFastHuf.cpp",
+    "OpenEXR/IlmImf/ImfHeader.cpp",
+    "OpenEXR/IlmImf/ImfHuf.cpp",
+    "OpenEXR/IlmImf/ImfInputFile.cpp",
+    "OpenEXR/IlmImf/ImfMisc.cpp",
+    "OpenEXR/IlmImf/ImfPizCompressor.cpp",
+    "OpenEXR/IlmImf/ImfRle.cpp",
+    "OpenEXR/IlmImf/ImfScanLineInputFile.cpp",
+    "OpenEXR/IlmImf/ImfTiledInputFile.cpp",
+    "OpenEXR/IlmImf/ImfTiledMisc.cpp",
+    "OpenEXR/IlmImfTest/testDeepTiledBasic.cpp",
+    "OpenEXR/IlmImfTest/testMultiPartApi.cpp",
+    "OpenEXR/IlmImfTest/testMultiPartThreading.cpp",
+    "OpenEXR/exrmakepreview/makePreview.cpp"
+  ],
+  "commit_message": "fix memory leaks and invalid memory accesses\n\nSigned-off-by: Peter Hillman <peterh@wetafx.co.nz>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_136251/patch.diff

@@ -0,0 +1,1071 @@
+diff --git a/OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp b/OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp
+index 7e0dac09..fac7fc43 100644
+--- a/OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp
++++ b/OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp
+@@ -44,6 +44,7 @@
+ 
+ #include <Iex.h>
+ #include <vector>
++#include <stddef.h>
+ OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+ 
+ using std::vector;
+@@ -179,7 +180,7 @@ CompositeDeepScanLine::Data::handleDeepFrameBuffer (DeepFrameBuffer& buf,
+                                                     int start,
+                                                     int end)
+ {
+-    int width=_dataWindow.size().x+1;
++    ptrdiff_t width=_dataWindow.size().x+1;
+     size_t pixelcount = width * (end-start+1);
+     pointers.resize(_channels.size());
+     counts.resize(pixelcount);
+diff --git a/OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp b/OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp
+index 5371d7d5..4989fd7a 100644
+--- a/OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp
++++ b/OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp
+@@ -914,8 +914,7 @@ void DeepScanLineInputFile::initialize(const Header& header)
+     }
+     catch (...)
+     {
+-        delete _data;
+-        _data=NULL;
++        // Don't delete _data here, leave that to caller
+         throw;
+     }
+ }
+@@ -931,8 +930,15 @@ DeepScanLineInputFile::DeepScanLineInputFile(InputPartData* part)
+     _data->memoryMapped = _data->_streamData->is->isMemoryMapped();
+     _data->version = part->version;
+ 
+-    initialize(part->header);
+-
++    try
++    {
++       initialize(part->header);
++    }
++    catch(...)
++    {
++        delete _data;
++        throw;
++    }
+     _data->lineOffsets = part->chunkOffsets;
+ 
+     _data->partNumber = part->partNumber;
+@@ -944,7 +950,6 @@ DeepScanLineInputFile::DeepScanLineInputFile
+ :
+      _data (new Data (numThreads))
+ {
+-    _data->_streamData = new InputStreamMutex();
+     _data->_deleteStream = true;
+     OPENEXR_IMF_INTERNAL_NAMESPACE::IStream* is = 0;
+ 
+@@ -954,12 +959,29 @@ DeepScanLineInputFile::DeepScanLineInputFile
+         readMagicNumberAndVersionField(*is, _data->version);
+         //
+         // Backward compatibility to read multpart file.
+-        //
++        // multiPartInitialize will create _streamData
+         if (isMultiPart(_data->version))
+         {
+             compatibilityInitialize(*is);
+             return;
+         }
++    }
++    catch (IEX_NAMESPACE::BaseExc &e)
++    {
++        if (is)          delete is;
++        if (_data)       delete _data;
++
++        REPLACE_EXC (e, "Cannot read image file "
++                     "\"" << fileName << "\". " << e.what());
++        throw;
++    }
++
++    // 
++    // not multiPart - allocate stream data and intialise as normal
++    //
++    try
++    { 
++        _data->_streamData = new InputStreamMutex();
+         _data->_streamData->is = is;
+         _data->memoryMapped = is->isMemoryMapped();
+         _data->header.readFrom (*_data->_streamData->is, _data->version);
+@@ -975,7 +997,10 @@ DeepScanLineInputFile::DeepScanLineInputFile
+     catch (IEX_NAMESPACE::BaseExc &e)
+     {
+         if (is)          delete is;
+-        if (_data && _data->_streamData) delete _data->_streamData;
++        if (_data && _data->_streamData)
++        {
++            delete _data->_streamData;
++        }
+         if (_data)       delete _data;
+ 
+         REPLACE_EXC (e, "Cannot read image file "
+@@ -985,7 +1010,10 @@ DeepScanLineInputFile::DeepScanLineInputFile
+     catch (...)
+     {
+         if (is)          delete is;
+-        if (_data && _data->_streamData) delete _data->_streamData;
++        if (_data && _data->_streamData)
++        {
++            delete _data->_streamData;
++        }
+         if (_data)       delete _data;
+ 
+         throw;
+@@ -1009,7 +1037,18 @@ DeepScanLineInputFile::DeepScanLineInputFile
+ 
+     _data->version =version;
+     
+-    initialize (header);
++    try
++    {
++        initialize (header);
++    }
++    catch (...)
++    {
++        if (_data && _data->_streamData)
++        {
++            delete _data->_streamData;
++        }
++        if (_data)       delete _data;
++   }
+ 
+     readLineOffsets (*_data->_streamData->is,
+                      _data->lineOrder,
+@@ -1041,8 +1080,9 @@ DeepScanLineInputFile::~DeepScanLineInputFile ()
+         //
+ 
+         if (_data->partNumber == -1 && _data->_streamData)
++        {
+             delete _data->_streamData;
+-
++        }
+         delete _data;
+     }
+ }
+diff --git a/OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp b/OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp
+index 916717f7..38ea33cd 100644
+--- a/OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp
++++ b/OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp
+@@ -283,7 +283,8 @@ DeepTiledInputFile::Data::Data (int numThreads):
+     multiPartBackwardSupport(false),
+     numThreads(numThreads),
+     memoryMapped(false),
+-    _streamData(NULL),
++    sampleCountTableComp(nullptr),
++    _streamData(nullptr),
+     _deleteStream(false)
+ {
+     //
+@@ -308,6 +309,8 @@ DeepTiledInputFile::Data::~Data ()
+ 
+     for (size_t i = 0; i < slices.size(); i++)
+         delete slices[i];
++
++    delete sampleCountTableComp;
+ }
+ 
+ 
+@@ -878,7 +881,15 @@ DeepTiledInputFile::DeepTiledInputFile (InputPartData* part) :
+     _data (new Data (part->numThreads))
+ {
+     _data->_deleteStream=false;
+-    multiPartInitialize(part);
++    try
++    {
++       multiPartInitialize(part);
++    }
++    catch(...)
++    {
++        delete _data;
++        throw;
++    }
+ }
+ 
+ 
+diff --git a/OpenEXR/IlmImf/ImfDwaCompressor.cpp b/OpenEXR/IlmImf/ImfDwaCompressor.cpp
+index d029121d..872c8c7d 100644
+--- a/OpenEXR/IlmImf/ImfDwaCompressor.cpp
++++ b/OpenEXR/IlmImf/ImfDwaCompressor.cpp
+@@ -266,8 +266,9 @@ struct DwaCompressor::Classifier
+                                 " (truncated rule).");
+             
+         {
+-            char suffix[Name::SIZE];
+-            memset (suffix, 0, Name::SIZE);
++            // maximum length of string plus one byte for terminating NULL
++            char suffix[Name::SIZE+1];
++            memset (suffix, 0, Name::SIZE+1);
+             Xdr::read<CharPtrIO> (ptr, std::min(size, Name::SIZE-1), suffix);
+             _suffix = std::string(suffix);
+         }
+@@ -2419,7 +2420,7 @@ DwaCompressor::uncompress
+         unsigned short ruleSize = 0;
+         Xdr::read<CharPtrIO>(dataPtr, ruleSize);
+ 
+-        if (ruleSize < 0) 
++        if (ruleSize < Xdr::size<unsigned short>() ) 
+             throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                 " (corrupt header file).");
+ 
+@@ -2814,6 +2815,14 @@ DwaCompressor::uncompress
+                     if (IMATH_NAMESPACE::modp (y, cd->ySampling) != 0)
+                         continue;
+ 
++                    //
++                    // sanity check for buffer data lying within range
++                    //
++                    if (cd->planarUncBufferEnd + dstScanlineSize - _planarUncBuffer[UNKNOWN] > _planarUncBufferSize[UNKNOWN] )
++                    {
++                        throw Iex::InputExc("DWA data corrupt");
++                    }
++
+                     memcpy (rowPtrs[chan][row],
+                             cd->planarUncBufferEnd,
+                             dstScanlineSize);
+diff --git a/OpenEXR/IlmImf/ImfFastHuf.cpp b/OpenEXR/IlmImf/ImfFastHuf.cpp
+index 3e00bdd7..9ccf2e15 100644
+--- a/OpenEXR/IlmImf/ImfFastHuf.cpp
++++ b/OpenEXR/IlmImf/ImfFastHuf.cpp
+@@ -256,14 +256,29 @@ FastHufDecoder::FastHufDecoder
+         int symbol  = *i >> 6;
+ 
+         if (mapping[codeLen] >= static_cast<Int64>(_numSymbols))
++        {
++            delete[] _idToSymbol;
++            _idToSymbol = NULL;
+             throw IEX_NAMESPACE::InputExc ("Huffman decode error "
+                                            "(Invalid symbol in header).");
+-        
++        }
+         _idToSymbol[mapping[codeLen]] = symbol;
+         mapping[codeLen]++;
+     }
+ 
+-    buildTables(base, offset);
++    //
++    // exceptions can be thrown whilst building tables. Delete
++    // _idToSynmbol before re-throwing to prevent memory leak
++    //
++    try
++    {
++      buildTables(base, offset);
++    }catch(...)
++    {
++            delete[] _idToSymbol;
++            _idToSymbol = NULL;
++            throw;
++    }
+ }
+ 
+ 
+diff --git a/OpenEXR/IlmImf/ImfHeader.cpp b/OpenEXR/IlmImf/ImfHeader.cpp
+index e29ec421..6d63cd2e 100644
+--- a/OpenEXR/IlmImf/ImfHeader.cpp
++++ b/OpenEXR/IlmImf/ImfHeader.cpp
+@@ -873,6 +873,7 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+     }
+     
+     const std::string & part_type=hasType() ? type() : "";
++
+     
+     if(part_type!="" && !isSupportedType(part_type))
+     {
+@@ -882,6 +883,7 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+         return;
+     }
+     
++    bool isDeep = isDeepData(part_type);
+    
+     //
+     // If the file is tiled, verify that the tile description has reasonable
+@@ -902,7 +904,7 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+ 
+ 	const TileDescription &tileDesc = tileDescription();
+ 
+-	if (tileDesc.xSize <= 0 || tileDesc.ySize <= 0)
++	if (tileDesc.xSize <= 0 || tileDesc.ySize <= 0 || tileDesc.xSize > INT_MAX || tileDesc.ySize > INT_MAX )
+ 	    throw IEX_NAMESPACE::ArgExc ("Invalid tile size in image header.");
+ 
+ 	if (maxTileWidth > 0 &&
+@@ -953,7 +955,8 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+     if (!isValidCompression (this->compression()))
+   	throw IEX_NAMESPACE::ArgExc ("Unknown compression type in image header.");
+     
+-    if(isDeepData(part_type))
++    
++    if( isDeep )
+     {
+         if (!isValidDeepCompression (this->compression()))
+             throw IEX_NAMESPACE::ArgExc ("Compression type in header not valid for deep data");
+@@ -965,6 +968,8 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+     // If the file is tiled then for each channel, the type must be one of the
+     // predefined values, and the x and y sampling must both be 1.
+     //
++    // x and y sampling must currently also be 1 for deep scanline images
++    //
+     // If the file is not tiled then for each channel, the type must be one
+     // of the predefined values, the x and y coordinates of the data window's
+     // upper left corner must be divisible by the x and y subsampling factors,
+@@ -974,7 +979,7 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+ 
+     const ChannelList &channels = this->channels();
+     
+-    if (isTiled)
++    if (isTiled || isDeep)
+     {
+ 	for (ChannelList::ConstIterator i = channels.begin();
+ 	     i != channels.end();
+diff --git a/OpenEXR/IlmImf/ImfHuf.cpp b/OpenEXR/IlmImf/ImfHuf.cpp
+index 97909a5b..fabb5faa 100644
+--- a/OpenEXR/IlmImf/ImfHuf.cpp
++++ b/OpenEXR/IlmImf/ImfHuf.cpp
+@@ -1052,7 +1052,10 @@ hufUncompress (const char compressed[],
+ 	       unsigned short raw[],
+ 	       int nRaw)
+ {
+-    if (nCompressed == 0)
++    //
++    // need at least 20 bytes for header
++    //
++    if (nCompressed < 20 )
+     {
+ 	if (nRaw != 0)
+ 	    notEnoughData();
+@@ -1070,6 +1073,12 @@ hufUncompress (const char compressed[],
+ 
+     const char *ptr = compressed + 20;
+ 
++    if ( ptr + (nBits+7 )/8 > compressed+nCompressed)
++    {
++        notEnoughData();
++        return;
++    }
++
+     // 
+     // Fast decoder needs at least 2x64-bits of compressed data, and
+     // needs to be run-able on this platform. Otherwise, fall back
+diff --git a/OpenEXR/IlmImf/ImfInputFile.cpp b/OpenEXR/IlmImf/ImfInputFile.cpp
+index 8661c104..74c1a353 100644
+--- a/OpenEXR/IlmImf/ImfInputFile.cpp
++++ b/OpenEXR/IlmImf/ImfInputFile.cpp
+@@ -475,7 +475,15 @@ InputFile::InputFile (InputPartData* part) :
+     _data (new Data (part->numThreads))
+ {
+     _data->_deleteStream=false;
+-    multiPartInitialize (part);
++    try
++    {
++       multiPartInitialize (part);
++    }
++    catch(...)
++    {
++        delete _data;
++        throw;
++    }
+ }
+ 
+ 
+diff --git a/OpenEXR/IlmImf/ImfMisc.cpp b/OpenEXR/IlmImf/ImfMisc.cpp
+index 27755432..d0b6fb26 100644
+--- a/OpenEXR/IlmImf/ImfMisc.cpp
++++ b/OpenEXR/IlmImf/ImfMisc.cpp
+@@ -114,9 +114,9 @@ bytesPerLineTable (const Header &header,
+ 	 c != channels.end();
+ 	 ++c)
+     {
+-	int nBytes = pixelTypeSize (c.channel().type) *
+-		     (dataWindow.max.x - dataWindow.min.x + 1) /
+-		     c.channel().xSampling;
++	size_t nBytes = size_t(pixelTypeSize (c.channel().type)) *
++		     size_t(dataWindow.max.x - dataWindow.min.x + 1) /
++		     size_t(c.channel().xSampling);
+ 
+ 	for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
+ 	    if (modp (y, c.channel().ySampling) == 0)
+@@ -269,6 +269,7 @@ defaultFormat (Compressor * compressor)
+ }
+ 
+ 
++//obsolete
+ int
+ numLinesInBuffer (Compressor * compressor)
+ {
+@@ -1842,6 +1843,39 @@ usesLongNames (const Header &header)
+     return false;
+ }
+ 
++namespace
++{
++// for a given compression type, return the number of scanlines
++// compressed into a single chunk
++// TODO add to API and move to ImfCompressor.cpp
++int
++numLinesInBuffer(Compression comp)
++{
++    switch(comp)
++    {
++        case NO_COMPRESSION :
++        case RLE_COMPRESSION:
++        case ZIPS_COMPRESSION:
++            return 1;
++        case ZIP_COMPRESSION:
++            return 16;
++        case PIZ_COMPRESSION:
++            return 32;
++        case PXR24_COMPRESSION:
++            return 16;
++        case B44_COMPRESSION:
++        case B44A_COMPRESSION:
++        case DWAA_COMPRESSION:
++            return 32;
++        case DWAB_COMPRESSION:
++            return 256;
++
++        default:
++	        throw IEX_NAMESPACE::ArgExc ("Unknown compression type");
++    }
++}
++}
++
+ int
+ getScanlineChunkOffsetTableSize(const Header& header)
+ {
+@@ -1851,17 +1885,11 @@ getScanlineChunkOffsetTableSize(const Header& header)
+     size_t maxBytesPerLine = bytesPerLineTable (header,
+                                                 bytesPerLine);
+ 
+-    Compressor* compressor = newCompressor(header.compression(),
+-                                           maxBytesPerLine,
+-                                           header);
+-
+-    int linesInBuffer = numLinesInBuffer (compressor);
++    int linesInBuffer = numLinesInBuffer ( header.compression() );
+ 
+     int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y +
+                           linesInBuffer) / linesInBuffer;
+ 
+-    delete compressor;
+-
+     return lineOffsetSize;
+ }
+ 
+diff --git a/OpenEXR/IlmImf/ImfPizCompressor.cpp b/OpenEXR/IlmImf/ImfPizCompressor.cpp
+index 7a49d42d..edc141ad 100644
+--- a/OpenEXR/IlmImf/ImfPizCompressor.cpp
++++ b/OpenEXR/IlmImf/ImfPizCompressor.cpp
+@@ -492,7 +492,9 @@ PizCompressor::uncompress (const char *inPtr,
+     // This is the cunompress function which is used by both the tiled and
+     // scanline decompression routines.
+     //
+-    
++   
++    const char* inputEnd=inPtr+inSize;
++
+     //
+     // Special case - empty input buffer
+     //
+@@ -503,6 +505,7 @@ PizCompressor::uncompress (const char *inPtr,
+ 	return 0;
+     }
+ 
++
+     //
+     // Determine the layout of the compressed pixel data
+     //
+@@ -549,6 +552,12 @@ PizCompressor::uncompress (const char *inPtr,
+     AutoArray <unsigned char, BITMAP_SIZE> bitmap;
+     memset (bitmap, 0, sizeof (unsigned char) * BITMAP_SIZE);
+ 
++
++    if(inPtr + sizeof(unsigned short)*2 > inputEnd)
++    {
++   	   throw InputExc ("PIZ compressed data too short");
++    }
++
+     Xdr::read <CharPtrIO> (inPtr, minNonZero);
+     Xdr::read <CharPtrIO> (inPtr, maxNonZero);
+ 
+@@ -560,8 +569,14 @@ PizCompressor::uncompress (const char *inPtr,
+ 
+     if (minNonZero <= maxNonZero)
+     {
+-	Xdr::read <CharPtrIO> (inPtr, (char *) &bitmap[0] + minNonZero,
+-			       maxNonZero - minNonZero + 1);
++        size_t bytesToRead = maxNonZero - minNonZero + 1;
++	    if(inPtr + bytesToRead > inputEnd)
++        {
++   	      throw InputExc ("PIZ compressed data too short");
++        }
++
++Xdr::read <CharPtrIO> (inPtr, (char *) &bitmap[0] + minNonZero,
++			       bytesToRead);
+     }
+ 
+     AutoArray <unsigned short, USHORT_RANGE> lut;
+@@ -570,6 +585,11 @@ PizCompressor::uncompress (const char *inPtr,
+     //
+     // Huffman decoding
+     //
++   if(inPtr + sizeof(int)> inputEnd)
++   {
++       throw InputExc ("PIZ compressed data too short");
++   }
++
+ 
+     int length;
+     Xdr::read <CharPtrIO> (inPtr, length);
+diff --git a/OpenEXR/IlmImf/ImfRle.cpp b/OpenEXR/IlmImf/ImfRle.cpp
+index 7be6ac44..f6992fa5 100644
+--- a/OpenEXR/IlmImf/ImfRle.cpp
++++ b/OpenEXR/IlmImf/ImfRle.cpp
+@@ -129,6 +129,11 @@ rleUncompress (int inLength, int maxLength, const signed char in[], char out[])
+ 	    if (0 > (maxLength -= count))
+ 		return 0;
+ 
++        // check the input buffer is big enough to contain
++        // 'count' bytes of remaining data
++        if (inLength < 0)
++          return 0;
++
+         memcpy(out, in, count);
+         out += count;
+         in  += count;
+diff --git a/OpenEXR/IlmImf/ImfScanLineInputFile.cpp b/OpenEXR/IlmImf/ImfScanLineInputFile.cpp
+index 9d7404f3..2a559654 100644
+--- a/OpenEXR/IlmImf/ImfScanLineInputFile.cpp
++++ b/OpenEXR/IlmImf/ImfScanLineInputFile.cpp
+@@ -1097,8 +1097,6 @@ newLineBufferTask (TaskGroup *group,
+ 
+ void ScanLineInputFile::initialize(const Header& header)
+ {
+-    try
+-    {
+         _data->header = header;
+ 
+         _data->lineOrder = _data->header.lineOrder();
+@@ -1112,6 +1110,12 @@ void ScanLineInputFile::initialize(const Header& header)
+ 
+         size_t maxBytesPerLine = bytesPerLineTable (_data->header,
+                                                     _data->bytesPerLine);
++        
++        if(maxBytesPerLine > INT_MAX)
++        {
++            throw IEX_NAMESPACE::InputExc("maximum bytes per scanline exceeds maximum permissible size");
++        }
++
+ 
+         for (size_t i = 0; i < _data->lineBuffers.size(); i++)
+         {
+@@ -1143,13 +1147,6 @@ void ScanLineInputFile::initialize(const Header& header)
+                               _data->linesInBuffer) / _data->linesInBuffer;
+ 
+         _data->lineOffsets.resize (lineOffsetSize);
+-    }
+-    catch (...)
+-    {
+-        delete _data;
+-        _data=NULL;
+-        throw;
+-    }
+ }
+ 
+ 
+@@ -1164,8 +1161,27 @@ ScanLineInputFile::ScanLineInputFile(InputPartData* part)
+ 
+     _data->version = part->version;
+ 
+-    initialize(part->header);
+-
++    try
++    {
++       initialize(part->header);
++    }
++    catch(...)
++    {
++        if (!_data->memoryMapped)
++        {
++            for (size_t i = 0; i < _data->lineBuffers.size(); i++)
++            {
++                if( _data->lineBuffers[i] )
++                {
++                   EXRFreeAligned(_data->lineBuffers[i]->buffer);
++                   _data->lineBuffers[i]->buffer=nullptr;
++                }
++            }
++        }
++        
++        delete _data;
++        throw;
++    }
+     _data->lineOffsets = part->chunkOffsets;
+ 
+     _data->partNumber = part->partNumber;
+@@ -1188,19 +1204,43 @@ ScanLineInputFile::ScanLineInputFile
+     _streamData->is = is;
+     _data->memoryMapped = is->isMemoryMapped();
+ 
+-    initialize(header);
+-    
+-    //
+-    // (TODO) this is nasty - we need a better way of working out what type of file has been used.
+-    // in any case I believe this constructor only gets used with single part files
+-    // and 'version' currently only tracks multipart state, so setting to 0 (not multipart) works for us
+-    //
+-    
+-    _data->version=0;
+-    readLineOffsets (*_streamData->is,
+-                     _data->lineOrder,
+-                     _data->lineOffsets,
+-                     _data->fileIsComplete);
++    try
++    {
++
++        initialize(header);
++        
++        //
++        // (TODO) this is nasty - we need a better way of working out what type of file has been used.
++        // in any case I believe this constructor only gets used with single part files
++        // and 'version' currently only tracks multipart state, so setting to 0 (not multipart) works for us
++        //
++        
++        _data->version=0;
++        readLineOffsets (*_streamData->is,
++                        _data->lineOrder,
++                        _data->lineOffsets,
++                        _data->fileIsComplete);
++    }
++    catch(...)
++    {
++        if(_data)
++        {
++           if (!_data->memoryMapped)
++           {
++              for (size_t i = 0; i < _data->lineBuffers.size(); i++)
++              {
++                 if( _data->lineBuffers[i] )
++                 {
++                   EXRFreeAligned(_data->lineBuffers[i]->buffer);
++                   _data->lineBuffers[i]->buffer=nullptr;
++                 }
++              }
++           }
++        }
++        delete _streamData;
++        delete _data;
++        throw;
++    }
+ }
+ 
+ 
+@@ -1422,6 +1462,14 @@ ScanLineInputFile::setFrameBuffer (const FrameBuffer &frameBuffer)
+                       // not possible.
+                       break;
+               }
++
++              //
++              // optimization mode cannot currently skip subsampled channels
++              //
++              if (i.channel().xSampling!=1 || i.channel().ySampling!=1)
++              {
++                  optimizationPossible = false;
++              }
+               ++i;
+ 	}
+ 
+diff --git a/OpenEXR/IlmImf/ImfTiledInputFile.cpp b/OpenEXR/IlmImf/ImfTiledInputFile.cpp
+index bda7bad5..e6936d53 100644
+--- a/OpenEXR/IlmImf/ImfTiledInputFile.cpp
++++ b/OpenEXR/IlmImf/ImfTiledInputFile.cpp
+@@ -703,61 +703,56 @@ TiledInputFile::TiledInputFile (const char fileName[], int numThreads):
+     IStream* is = 0;
+     try
+     {
+-        is = new StdIFStream (fileName);
+-	readMagicNumberAndVersionField(*is, _data->version);
+-
+-	//
+-        // Backward compatibility to read multpart file.
+-        //
+-	if (isMultiPart(_data->version))
+-	{
+-	    compatibilityInitialize(*is);
+-	    return;
+-	}
+-
+-	_data->_streamData = new InputStreamMutex();
+-	_data->_streamData->is = is;
+-	_data->header.readFrom (*_data->_streamData->is, _data->version);
+-	initialize();
+-        //read tile offsets - we are not multipart or deep
+-        _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);
+-	_data->_streamData->currentPosition = _data->_streamData->is->tellg();
+-    }
+-    catch (IEX_NAMESPACE::BaseExc &e)
+-    {
+-        if (_data->_streamData != 0)
++        try
+         {
+-            if (_data->_streamData->is != 0)
++            is = new StdIFStream (fileName);
++            readMagicNumberAndVersionField(*is, _data->version);
++
++            //
++            // Backward compatibility to read multpart file.
++            //
++            if (isMultiPart(_data->version))
+             {
+-                delete _data->_streamData->is;
+-                _data->_streamData->is = is = 0;
++                compatibilityInitialize(*is);
++                return;
+             }
+ 
+-            delete _data->_streamData;
++            _data->_streamData = new InputStreamMutex();
++            _data->_streamData->is = is;
++            _data->header.readFrom (*_data->_streamData->is, _data->version);
++            initialize();
++            //read tile offsets - we are not multipart or deep
++            _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);
++            _data->_streamData->currentPosition = _data->_streamData->is->tellg();
++        }
++        catch (IEX_NAMESPACE::BaseExc &e)
++        {
++            REPLACE_EXC (e, "Cannot open image file "
++                    "\"" << fileName << "\". " << e.what());
++            throw;
+         }
+-
+-        if (is != 0)
+-            delete is;
+-
+-	REPLACE_EXC (e, "Cannot open image file "
+-                 "\"" << fileName << "\". " << e.what());
+-	throw;
+     }
+     catch (...)
+     {
+-        if ( _data->_streamData != 0)
++        if (!_data->memoryMapped)
+         {
+-            if ( _data->_streamData->is != 0)
++            for (size_t i = 0; i < _data->tileBuffers.size(); i++)
+             {
+-                delete _data->_streamData->is;
+-                _data->_streamData->is = is = 0;
++                if(_data->tileBuffers[i])
++                {
++                   delete [] _data->tileBuffers[i]->buffer;
++                }
+             }
+-
++        }
++        if ( _data->_streamData != 0)
++        {
++            delete _data->_streamData->is;
++            _data->_streamData->is = is = 0;
+             delete _data->_streamData;
+         }
+ 
+-        if (is != 0)
+-            delete is;
++        delete is;
++        delete _data;
+         throw;
+     }
+ }
+@@ -776,38 +771,45 @@ TiledInputFile::TiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int
+ 
+     try
+     {
+-	readMagicNumberAndVersionField(is, _data->version);
+-
+-	//
+-	// Backward compatibility to read multpart file.
+-	//
+-	if (isMultiPart(_data->version))
++        try
+         {
+-	    compatibilityInitialize(is);
+-            return;
+-        }
++            readMagicNumberAndVersionField(is, _data->version);
+ 
+-	streamDataCreated = true;
+-	_data->_streamData = new InputStreamMutex();
+-	_data->_streamData->is = &is;
+-	_data->header.readFrom (*_data->_streamData->is, _data->version);
+-	initialize();
+-        // file is guaranteed to be single part, regular image
+-        _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);
+-	_data->memoryMapped = _data->_streamData->is->isMemoryMapped();
+-	_data->_streamData->currentPosition = _data->_streamData->is->tellg();
+-    }
+-    catch (IEX_NAMESPACE::BaseExc &e)
+-    {
+-        if (streamDataCreated) delete _data->_streamData;
+-	delete _data;
++            //
++            // Backward compatibility to read multpart file.
++            //
++            if (isMultiPart(_data->version))
++            {
++                compatibilityInitialize(is);
++                return;
++            }
+ 
+-	REPLACE_EXC (e, "Cannot open image file "
+-                 "\"" << is.fileName() << "\". " << e.what());
+-	throw;
++            streamDataCreated = true;
++            _data->_streamData = new InputStreamMutex();
++            _data->_streamData->is = &is;
++            _data->header.readFrom (*_data->_streamData->is, _data->version);
++            initialize();
++            // file is guaranteed to be single part, regular image
++            _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);
++            _data->memoryMapped = _data->_streamData->is->isMemoryMapped();
++            _data->_streamData->currentPosition = _data->_streamData->is->tellg();
++        }
++        catch (IEX_NAMESPACE::BaseExc &e)
++        {
++            REPLACE_EXC (e, "Cannot open image file "
++                    "\"" << is.fileName() << "\". " << e.what());
++            throw;
++        }
+     }
+     catch (...)
+     {
++        if (!_data->memoryMapped)
++        {
++            for (size_t i = 0; i < _data->tileBuffers.size(); i++)
++            {
++                delete [] _data->tileBuffers[i]->buffer;
++            }
++        }
+         if (streamDataCreated) delete _data->_streamData;
+ 	delete _data;
+         throw;
+@@ -831,13 +833,29 @@ TiledInputFile::TiledInputFile (const Header &header,
+     // we have somehow got the header.
+     //
+ 
+-    _data->_streamData->is = is;
+-    _data->header = header;
+-    _data->version = version;
+-    initialize();
+-    _data->tileOffsets.readFrom (*(_data->_streamData->is),_data->fileIsComplete,false,false);
+-    _data->memoryMapped = is->isMemoryMapped();
+-    _data->_streamData->currentPosition = _data->_streamData->is->tellg();
++    try
++    {
++        _data->_streamData->is = is;
++        _data->header = header;
++        _data->version = version;
++        initialize();
++        _data->tileOffsets.readFrom (*(_data->_streamData->is),_data->fileIsComplete,false,false);
++        _data->memoryMapped = is->isMemoryMapped();
++        _data->_streamData->currentPosition = _data->_streamData->is->tellg();
++    }
++    catch(...)
++    {
++        if (!_data->memoryMapped)
++        {
++            for (size_t i = 0; i < _data->tileBuffers.size(); i++)
++            {
++                delete [] _data->tileBuffers[i]->buffer;
++            }
++        }
++        delete _data->_streamData;
++	delete _data;
++        throw; 
++    }
+ }
+ 
+ 
+@@ -845,7 +863,15 @@ TiledInputFile::TiledInputFile (InputPartData* part)
+ {
+     _data = new Data (part->numThreads);
+     _data->_deleteStream=false;
+-    multiPartInitialize(part);
++    try
++    {
++      multiPartInitialize(part);
++    }
++    catch(...)
++    {
++        if (_data) delete _data;
++        throw;
++    }
+ }
+ 
+ 
+diff --git a/OpenEXR/IlmImf/ImfTiledMisc.cpp b/OpenEXR/IlmImf/ImfTiledMisc.cpp
+index d262f734..8552ada2 100644
+--- a/OpenEXR/IlmImf/ImfTiledMisc.cpp
++++ b/OpenEXR/IlmImf/ImfTiledMisc.cpp
+@@ -363,40 +363,51 @@ getTiledChunkOffsetTableSize(const Header& header)
+     //
+     Int64 lineOffsetSize = 0;
+     const TileDescription &desc = header.tileDescription();
+-    switch (desc.mode)
++    try
+     {
+-        case ONE_LEVEL:
+-        case MIPMAP_LEVELS:
+-            for (int i = 0; i < numXLevels; i++)
+-            {
+-                lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[i]);
+-                if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
++        switch (desc.mode)
++        {
++            case ONE_LEVEL:
++            case MIPMAP_LEVELS:
++                for (int i = 0; i < numXLevels; i++)
+                 {
+-                    throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
++                    lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[i]);
++                    if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
++                    {
++                        throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
++                    }
+                 }
+-            }
+-           break;
+-        case RIPMAP_LEVELS:
+-            for (int i = 0; i < numXLevels; i++)
+-            {
+-                for (int j = 0; j < numYLevels; j++)
++            break;
++            case RIPMAP_LEVELS:
++                for (int i = 0; i < numXLevels; i++)
+                 {
+-                     lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[j]);
+-                     if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
+-                     {
+-                        throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
+-                     }
++                    for (int j = 0; j < numYLevels; j++)
++                    {
++                        lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[j]);
++                        if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
++                        {
++                            throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
++                        }
++                    }
+                 }
+-            }
+-           break;
+-        case NUM_LEVELMODES :
+-            throw IEX_NAMESPACE::LogicExc("Bad level mode getting chunk offset table size");
++            break;
++            case NUM_LEVELMODES :
++                throw IEX_NAMESPACE::LogicExc("Bad level mode getting chunk offset table size");
++        }
++        delete[] numXTiles;
++        delete[] numYTiles;
++
++        return static_cast<int>(lineOffsetSize);
++
+     }
++    catch(...)
++    {
++        delete[] numXTiles;
++        delete[] numYTiles;
+ 
+-    delete[] numXTiles;
+-    delete[] numYTiles;
++        throw;
++    }
+ 
+-    return static_cast<int>(lineOffsetSize);
+ }
+ 
+ 
+diff --git a/OpenEXR/IlmImfTest/testDeepTiledBasic.cpp b/OpenEXR/IlmImfTest/testDeepTiledBasic.cpp
+index e81b56a7..9fab3553 100644
+--- a/OpenEXR/IlmImfTest/testDeepTiledBasic.cpp
++++ b/OpenEXR/IlmImfTest/testDeepTiledBasic.cpp
+@@ -754,15 +754,12 @@ void readFile (int channelCount,
+                     {
+                         for (int k = 0; k < channelCount; k++)
+                         {
+-                            if( !randomChannels || read_channel[k]==1)
+-                            {
+                                 if (channelTypes[k] == 0)
+                                     delete[] (unsigned int*) data[k][i][j];
+                                 if (channelTypes[k] == 1)
+                                     delete[] (half*) data[k][i][j];
+                                 if (channelTypes[k] == 2)
+                                     delete[] (float*) data[k][i][j];
+-                            }
+                         }
+                         for( int f = 0 ; f < fillChannels ; ++f )
+                         {
+diff --git a/OpenEXR/IlmImfTest/testMultiPartApi.cpp b/OpenEXR/IlmImfTest/testMultiPartApi.cpp
+index c6265b88..c0bfb688 100644
+--- a/OpenEXR/IlmImfTest/testMultiPartApi.cpp
++++ b/OpenEXR/IlmImfTest/testMultiPartApi.cpp
+@@ -463,6 +463,21 @@ generateRandomFile (int partCount, const std::string & fn)
+         }
+     }
+ 
++    for (size_t i = 0 ; i < parts.size() ; ++i )
++    {
++        int partType = partTypes[i];
++
++        if (partType == 0)
++        {
++            delete (OutputPart*) parts[i];
++        }
++        else
++        {
++            delete (TiledOutputPart*) parts[i];
++        }
++
++    }
++
+     delete[] tiledHalfData;
+     delete[] tiledUintData;
+     delete[] tiledFloatData;
+diff --git a/OpenEXR/IlmImfTest/testMultiPartThreading.cpp b/OpenEXR/IlmImfTest/testMultiPartThreading.cpp
+index 68eb8fa9..c4e05704 100644
+--- a/OpenEXR/IlmImfTest/testMultiPartThreading.cpp
++++ b/OpenEXR/IlmImfTest/testMultiPartThreading.cpp
+@@ -625,6 +625,18 @@ generateRandomFile (int partCount, const std::string & fn)
+         }
+     }
+ 
++    for (int i = 0; i < partCount; i++)
++    {
++        if (partTypes[i] == 0)
++        {
++            delete (OutputPart*) parts[i];
++        }
++        else
++        {
++            delete (TiledOutputPart*) parts[i];
++        }
++    }
++ 
+     delete threadPool;
+ 
+     delete[] tiledHalfData;
+diff --git a/OpenEXR/exrmakepreview/makePreview.cpp b/OpenEXR/exrmakepreview/makePreview.cpp
+index e2d08798..28205aa0 100644
+--- a/OpenEXR/exrmakepreview/makePreview.cpp
++++ b/OpenEXR/exrmakepreview/makePreview.cpp
+@@ -120,8 +120,8 @@ generatePreview (const char inFileName[],
+     previewHeight = max (int (h / (w * a) * previewWidth + .5f), 1);
+     previewPixels.resizeErase (previewHeight, previewWidth);
+ 
+-    float fx = (previewWidth  > 1)? (float (w - 1) / (previewWidth  - 1)): 1;
+-    float fy = (previewHeight > 1)? (float (h - 1) / (previewHeight - 1)): 1;
++    double fx = (previewWidth  > 1)? (double (w - 1) / (previewWidth  - 1)): 1;
++    double fy = (previewHeight > 1)? (double (h - 1) / (previewHeight - 1)): 1;
+     float m  = Math<float>::pow (2.f, IMATH_NAMESPACE::clamp (exposure + 2.47393f, -20.f, 20.f));
+ 
+     for (int y = 0; y < previewHeight; ++y)

tasks/csa159/pair_136251/pre_functions.txt

@@ -0,0 +1,2527 @@
+### File: OpenEXR/IlmImf/ImfCompositeDeepScanLine.cpp
+```c
+void 
+CompositeDeepScanLine::Data::handleDeepFrameBuffer (DeepFrameBuffer& buf,
+                                                    std::vector< unsigned int > & counts,
+                                                    vector< std::vector< float* > > & pointers,
+                                                    const Header& header,
+                                                    int start,
+                                                    int end)
+{
+    int width=_dataWindow.size().x+1;
+    size_t pixelcount = width * (end-start+1);
+    pointers.resize(_channels.size());
+    counts.resize(pixelcount);
+    buf.insertSampleCountSlice (Slice (OPENEXR_IMF_INTERNAL_NAMESPACE::UINT,
+                                (char *) (&counts[0]-_dataWindow.min.x-start*width),
+                                sizeof(unsigned int),
+                                sizeof(unsigned int)*width));
+
+    pointers[0].resize(pixelcount);
+    buf.insert ("Z", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                (char *)(&pointers[0][0]-_dataWindow.min.x-start*width),
+                                sizeof(float *),
+                                sizeof(float *)*width,
+                                sizeof(float) ));
+
+    if(_zback)
+    {
+        pointers[1].resize(pixelcount);
+        buf.insert ("ZBack", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                        (char *)(&pointers[1][0]-_dataWindow.min.x-start*width),
+                                        sizeof(float *),
+                                        sizeof(float *)*width,
+                                        sizeof(float) ));
+    }
+
+    pointers[2].resize(pixelcount);
+    buf.insert ("A", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                (char *)(&pointers[2][0]-_dataWindow.min.x-start*width),
+                                sizeof(float *),
+                                sizeof(float *)*width,
+                                sizeof(float) ));
+
+
+    size_t i =0;
+    for(FrameBuffer::ConstIterator qt  = _outputFrameBuffer.begin();
+                                   qt != _outputFrameBuffer.end();
+                                   qt++)
+    {
+        int channel_in_source = _bufferMap[i];
+        if(channel_in_source>2)
+        {
+            // not dealt with yet (0,1,2 previously inserted)
+            pointers[channel_in_source].resize(pixelcount);
+            buf.insert (qt.name(),
+                        DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                   (char *)(&pointers[channel_in_source][0]-_dataWindow.min.x-start*width),
+                                   sizeof(float *),
+                                   sizeof(float *)*width,
+                                   sizeof(float) ));
+        }
+
+        i++;
+    }
+
+}
+```
+
+### File: OpenEXR/IlmImf/ImfDeepScanLineInputFile.cpp
+```c
+void DeepScanLineInputFile::initialize(const Header& header)
+{
+    try
+    {
+        if (header.type() != DEEPSCANLINE)
+            throw IEX_NAMESPACE::ArgExc("Can't build a DeepScanLineInputFile from "
+            "a type-mismatched part.");
+        
+        if(header.version()!=1)
+        {
+            THROW(IEX_NAMESPACE::ArgExc, "Version " << header.version() << " not supported for deepscanline images in this version of the library");
+        }
+        
+        _data->header = header;
+
+        _data->lineOrder = _data->header.lineOrder();
+
+        const Box2i &dataWindow = _data->header.dataWindow();
+
+        _data->minX = dataWindow.min.x;
+        _data->maxX = dataWindow.max.x;
+        _data->minY = dataWindow.min.y;
+        _data->maxY = dataWindow.max.y;
+
+        _data->sampleCount.resizeErase(_data->maxY - _data->minY + 1,
+                                       _data->maxX - _data->minX + 1);
+        _data->lineSampleCount.resizeErase(_data->maxY - _data->minY + 1);
+
+        Compressor* compressor = newCompressor(_data->header.compression(),
+                                               0,
+                                               _data->header);
+
+        _data->linesInBuffer = numLinesInBuffer (compressor);
+
+        delete compressor;
+
+        _data->nextLineBufferMinY = _data->minY - 1;
+
+        int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y +
+                              _data->linesInBuffer) / _data->linesInBuffer;
+
+        _data->lineOffsets.resize (lineOffsetSize);
+
+        for (size_t i = 0; i < _data->lineBuffers.size(); i++)
+            _data->lineBuffers[i] = new LineBuffer ();
+
+        _data->gotSampleCount.resizeErase(_data->maxY - _data->minY + 1);
+        for (int i = 0; i < _data->maxY - _data->minY + 1; i++)
+            _data->gotSampleCount[i] = false;
+
+        _data->maxSampleCountTableSize = min(_data->linesInBuffer, _data->maxY - _data->minY + 1) *
+                                        (_data->maxX - _data->minX + 1) *
+                                        sizeof(unsigned int);
+
+        _data->sampleCountTableBuffer.resizeErase(_data->maxSampleCountTableSize);
+
+        _data->sampleCountTableComp = newCompressor(_data->header.compression(),
+                                                    _data->maxSampleCountTableSize,
+                                                    _data->header);
+
+        _data->bytesPerLine.resize (_data->maxY - _data->minY + 1);
+        
+        const ChannelList & c=header.channels();
+        
+        _data->combinedSampleSize=0;
+        for(ChannelList::ConstIterator i=c.begin();i!=c.end();i++)
+        {
+            switch(i.channel().type)
+            {
+                case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF  :
+                    _data->combinedSampleSize+=Xdr::size<half>();
+                    break;
+                case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT :
+                    _data->combinedSampleSize+=Xdr::size<float>();
+                    break;
+                case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT  :
+                    _data->combinedSampleSize+=Xdr::size<unsigned int>();
+                    break;
+                default :
+                    THROW(IEX_NAMESPACE::ArgExc, "Bad type for channel " << i.name() << " initializing deepscanline reader");
+                    
+            }
+        }
+        
+    }
+    catch (...)
+    {
+        delete _data;
+        _data=NULL;
+        throw;
+    }
+}
+
+void
+DeepScanLineInputFile::compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)
+{
+    is.seekg(0);
+    //
+    // Construct a MultiPartInputFile, initialize TiledInputFile
+    // with the part 0 data.
+    // (TODO) maybe change the third parameter of the constructor of MultiPartInputFile later.
+    //
+    _data->multiPartBackwardSupport = true;
+    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);
+    InputPartData* part = _data->multiPartFile->getPart(0);
+    
+    multiPartInitialize(part);
+}
+```
+
+### File: OpenEXR/IlmImf/ImfDeepTiledInputFile.cpp
+```c
+void
+DeepTiledInputFile::compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)
+{
+    is.seekg(0);
+    //
+    // Construct a MultiPartInputFile, initialize TiledInputFile
+    // with the part 0 data.
+    // (TODO) maybe change the third parameter of the constructor of MultiPartInputFile later.
+    //
+    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);
+    _data->multiPartBackwardSupport = true;
+    InputPartData* part = _data->multiPartFile->getPart(0);
+
+    multiPartInitialize(part);
+}
+```
+
+### File: OpenEXR/IlmImf/ImfDwaCompressor.cpp
+```c
+struct DwaCompressor::Classifier
+{
+    Classifier (std::string suffix,
+                CompressorScheme scheme,
+                PixelType type,
+                int cscIdx,
+                bool caseInsensitive):
+        _suffix(suffix),
+        _scheme(scheme),
+        _type(type),
+        _cscIdx(cscIdx),
+        _caseInsensitive(caseInsensitive)
+    {
+        if (caseInsensitive) 
+            std::transform(_suffix.begin(), _suffix.end(), _suffix.begin(), tolower);
+    }
+
+    Classifier (const char *&ptr, int size)
+    {
+        if (size <= 0) 
+            throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                " (truncated rule).");
+            
+        {
+            char suffix[Name::SIZE];
+            memset (suffix, 0, Name::SIZE);
+            Xdr::read<CharPtrIO> (ptr, std::min(size, Name::SIZE-1), suffix);
+            _suffix = std::string(suffix);
+        }
+
+        if (static_cast<size_t>(size) < _suffix.length() + 1 + 2*Xdr::size<char>()) 
+            throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                " (truncated rule).");
+
+        char value;
+        Xdr::read<CharPtrIO> (ptr, value);
+
+        _cscIdx = (int)(value >> 4) - 1;
+        if (_cscIdx < -1 || _cscIdx >= 3) 
+            throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                " (corrupt cscIdx rule).");
+
+        _scheme = (CompressorScheme)((value >> 2) & 3);
+        if (_scheme < 0 || _scheme >= NUM_COMPRESSOR_SCHEMES) 
+            throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                " (corrupt scheme rule).");
+
+        _caseInsensitive = (value & 1 ? true : false);
+
+        Xdr::read<CharPtrIO> (ptr, value);
+        if (value < 0 || value >= NUM_PIXELTYPES) 
+            throw IEX_NAMESPACE::InputExc("Error uncompressing DWA data"
+                                " (corrupt rule).");
+        _type = (PixelType)value;
+    }
+```
+
+### File: OpenEXR/IlmImf/ImfFastHuf.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2009-2014 DreamWorks Animation LLC. 
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of DreamWorks Animation nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfFastHuf.h"
+#include <Iex.h>
+
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <vector>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+//
+// Adapted from hufUnpackEncTable - 
+// We don't need to reconstruct the code book, just the encoded
+// lengths for each symbol. From the lengths, we can build the
+// base + offset tables. This should be a bit more efficient
+// for sparse code books.
+// 
+//   table     - ptr to the start of the code length data. Will be
+//               updated as we decode data
+//
+//   numBytes  - size of the encoded table (I think)?
+//
+//   minSymbol - smallest symbol in the code book
+//
+//   maxSymbol - largest symbol in the code book. 
+//
+//   rleSymbol - the symbol to trigger RLE in the encoded bitstream
+//
+
+FastHufDecoder::FastHufDecoder
+    (const char *&table,
+     int numBytes,
+     int minSymbol,
+     int maxSymbol,
+     int rleSymbol)
+:
+    _rleSymbol (rleSymbol),
+    _numSymbols (0),
+    _minCodeLength (255),
+    _maxCodeLength (0),
+    _idToSymbol (0)
+{
+    //
+    // List of symbols that we find with non-zero code lengths
+    // (listed in the order we find them). Store these in the
+    // same format as the code book stores codes + lengths - 
+    // low 6 bits are the length, everything above that is
+    // the symbol.
+    //
+
+    std::vector<Int64> symbols;
+
+    //
+    // The 'base' table is the minimum code at each code length. base[i]
+    // is the smallest code (numerically) of length i.
+    //
+
+    Int64 base[MAX_CODE_LEN + 1];     
+
+    //
+    // The 'offset' table is the position (in sorted order) of the first id
+    // of a given code lenght. Array is indexed by code length, like base.  
+    //
+
+    Int64 offset[MAX_CODE_LEN + 1];   
+
+    //
+    // Count of how many codes at each length there are. Array is 
+    // indexed by code length, like base and offset.
+    //
+
+    size_t codeCount[MAX_CODE_LEN + 1];    
+
+    for (int i = 0; i <= MAX_CODE_LEN; ++i)
+    {
+        codeCount[i] = 0;
+        base[i]      = 0xffffffffffffffffULL;
+        offset[i]    = 0;
+    }
+
+    //
+    // Count the number of codes, the min/max code lengths, the number of
+    // codes with each length, and record symbols with non-zero code
+    // length as we find them.
+    //
+
+    const char *currByte     = table;
+    Int64       currBits     = 0;
+    int         currBitCount = 0;
+
+    const int SHORT_ZEROCODE_RUN = 59;
+    const int LONG_ZEROCODE_RUN  = 63;
+    const int SHORTEST_LONG_RUN  = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
+
+    for (Int64 symbol = static_cast<Int64>(minSymbol); symbol <= static_cast<Int64>(maxSymbol); symbol++)
+    {
+        if (currByte - table > numBytes)
+        {
+            throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                           "(Truncated table data).");
+        }
+
+        //
+        // Next code length - either:
+        //       0-58  (literal code length)
+        //       59-62 (various lengths runs of 0)
+        //       63    (run of n 0's, with n is the next 8 bits)
+        //
+
+        Int64 codeLen = readBits (6, currBits, currBitCount, currByte);
+
+        if (codeLen == (Int64) LONG_ZEROCODE_RUN)
+        {
+            if (currByte - table > numBytes)
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Truncated table data).");
+            }
+
+            int runLen = readBits (8, currBits, currBitCount, currByte) +
+                         SHORTEST_LONG_RUN;
+
+            if (symbol + runLen > static_cast<Int64>(maxSymbol + 1))
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Run beyond end of table).");
+            }
+            
+            symbol += runLen - 1;
+
+        }
+        else if (codeLen >= static_cast<Int64>(SHORT_ZEROCODE_RUN))
+        {
+            int runLen = codeLen - SHORT_ZEROCODE_RUN + 2;
+
+            if (symbol + runLen > static_cast<Int64>(maxSymbol + 1))
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Run beyond end of table).");
+            }
+
+            symbol += runLen - 1;
+
+        }
+        else if (codeLen != 0)
+        {
+            symbols.push_back ((symbol << 6) | (codeLen & 63));
+
+            if (codeLen < _minCodeLength)
+                _minCodeLength = codeLen;
+
+            if (codeLen > _maxCodeLength)
+                _maxCodeLength = codeLen;
+
+            codeCount[codeLen]++;
+        }
+    }
+
+    for (int i = 0; i < MAX_CODE_LEN; ++i)
+        _numSymbols += codeCount[i];
+
+    table = currByte;
+
+    //
+    // Compute base - once we have the code length counts, there
+    //                is a closed form solution for this
+    //
+
+    {
+        double* countTmp = new double[_maxCodeLength+1];
+
+        for (int l = _minCodeLength; l <= _maxCodeLength; ++l)
+        {
+            countTmp[l] = (double)codeCount[l] * 
+                          (double)(2 << (_maxCodeLength-l));
+        }
+    
+        for (int l = _minCodeLength; l <= _maxCodeLength; ++l)
+        {
+            double tmp = 0;
+
+            for (int k =l + 1; k <= _maxCodeLength; ++k)
+                tmp += countTmp[k];
+            
+            tmp /= (double)(2 << (_maxCodeLength - l));
+
+            base[l] = (Int64)ceil (tmp);
+        }
+
+        delete [] countTmp;
+    }
+   
+    //
+    // Compute offset - these are the positions of the first
+    //                  id (not symbol) that has length [i]
+    //
+
+    offset[_maxCodeLength] = 0;
+
+    for (int i= _maxCodeLength - 1; i >= _minCodeLength; i--)
+        offset[i] = offset[i + 1] + codeCount[i + 1];
+
+    //
+    // Allocate and fill the symbol-to-id mapping. Smaller Ids should be
+    // mapped to less-frequent symbols (which have longer codes). Use
+    // the offset table to tell us where the id's for a given code 
+    // length start off.
+    //
+
+    _idToSymbol = new int[_numSymbols];
+
+    Int64 mapping[MAX_CODE_LEN + 1];
+    for (int i = 0; i < MAX_CODE_LEN + 1; ++i) 
+        mapping[i] = -1;
+    for (int i = _minCodeLength; i <= _maxCodeLength; ++i)
+        mapping[i] =
+
+// ... (14845 more chars)
+```
+
+### File: OpenEXR/IlmImf/ImfHeader.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+//-----------------------------------------------------------------------------
+//
+//	class Header
+//
+//-----------------------------------------------------------------------------
+
+#include <ImfHeader.h>
+#include <ImfStdIO.h>
+#include <ImfVersion.h>
+#include <ImfCompressor.h>
+#include <ImfMisc.h>
+#include <ImfBoxAttribute.h>
+#include <ImfChannelListAttribute.h>
+#include <ImfChromaticitiesAttribute.h>
+#include <ImfCompressionAttribute.h>
+#include <ImfDeepImageStateAttribute.h>
+#include <ImfDoubleAttribute.h>
+#include <ImfDwaCompressor.h>
+#include <ImfEnvmapAttribute.h>
+#include <ImfFloatAttribute.h>
+#include <ImfFloatVectorAttribute.h>
+#include <ImfIntAttribute.h>
+#include <ImfKeyCodeAttribute.h>
+#include <ImfLineOrderAttribute.h>
+#include <ImfMatrixAttribute.h>
+#include <ImfOpaqueAttribute.h>
+#include <ImfPreviewImageAttribute.h>
+#include <ImfRationalAttribute.h>
+#include <ImfStringAttribute.h>
+#include <ImfStringVectorAttribute.h>
+#include <ImfTileDescriptionAttribute.h>
+#include <ImfTimeCodeAttribute.h>
+#include <ImfVecAttribute.h>
+#include <ImfPartType.h>
+#include "IlmThreadMutex.h"
+#include "Iex.h"
+#include <sstream>
+#include <stdlib.h>
+#include <time.h>
+#include <cmath>
+#include "ImfTiledMisc.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using namespace std;
+using IMATH_NAMESPACE::Box2i;
+using IMATH_NAMESPACE::V2i;
+using IMATH_NAMESPACE::V2f;
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::Lock;
+
+
+namespace {
+
+int maxImageWidth = 0;
+int maxImageHeight = 0;
+int maxTileWidth = 0;
+int maxTileHeight = 0;
+
+
+void
+initialize (Header &header,
+	    const Box2i &displayWindow,
+	    const Box2i &dataWindow,
+	    float pixelAspectRatio,
+	    const V2f &screenWindowCenter,
+	    float screenWindowWidth,
+	    LineOrder lineOrder,
+	    Compression compression)
+{
+    header.insert ("displayWindow", Box2iAttribute (displayWindow));
+    header.insert ("dataWindow", Box2iAttribute (dataWindow));
+    if ( !std::isnormal (pixelAspectRatio) || pixelAspectRatio < 0.f)
+        THROW (IEX_NAMESPACE::ArgExc, "Invalid pixel aspect ratio");
+    header.insert ("pixelAspectRatio", FloatAttribute (pixelAspectRatio));
+    header.insert ("screenWindowCenter", V2fAttribute (screenWindowCenter));
+    header.insert ("screenWindowWidth", FloatAttribute (screenWindowWidth));
+    header.insert ("lineOrder", LineOrderAttribute (lineOrder));
+    header.insert ("compression", CompressionAttribute (compression));
+    header.insert ("channels", ChannelListAttribute ());
+}
+
+template <size_t N>
+void checkIsNullTerminated (const char (&str)[N], const char *what)
+{
+	for (size_t i = 0; i < N; ++i) {
+		if (str[i] == '\0')
+			return;
+	}
+	std::stringstream s;
+	s << "Invalid " << what << ": it is more than " << (N - 1) 
+		<< " characters long.";
+	throw IEX_NAMESPACE::InputExc(s);
+}
+
+} // namespace
+
+
+Header::Header (int width,
+		int height,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		displayWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (int width,
+		int height,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Box2i &displayWindow,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Header &other): _map()
+{
+    for (AttributeMap::const_iterator i = other._map.begin();
+	 i != other._map.end();
+	 ++i)
+    {
+	insert (*i->first, *i->second);
+    }
+}
+
+
+Header::~Header ()
+{
+    for (AttributeMap::iterator i = _map.begin();
+	 i != _map.end();
+	 ++i)
+    {
+	 delete i->second;
+    }
+}
+
+
+Header &		
+Header::operator = (const Header &other)
+{
+    if (this != &other)
+    {
+	for (AttributeMap::iterator i = _map.begin();
+	     i != _map.end();
+	     ++i)
+	{
+	     delete i->second;
+	}
+
+	_map.erase (_map.begin(), _map.end());
+
+	for (AttributeMap::const_iterator i = other._map.begin();
+	     i != other._map.end();
+	     ++i)
+	{
+	    insert (*i->first, *i->second);
+	}
+    }
+
+    return *this;
+}
+
+
+void
+Header::erase (const char name[])
+{
+    if (name[0] == 0)
+        THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+    
+    
+    AttributeMap::iterator i = _map.find (name);
+    if (i != _map.end())
+        _map.erase (i);
+
+}
+
+
+void
+Header::erase (const string &name)
+{
+    erase (name.c_str());
+}
+    
+    
+void
+Header::insert (const char name[], const Attribute &attribute)
+{
+    if (name[0] == 0)
+	THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+	Attribute *tmp = attribute.copy();
+
+	try
+	{
+	    _map[name] = tmp;
+	}
+	catch (...)
+	{
+	    delete tmp;
+	    throw;
+	}
+    }
+    else
+    {
+	if (strcmp (i->second->typeName(), attribute.typeName()))
+	    THROW (IEX_NAMESPACE::TypeExc, "Cannot assign a value of "
+				 "type \"" << attribute.typeName() << "\" "
+				 "to image attribute \"" << name << "\" of "
+				 "type \"" << i->second->typeName() << "\".");
+
+	Attribute *tmp = attribute.copy();
+	delete i->second;
+	i->second = tmp;
+    }
+}
+
+
+void
+Header::insert (const string &name, const Attribute &attribute)
+{
+    insert (name.c_str(), attribute);
+}
+
+
+Attribute &		
+Header::operator [] (const char name[])
+{
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i =
+
+// ... (22549 more chars)
+```
+
+### File: OpenEXR/IlmImf/ImfHuf.cpp
+```c
+void
+hufUncompress (const char compressed[],
+	       int nCompressed,
+	       unsigned short raw[],
+	       int nRaw)
+{
+    if (nCompressed == 0)
+    {
+	if (nRaw != 0)
+	    notEnoughData();
+
+	return;
+    }
+
+    int im = readUInt (compressed);
+    int iM = readUInt (compressed + 4);
+    // int tableLength = readUInt (compressed + 8);
+    int nBits = readUInt (compressed + 12);
+
+    if (im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE)
+	invalidTableSize();
+
+    const char *ptr = compressed + 20;
+
+    // 
+    // Fast decoder needs at least 2x64-bits of compressed data, and
+    // needs to be run-able on this platform. Otherwise, fall back
+    // to the original decoder
+    //
+
+    if (FastHufDecoder::enabled() && nBits > 128)
+    {
+        FastHufDecoder fhd (ptr, nCompressed - (ptr - compressed), im, iM, iM);
+        fhd.decode ((unsigned char*)ptr, nBits, raw, nRaw);
+    }
+    else
+    {
+        AutoArray <Int64, HUF_ENCSIZE> freq;
+        AutoArray <HufDec, HUF_DECSIZE> hdec;
+
+        hufClearDecTable (hdec);
+
+        hufUnpackEncTable (&ptr,
+                           nCompressed - (ptr - compressed),
+                           im,
+                           iM,
+                           freq);
+
+        try
+        {
+            if (nBits > 8 * (nCompressed - (ptr - compressed)))
+                invalidNBits();
+
+            hufBuildDecTable (freq, im, iM, hdec);
+            hufDecode (freq, hdec, ptr, nBits, iM, nRaw, raw);
+        }
+        catch (...)
+        {
+            hufFreeDecTable (hdec);
+            throw;
+        }
+
+        hufFreeDecTable (hdec);
+    }
+}
+```
+
+### File: OpenEXR/IlmImf/ImfInputFile.cpp
+```c
+void
+InputFile::compatibilityInitialize (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)
+{
+    is.seekg(0);
+
+    //
+    // Construct a MultiPartInputFile, initialize InputFile
+    // with the part 0 data.
+    // (TODO) may want to have a way to set the reconstruction flag.
+    //
+    _data->multiPartBackwardSupport = true;
+    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);
+    InputPartData* part = _data->multiPartFile->getPart(0);
+
+    multiPartInitialize (part);
+}
+```
+
+### File: OpenEXR/IlmImf/ImfMisc.cpp
+```c
+size_t
+bytesPerLineTable (const Header &header,
+		   vector<size_t> &bytesPerLine)
+{
+    const Box2i &dataWindow = header.dataWindow();
+    const ChannelList &channels = header.channels();
+
+    bytesPerLine.resize (dataWindow.max.y - dataWindow.min.y + 1);
+
+    for (ChannelList::ConstIterator c = channels.begin();
+	 c != channels.end();
+	 ++c)
+    {
+	int nBytes = pixelTypeSize (c.channel().type) *
+		     (dataWindow.max.x - dataWindow.min.x + 1) /
+		     c.channel().xSampling;
+
+	for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
+	    if (modp (y, c.channel().ySampling) == 0)
+		bytesPerLine[i] += nBytes;
+    }
+
+    size_t maxBytesPerLine = 0;
+
+    for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
+	if (maxBytesPerLine < bytesPerLine[i])
+	    maxBytesPerLine = bytesPerLine[i];
+
+    return maxBytesPerLine;
+}
+
+int
+numLinesInBuffer (Compressor * compressor)
+{
+    return compressor? compressor->numScanLines(): 1;
+}
+
+bool
+usesLongNames (const Header &header)
+{
+    //
+    // If an OpenEXR file contains any attribute names, attribute type names
+    // or channel names longer than 31 characters, then the file cannot be
+    // read by older versions of the IlmImf library (up to OpenEXR 1.6.1).
+    // Before writing the file header, we check if the header contains
+    // any names longer than 31 characters; if it does, then we set the
+    // LONG_NAMES_FLAG in the file version number.  Older versions of the
+    // IlmImf library will refuse to read files that have the LONG_NAMES_FLAG
+    // set.  Without the flag, older versions of the library would mis-
+    // interpret the file as broken.
+    //
+
+    for (Header::ConstIterator i = header.begin();
+         i != header.end();
+         ++i)
+    {
+        if (strlen (i.name()) >= 32 || strlen (i.attribute().typeName()) >= 32)
+            return true;
+    }
+
+    const ChannelList &channels = header.channels();
+
+    for (ChannelList::ConstIterator i = channels.begin();
+         i != channels.end();
+         ++i)
+    {
+        if (strlen (i.name()) >= 32)
+            return true;
+    }
+
+    return false;
+}
+
+int
+getScanlineChunkOffsetTableSize(const Header& header)
+{
+    const Box2i &dataWindow = header.dataWindow();
+
+    vector<size_t> bytesPerLine;
+    size_t maxBytesPerLine = bytesPerLineTable (header,
+                                                bytesPerLine);
+
+    Compressor* compressor = newCompressor(header.compression(),
+                                           maxBytesPerLine,
+                                           header);
+
+    int linesInBuffer = numLinesInBuffer (compressor);
+
+    int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y +
+                          linesInBuffer) / linesInBuffer;
+
+    delete compressor;
+
+    return lineOffsetSize;
+}
+```
+
+### File: OpenEXR/IlmImf/ImfPizCompressor.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+//-----------------------------------------------------------------------------
+//
+//	class PizCompressor
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfPizCompressor.h"
+#include "ImfHeader.h"
+#include "ImfChannelList.h"
+#include "ImfHuf.h"
+#include "ImfWav.h"
+#include "ImfMisc.h"
+#include "ImfCheckedArithmetic.h"
+#include <ImathFun.h>
+#include <ImathBox.h>
+#include <Iex.h>
+#include "ImfIO.h"
+#include "ImfXdr.h"
+#include "ImfAutoArray.h"
+#include <string.h>
+#include <assert.h>
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using IMATH_NAMESPACE::divp;
+using IMATH_NAMESPACE::modp;
+using IMATH_NAMESPACE::Box2i;
+using IMATH_NAMESPACE::V2i;
+using IEX_NAMESPACE::InputExc;
+
+namespace {
+
+//
+// Functions to compress the range of values in the pixel data
+//
+
+const int USHORT_RANGE = (1 << 16);
+const int BITMAP_SIZE  = (USHORT_RANGE >> 3);
+
+void
+bitmapFromData (const unsigned short data[/*nData*/],
+		int nData,
+		unsigned char bitmap[BITMAP_SIZE],
+		unsigned short &minNonZero,
+		unsigned short &maxNonZero)
+{
+    for (int i = 0; i < BITMAP_SIZE; ++i)
+	bitmap[i] = 0;
+
+    for (int i = 0; i < nData; ++i)
+	bitmap[data[i] >> 3] |= (1 << (data[i] & 7));
+
+    bitmap[0] &= ~1;			// zero is not explicitly stored in
+					// the bitmap; we assume that the
+					// data always contain zeroes
+    minNonZero = BITMAP_SIZE - 1;
+    maxNonZero = 0;
+
+    for (int i = 0; i < BITMAP_SIZE; ++i)
+    {
+	if (bitmap[i])
+	{
+	    if (minNonZero > i)
+		minNonZero = i;
+	    if (maxNonZero < i)
+		maxNonZero = i;
+	}
+    }
+}
+
+
+unsigned short
+forwardLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
+		      unsigned short lut[USHORT_RANGE])
+{
+    int k = 0;
+
+    for (int i = 0; i < USHORT_RANGE; ++i)
+    {
+	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
+	    lut[i] = k++;
+	else
+	    lut[i] = 0;
+    }
+
+    return k - 1;	// maximum value stored in lut[],
+}			// i.e. number of ones in bitmap minus 1
+
+
+unsigned short
+reverseLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
+		      unsigned short lut[USHORT_RANGE])
+{
+    int k = 0;
+
+    for (int i = 0; i < USHORT_RANGE; ++i)
+    {
+	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
+	    lut[k++] = i;
+    }
+
+    int n = k - 1;
+
+    while (k < USHORT_RANGE)
+	lut[k++] = 0;
+
+    return n;		// maximum k where lut[k] is non-zero,
+}			// i.e. number of ones in bitmap minus 1
+
+
+void
+applyLut (const unsigned short lut[USHORT_RANGE],
+	  unsigned short data[/*nData*/],
+	  int nData)
+{
+    for (int i = 0; i < nData; ++i)
+	data[i] = lut[data[i]];
+}
+
+
+} // namespace
+
+
+struct PizCompressor::ChannelData
+{
+    unsigned short *	start;
+    unsigned short *	end;
+    int			nx;
+    int			ny;
+    int			ys;
+    int			size;
+};
+
+
+PizCompressor::PizCompressor
+    (const Header &hdr,
+     size_t maxScanLineSize,
+     size_t numScanLines)
+:
+    Compressor (hdr),
+    _maxScanLineSize (maxScanLineSize),
+    _format (XDR),
+    _numScanLines (numScanLines),
+    _tmpBuffer (0),
+    _outBuffer (0),
+    _numChans (0),
+    _channels (hdr.channels()),
+    _channelData (0)
+{
+    // TODO: Remove this when we can change the ABI
+    (void) _maxScanLineSize;
+    size_t tmpBufferSize = uiMult (maxScanLineSize, numScanLines) / 2;
+
+    size_t outBufferSize =
+                uiAdd (uiMult (maxScanLineSize, numScanLines),
+                       size_t (65536 + 8192));
+
+    _tmpBuffer = new unsigned short
+            [checkArraySize (tmpBufferSize, sizeof (unsigned short))];
+
+    _outBuffer = new char [outBufferSize];
+
+    const ChannelList &channels = header().channels();
+    bool onlyHalfChannels = true;
+
+    for (ChannelList::ConstIterator c = channels.begin();
+	 c != channels.end();
+	 ++c)
+    {
+	_numChans++;
+
+	assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);
+
+	if (c.channel().type != HALF)
+	    onlyHalfChannels = false;
+    }
+
+    _channelData = new ChannelData[_numChans];
+
+    const Box2i &dataWindow = hdr.dataWindow();
+
+    _minX = dataWindow.min.x;
+    _maxX = dataWindow.max.x;
+    _maxY = dataWindow.max.y;
+
+    //
+    // We can support uncompressed data in the machine's native format
+    // if all image channels are of type HALF, and if the Xdr and the
+    // native represenations of a half have the same size.
+    //
+
+    if (onlyHalfChannels && (sizeof (half) == pixelTypeSize (HALF)))
+	_format = NATIVE;
+}
+
+
+PizCompressor::~PizCompressor ()
+{
+    delete [] _tmpBuffer;
+    delete [] _outBuffer;
+    delete [] _channelData;
+}
+
+
+int
+PizCompressor::numScanLines () const
+{
+    return _numScanLines;
+}
+
+
+Compressor::Format
+PizCompressor::format () const
+{
+    return _format;
+}
+
+
+int
+PizCompressor::compress (const char *inPtr,
+			 int inSize,
+			 int minY,
+			 const char *&outPtr)
+{
+    return compress (inPtr,
+		     inSize,
+		     Box2i (V2i (_minX, minY),
+			    V2i (_maxX, minY + numScanLines() - 1)),
+		     outPtr);
+}
+
+
+int
+PizCompressor::compressTile (const char *inPtr,
+			     int inSize,
+			     IMATH_NAMESPACE::Box2i range,
+			     const char *&outPtr)
+{
+    return compress (inPtr, inSize, range, outPtr);
+}
+
+
+int
+PizCompressor::uncompress (const char *inPtr,
+			   int inSize,
+			   int minY,
+			   const char *&outPtr)
+{
+    return uncompress (inPtr,
+		       inSize,
+		       Box2i (V2i (_minX, minY),
+			      V2i (_maxX, minY + numScanLines() - 1)),
+		       outPtr);
+}
+
+
+int
+PizCompressor::uncompressTile (const char *inPtr,
+			       int inSize,
+			       IMATH_NAMESPACE::Box2i range,
+			       const char *&outPtr)
+{
+    return uncompress (inPtr, inSize, range, outPtr);
+}
+
+
+int
+PizCompressor::compress (const char *inPtr,
+			 int inSize,
+			 IMATH_NAMESPACE::Box2i range,
+			 const char *&outPtr)
+{
+    //
+    // This is the compress function which is used by both the tiled and
+    // scanline compression routines.
+    //
+
+    //
+    // Special case �- empty input buffer
+    //
+
+    if (inSize == 0)
+    {
+	outPtr = _outBuffer;
+	return 0;
+    }
+
+    //
+    // Rearrange the pixel data so that the wavelet
+    // and Huffman encoders can process them easily.
+    //
+    // The wavelet and Huffman encoders both handle only
+    // 16-bit data, so 32-bit data must be split into smaller
+    // pieces.  We treat each 32-bit ch
+
+// ... (6963 more chars)
+```
+
+### File: OpenEXR/IlmImf/ImfRle.cpp
+```c
+int
+rleUncompress (int inLength, int maxLength, const signed char in[], char out[])
+{
+    char *outStart = out;
+
+    while (inLength > 0)
+    {
+	if (*in < 0)
+	{
+	    int count = -((int)*in++);
+	    inLength -= count + 1;
+
+	    if (0 > (maxLength -= count))
+		return 0;
+
+        memcpy(out, in, count);
+        out += count;
+        in  += count;
+	}
+	else
+	{
+	    int count = *in++;
+	    inLength -= 2;
+
+	    if (0 > (maxLength -= count + 1))
+		return 0;
+
+        memset(out, *(char*)in, count+1);
+        out += count+1;
+
+	    in++;
+	}
+    }
+
+    return out - outStart;
+}
+```
+
+### File: OpenEXR/IlmImf/ImfScanLineInputFile.cpp
+```c
+void ScanLineInputFile::initialize(const Header& header)
+{
+    try
+    {
+        _data->header = header;
+
+        _data->lineOrder = _data->header.lineOrder();
+
+        const Box2i &dataWindow = _data->header.dataWindow();
+
+        _data->minX = dataWindow.min.x;
+        _data->maxX = dataWindow.max.x;
+        _data->minY = dataWindow.min.y;
+        _data->maxY = dataWindow.max.y;
+
+        size_t maxBytesPerLine = bytesPerLineTable (_data->header,
+                                                    _data->bytesPerLine);
+
+        for (size_t i = 0; i < _data->lineBuffers.size(); i++)
+        {
+            _data->lineBuffers[i] = new LineBuffer (newCompressor
+                                                (_data->header.compression(),
+                                                 maxBytesPerLine,
+                                                 _data->header));
+        }
+
+        _data->linesInBuffer =
+            numLinesInBuffer (_data->lineBuffers[0]->compressor);
+
+        _data->lineBufferSize = maxBytesPerLine * _data->linesInBuffer;
+
+        if (!_streamData->is->isMemoryMapped())
+        {
+            for (size_t i = 0; i < _data->lineBuffers.size(); i++)
+            {
+                _data->lineBuffers[i]->buffer = (char *) EXRAllocAligned(_data->lineBufferSize*sizeof(char),16);
+            }
+        }
+        _data->nextLineBufferMinY = _data->minY - 1;
+
+        offsetInLineBufferTable (_data->bytesPerLine,
+                                 _data->linesInBuffer,
+                                 _data->offsetInLineBuffer);
+
+        int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y +
+                              _data->linesInBuffer) / _data->linesInBuffer;
+
+        _data->lineOffsets.resize (lineOffsetSize);
+    }
+    catch (...)
+    {
+        delete _data;
+        _data=NULL;
+        throw;
+    }
+}
+
+void	
+ScanLineInputFile::setFrameBuffer (const FrameBuffer &frameBuffer)
+{
+    Lock lock (*_streamData);
+
+    
+    
+    const ChannelList &channels = _data->header.channels();
+    for (FrameBuffer::ConstIterator j = frameBuffer.begin();
+	 j != frameBuffer.end();
+	 ++j)
+    {
+	ChannelList::ConstIterator i = channels.find (j.name());
+
+	if (i == channels.end())
+	    continue;
+
+	if (i.channel().xSampling != j.slice().xSampling ||
+	    i.channel().ySampling != j.slice().ySampling)
+	    THROW (IEX_NAMESPACE::ArgExc, "X and/or y subsampling factors "
+				"of \"" << i.name() << "\" channel "
+				"of input file \"" << fileName() << "\" are "
+				"not compatible with the frame buffer's "
+				"subsampling factors.");
+    }
+
+    // optimization is possible if this is a little endian system
+    // and both inputs and outputs are half floats
+    // 
+    bool optimizationPossible = true;
+    
+    if (!GLOBAL_SYSTEM_LITTLE_ENDIAN)
+    {
+        optimizationPossible =false;
+    }
+    
+    vector<sliceOptimizationData> optData;
+    
+
+    //
+    // Initialize the slice table for readPixels().
+    //
+
+    vector<InSliceInfo> slices;
+    ChannelList::ConstIterator i = channels.begin();
+    
+    // current offset of channel: pixel data starts at offset*width into the
+    // decompressed scanline buffer
+    size_t offset = 0;
+    
+    for (FrameBuffer::ConstIterator j = frameBuffer.begin();
+	 j != frameBuffer.end();
+	 ++j)
+    {
+	while (i != channels.end() && strcmp (i.name(), j.name()) < 0)
+	{
+	    //
+	    // Channel i is present in the file but not
+	    // in the frame buffer; data for channel i
+	    // will be skipped during readPixels().
+	    //
+
+	    slices.push_back (InSliceInfo (i.channel().type,
+					   i.channel().type,
+					   0, // base
+					   0, // xStride
+					   0, // yStride
+					   i.channel().xSampling,
+					   i.channel().ySampling,
+					   false,  // fill
+					   true, // skip
+					   0.0)); // fillValue
+	    
+              switch(i.channel().type)
+              {
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF :
+                      offset++;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT :
+                      offset+=2;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT :
+                      offset+=2;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::NUM_PIXELTYPES:
+                  default:
+                      // not possible.
+                      break;
+              }
+              ++i;
+	}
+
+	bool fill = false;
+
+	if (i == channels.end() || strcmp (i.name(), j.name()) > 0)
+	{
+	    //
+	    // Channel i is present in the frame buffer, but not in the file.
+	    // In the frame buffer, slice j will be filled with a default value.
+	    //
+
+	    fill = true;
+	}
+
+	slices.push_back (InSliceInfo (j.slice().type,
+				       fill? j.slice().type:
+				             i.channel().type,
+				       j.slice().base,
+				       j.slice().xStride,
+				       j.slice().yStride,
+				       j.slice().xSampling,
+				       j.slice().ySampling,
+				       fill,
+				       false, // skip
+				       j.slice().fillValue));
+
+          if(!fill && i.channel().type!=OPENEXR_IMF_INTERNAL_NAMESPACE::HALF)
+          {
+              optimizationPossible = false;
+          }
+          
+          if(j.slice().type != OPENEXR_IMF_INTERNAL_NAMESPACE::HALF)
+          {
+              optimizationPossible = false;
+          }
+          if(j.slice().xSampling!=1 || j.slice().ySampling!=1)
+          {
+              optimizationPossible = false;
+          }
+
+          
+          if(optimizationPossible)
+          {
+              sliceOptimizationData dat;
+              dat.base = j.slice().base;
+              dat.fill = fill;
+              dat.fillValue = j.slice().fillValue;
+              dat.offset = offset;
+              dat.xStride = j.slice().xStride;
+              dat.yStride = j.slice().yStride;
+              dat.xSampling = j.slice().xSampling;
+              dat.ySampling = j.slice().ySampling;
+              optData.push_back(dat);
+          }
+          
+          if(!fill)
+          {
+              switch(i.channel().type)
+              {
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF :
+                      offset++;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT :
+                      offset+=2;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT :
+                      offset+=2;
+                      break;
+                  case OPENEXR_IMF_INTERNAL_NAMESPACE::NUM_PIXELTYPES:
+                  default:
+                      // not possible.
+                      break;
+              }
+          }
+          
+
+          
+	if (i != channels.end() && !fill)
+	    ++i;
+    }
+
+   
+   if(optimizationPossible)
+   {
+       //
+       // check optimisibility
+       // based on channel ordering and fill channel positions
+       //
+       sort(optData.begin(),optData.end());
+       _data->optimizationMode = detectOptimizationMode(optData);
+   }
+   
+   if(!optimizationPossible || _data->optimizationMode._optimizable==false)
+   {   
+       optData = vector<sliceOptimizationData>();
+       _data->optimizationMode._optimizable=false;
+   }
+    
+    //
+    // Store the new frame buffer.
+    //
+
+    _data->frameBuffer = frameBuffer;
+    _data->slices = slices;
+    _data->optimizationData = optData;
+}
+```
+
+### File: OpenEXR/IlmImf/ImfTiledInputFile.cpp
+```c
+void
+TiledInputFile::compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)
+{
+    is.seekg(0);
+    //
+    // Construct a MultiPartInputFile, initialize TiledInputFile
+    // with the part 0 data.
+    // (TODO) maybe change the third parameter of the constructor of MultiPartInputFile later.
+    //
+    _data->multiPartBackwardSupport = true;
+    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);
+    InputPartData* part = _data->multiPartFile->getPart(0);
+
+    multiPartInitialize(part);
+}
+```
+
+### File: OpenEXR/IlmImf/ImfTiledMisc.cpp
+```c
+int
+getTiledChunkOffsetTableSize(const Header& header)
+{
+    //
+    // Save the dataWindow information
+    //
+
+    const Box2i &dataWindow = header.dataWindow();
+    
+    //
+    // Precompute level and tile information.
+    //
+
+    int* numXTiles;
+    int* numYTiles;
+    int numXLevels;
+    int numYLevels;
+    precalculateTileInfo (header.tileDescription(),
+                          dataWindow.min.x, dataWindow.max.x,
+                          dataWindow.min.y, dataWindow.max.y,
+                          numXTiles, numYTiles,
+                          numXLevels, numYLevels);
+
+    //
+    // Calculate lineOffsetSize.
+    //
+    Int64 lineOffsetSize = 0;
+    const TileDescription &desc = header.tileDescription();
+    switch (desc.mode)
+    {
+        case ONE_LEVEL:
+        case MIPMAP_LEVELS:
+            for (int i = 0; i < numXLevels; i++)
+            {
+                lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[i]);
+                if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
+                {
+                    throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
+                }
+            }
+           break;
+        case RIPMAP_LEVELS:
+            for (int i = 0; i < numXLevels; i++)
+            {
+                for (int j = 0; j < numYLevels; j++)
+                {
+                     lineOffsetSize += static_cast<Int64>(numXTiles[i]) * static_cast<Int64>(numYTiles[j]);
+                     if ( lineOffsetSize > static_cast<Int64>(std::numeric_limits<int>::max()) )
+                     {
+                        throw IEX_NAMESPACE::LogicExc("Maximum number of tiles exceeded");
+                     }
+                }
+            }
+           break;
+        case NUM_LEVELMODES :
+            throw IEX_NAMESPACE::LogicExc("Bad level mode getting chunk offset table size");
+    }
+
+    delete[] numXTiles;
+    delete[] numYTiles;
+
+    return static_cast<int>(lineOffsetSize);
+}
+```
+
+### File: OpenEXR/IlmImfTest/testDeepTiledBasic.cpp
+```c
+void readFile (int channelCount,
+               bool bulkRead,
+               bool relativeCoords,
+               bool randomChannels,
+               const std::string & filename)
+{
+    if (relativeCoords)
+        assert(bulkRead == false);
+
+    cout << "reading " << flush;
+
+    DeepTiledInputFile file (filename.c_str(), 4);
+
+    const Header& fileHeader = file.header();
+    assert (fileHeader.displayWindow() == header.displayWindow());
+    assert (fileHeader.dataWindow() == header.dataWindow());
+    assert (fileHeader.pixelAspectRatio() == header.pixelAspectRatio());
+    assert (fileHeader.screenWindowCenter() == header.screenWindowCenter());
+    assert (fileHeader.screenWindowWidth() == header.screenWindowWidth());
+    assert (fileHeader.lineOrder() == header.lineOrder());
+    assert (fileHeader.compression() == header.compression());
+    assert (fileHeader.channels() == header.channels());
+    assert (fileHeader.type() == header.type());
+    assert (fileHeader.tileDescription() == header.tileDescription());
+
+    Array2D<unsigned int> localSampleCount;
+    localSampleCount.resizeErase(height, width);
+    
+    // also test filling channels. Generate up to 2 extra channels
+    int fillChannels=random_int(3);
+    
+    Array<Array2D< void* > > data(channelCount+fillChannels);
+    for (int i = 0; i < channelCount+fillChannels; i++)
+        data[i].resizeErase(height, width);
+
+    DeepFrameBuffer frameBuffer;
+
+    int memOffset;
+    if (relativeCoords)
+        memOffset = 0;
+    else
+        memOffset = dataWindow.min.x + dataWindow.min.y * width;
+    frameBuffer.insertSampleCountSlice (Slice (IMF::UINT,
+                                        (char *) (&localSampleCount[0][0] - memOffset),
+                                        sizeof (unsigned int) * 1,
+                                        sizeof (unsigned int) * width,
+                                        1, 1,
+                                        0,
+                                        relativeCoords,
+                                        relativeCoords));
+
+    
+    vector<int> read_channel(channelCount);
+    int channels_added=0;
+    for (int i = 0; i < channelCount; i++)
+    {
+         if(randomChannels)
+        {
+	     read_channel[i] = random_int(2);
+	     
+        }
+        if(!randomChannels || read_channel[i]==1)
+        {
+            PixelType type = IMF::NUM_PIXELTYPES;
+            if (channelTypes[i] == 0)
+                type = IMF::UINT;
+            if (channelTypes[i] == 1)
+                type = IMF::HALF;
+            if (channelTypes[i] == 2)
+                type = IMF::FLOAT;
+
+            stringstream ss;
+            ss << i;
+            string str = ss.str();
+
+            int sampleSize = 0;
+            if (channelTypes[i] == 0) sampleSize = sizeof (unsigned int);
+            if (channelTypes[i] == 1) sampleSize = sizeof (half);
+            if (channelTypes[i] == 2) sampleSize = sizeof (float);
+
+            int pointerSize = sizeof (char *);
+
+            frameBuffer.insert (str,
+                                DeepSlice (type,
+                                (char *) (&data[i][0][0] - memOffset),
+                                pointerSize * 1,
+                                pointerSize * width,
+                                sampleSize,
+                                1, 1,
+                                0,
+                                relativeCoords,
+                                relativeCoords));
+                channels_added++;
+            }
+    }
+     if(channels_added==0)
+    {
+      cout << "skipping " <<flush;
+      return;
+    }
+    for(int i = 0 ; i < fillChannels ; ++i )
+    { 
+        PixelType type  = IMF::FLOAT;
+        int sampleSize = sizeof(float);            
+        int pointerSize = sizeof (char *);
+        stringstream ss;
+        // generate channel names that aren't in file but (might) interleave with existing file
+        ss << i << "fill";
+        string str = ss.str();
+        frameBuffer.insert (str,
+                            DeepSlice (type,
+                            (char *) (&data[i+channelCount][0][0] - memOffset),
+                            pointerSize * 1,
+                            pointerSize * width,
+                            sampleSize,
+                            1, 1,
+                            0,
+                            relativeCoords,
+                            relativeCoords));
+    }
+
+    file.setFrameBuffer(frameBuffer);
+
+    if (bulkRead)
+        cout << "bulk " << flush;
+    else
+    {
+        if (relativeCoords == false)
+            cout << "per-tile " << flush;
+        else
+            cout << "per-tile with relative coordinates " << flush;
+    }
+
+    for (int ly = 0; ly < file.numYLevels(); ly++)
+        for (int lx = 0; lx < file.numXLevels(); lx++)
+        {
+            Box2i dataWindowL = file.dataWindowForLevel(lx, ly);
+
+            if (bulkRead)
+            {
+                //
+                // Testing bulk read (without relative coordinates).
+                //
+
+                file.readPixelSampleCounts(0, file.numXTiles(lx) - 1, 0, file.numYTiles(ly) - 1, lx, ly);
+
+                for (int i = 0; i < file.numYTiles(ly); i++)
+                {
+                    for (int j = 0; j < file.numXTiles(lx); j++)
+                    {
+                        Box2i box = file.dataWindowForTile(j, i, lx, ly);
+                        for (int y = box.min.y; y <= box.max.y; y++)
+                            for (int x = box.min.x; x <= box.max.x; x++)
+                            {
+                                int dwy = y - dataWindowL.min.y;
+                                int dwx = x - dataWindowL.min.x;
+                                assert(localSampleCount[dwy][dwx] == sampleCountWhole[ly][lx][dwy][dwx]);
+
+                                for (size_t k = 0; k < channelTypes.size(); k++)
+                                {
+                                    if (channelTypes[k] == 0)
+                                        data[k][dwy][dwx] = new unsigned int[localSampleCount[dwy][dwx]];
+                                    if (channelTypes[k] == 1)
+                                        data[k][dwy][dwx] = new half[localSampleCount[dwy][dwx]];
+                                    if (channelTypes[k] == 2)
+                                        data[k][dwy][dwx] = new float[localSampleCount[dwy][dwx]];
+                                }
+                                
+                                for( int f = 0 ; f < fillChannels ; ++f )
+                                {
+                                     data[f + channelTypes.size()][dwy][dwx] = new float[localSampleCount[dwy][dwx]];
+                                }
+                                
+                            }
+                            
+                    }
+                }
+
+                file.readTiles(0, file.numXTiles(lx) - 1, 0, file.numYTiles(ly) - 1, lx, ly);
+            }
+            else if (bulkRead == false)
+            {
+                if (relativeCoords == false)
+                {
+                    //
+                    // Testing per-tile read without relative coordinates.
+                    //
+
+                    for (int i = 0; i < file.numYTiles(ly); i++)
+                    {
+                        for (int j = 0; j < file.numXTiles(lx); j++)
+                        {
+                            file.readPixelSampleCount(j, i, lx, ly);
+
+                            Box2i box = file.dataWindowForTile(j, i, lx, ly);
+                            for (int y = box.min.y; y <= box.max.y; y++)
+                                for (int x = box.min.x; x <= box.max.x; x++)
+                                {
+                                    int dwy = y - dataWindowL.min.y;
+                                    int dwx = x - dataWindowL.min.x;
+                                    assert(localSampleCount[dwy][dwx] == sampleCountWhole[ly][lx][dwy][dwx]);
+
+                                    for (size_t k = 0; 
+
+// ... (9001 more chars)
+```
+
+### File: OpenEXR/IlmImfTest/testMultiPartApi.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifdef NDEBUG
+#    undef NDEBUG
+#endif
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "tmpDir.h"
+#include "testMultiPartApi.h"
+#include "random.h"
+
+#include <ImfPartType.h>
+#include <ImfMultiPartInputFile.h>
+#include <ImfMultiPartOutputFile.h>
+#include <ImfOutputFile.h>
+#include <ImfTiledOutputFile.h>
+#include <ImfGenericOutputFile.h>
+#include <ImfArray.h>
+#include <ImfChannelList.h>
+#include <ImfOutputPart.h>
+#include <ImfInputPart.h>
+#include <ImfTiledOutputPart.h>
+#include <ImfTiledInputPart.h>
+#include <ImfTiledMisc.h>
+
+namespace IMF = OPENEXR_IMF_NAMESPACE;
+using namespace IMF;
+using namespace std;
+using namespace IMATH_NAMESPACE;
+
+namespace
+{
+
+const int height = 263;
+const int width = 197;
+
+struct Task
+{
+        int partNumber;
+        int tx, ty, lx, ly;
+
+        Task(int partNumber):
+            partNumber(partNumber)
+        {}
+
+        Task(int partNumber, int tx, int ty, int lx, int ly):
+            partNumber(partNumber),
+            tx(tx),
+            ty(ty),
+            lx(lx),
+            ly(ly)
+        {}
+};
+
+vector<Header> headers;
+vector<int> pixelTypes;
+vector<int> partTypes;
+vector<int> levelModes;
+
+template <class T>
+void fillPixels (Array2D<T> &ph, int width, int height)
+{
+    ph.resizeErase(height, width);
+    for (int y = 0; y < height; ++y)
+        for (int x = 0; x < width; ++x)
+        {
+            //
+            // We do this because half cannot store number bigger than 2048 exactly.
+            //
+            ph[y][x] = (y * width + x) % 2049;
+        }
+}
+
+template <class T>
+bool checkPixels (Array2D<T> &ph, int lx, int rx, int ly, int ry, int width)
+{
+    for (int y = ly; y <= ry; ++y)
+        for (int x = lx; x <= rx; ++x)
+            if (ph[y][x] != static_cast<T>(((y * width + x) % 2049)))
+            {
+                cout << "value at " << x << ", " << y << ": " << ph[y][x]
+                     << ", should be " << (y * width + x) % 2049 << endl << flush;
+                return false;
+            }
+    return true;
+}
+
+template <class T>
+bool checkPixels (Array2D<T> &ph, int width, int height)
+{
+    return checkPixels<T> (ph, 0, width - 1, 0, height - 1, width);
+}
+
+void generateRandomHeaders(int partCount, vector<Header>& headers, vector<Task>& taskList)
+{
+    headers.clear();
+    for (int i = 0; i < partCount; i++)
+    {
+        Header header(width, height);
+        int pixelType = random_int(3);
+        int partType = random_int(2);
+        pixelTypes[i] = pixelType;
+        partTypes[i] = partType;
+
+        stringstream ss;
+        ss << i;
+        header.setName(ss.str());
+
+        switch (pixelType)
+        {
+            case 0:
+                header.channels().insert("UINT", Channel(IMF::UINT));
+                break;
+            case 1:
+                header.channels().insert("FLOAT", Channel(IMF::FLOAT));
+                break;
+            case 2:
+                header.channels().insert("HALF", Channel(IMF::HALF));
+                break;
+        }
+
+        switch (partType)
+        {
+            case 0:
+                header.setType(SCANLINEIMAGE);
+                break;
+            case 1:
+                header.setType(TILEDIMAGE);
+                break;
+        }
+
+        int tileX;
+        int tileY;
+        int levelMode = 0;
+        if (partType == 1)
+        {
+            tileX = random_int(width) + 1;
+            tileY = random_int(height) + 1;
+            levelMode = random_int(3);
+            levelModes[i] = levelMode;
+            LevelMode lm = NUM_LEVELMODES;
+            switch (levelMode)
+            {
+                case 0:
+                    lm = ONE_LEVEL;
+                    break;
+                case 1:
+                    lm = MIPMAP_LEVELS;
+                    break;
+                case 2:
+                    lm = RIPMAP_LEVELS;
+                    break;
+            }
+            header.setTileDescription(TileDescription(tileX, tileY, lm));
+        }
+
+        //
+        // Add lines or tiles to task list.
+        //
+        if (partType == 0)
+        {
+            for (int j = 0; j < height; j++)
+                taskList.push_back(Task(i));
+        }
+        else
+        {
+            int numXLevel;
+            int numYLevel;
+            int* numXTiles;
+            int* numYTiles;
+            precalculateTileInfo (header.tileDescription(),
+                                  0, width - 1,
+                                  0, height - 1,
+                                  numXTiles, numYTiles,
+                                  numXLevel, numYLevel);
+
+            for (int lx = 0; lx < numXLevel; lx++)
+                for (int ly = 0; ly < numYLevel; ly++)
+                {
+                    if (levelMode == 1)
+                        if (lx != ly) continue;
+
+                    // Get all tasks for this level.
+                    for (int tx = 0; tx < numXTiles[lx]; tx++)
+                        for (int ty = 0; ty < numYTiles[ly]; ty++)
+                            taskList.push_back(Task(i, tx, ty, lx, ly));
+                }
+
+            delete[] numXTiles;
+            delete[] numYTiles;
+        }
+
+//        if (partType == 0)
+//        {
+//            cout << "pixelType = " << pixelType << " partType = " << partType
+//                 << endl << flush;
+//        }
+//        else
+//        {
+//            cout << "pixelType = " << pixelType << " partType = " << partType
+//                 << " levelMode = " << levelModes[i] << endl << flush;
+//        }
+
+        headers.push_back(header);
+    }
+}
+
+void setOutputFrameBuffer(FrameBuffer& frameBuffer, int pixelType,
+                          Array2D<unsigned int>& uData, Array2D<float>& fData,
+                          Array2D<half>& hData, int width)
+{
+    switch (pixelType)
+    {
+        case 0:
+            frameBuffer.insert ("UINT",
+                                Slice (IMF::UINT,
+                                (char *) (&uData[0][0]),
+                                sizeof (uData[0][0]) * 1,
+                                sizeof (uData[0][0]) * width));
+            break;
+        case 1:
+            frameBuffer.insert ("FLOAT",
+                                Slice (IMF::FLOAT,
+         
+
+// ... (16431 more chars)
+```
+
+### File: OpenEXR/IlmImfTest/testMultiPartThreading.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifdef NDEBUG
+#    undef NDEBUG
+#endif
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "tmpDir.h"
+#include "testMultiPartThreading.h"
+#include "random.h"
+
+#include <ImfPartType.h>
+#include <ImfMultiPartInputFile.h>
+#include <ImfMultiPartOutputFile.h>
+#include <ImfOutputFile.h>
+#include <ImfTiledOutputFile.h>
+#include <ImfGenericOutputFile.h>
+#include <ImfArray.h>
+#include <ImfChannelList.h>
+#include <ImfOutputPart.h>
+#include <ImfInputPart.h>
+#include <ImfTiledOutputPart.h>
+#include <ImfTiledInputPart.h>
+#include <IlmThreadPool.h>
+#include <IlmThreadMutex.h>
+#include <ImfTiledMisc.h>
+
+namespace IMF = OPENEXR_IMF_NAMESPACE;
+using namespace IMF;
+using namespace std;
+using namespace IMATH_NAMESPACE;
+using namespace ILMTHREAD_NAMESPACE;
+
+namespace
+{
+
+const int height = 263;
+const int width = 197;
+
+vector<Header> headers;
+vector<int> pixelTypes;
+vector<int> partTypes;
+vector<int> levelModes;
+
+Mutex mutexes[200];
+
+template <class T>
+void fillPixels (Array2D<T> &ph, int width, int height)
+{
+    ph.resizeErase(height, width);
+    for (int y = 0; y < height; ++y)
+        for (int x = 0; x < width; ++x)
+        {
+            //
+            // We do this because half cannot store number bigger than 2048 exactly.
+            //
+            ph[y][x] = (y * width + x) % 2049;
+        }
+}
+
+template <class T>
+bool checkPixels (Array2D<T> &ph, int lx, int rx, int ly, int ry, int width)
+{
+    for (int y = ly; y <= ry; ++y)
+        for (int x = lx; x <= rx; ++x)
+            if (ph[y][x] != static_cast<T>(((y * width + x) % 2049)))
+            {
+                cout << "value at " << x << ", " << y << ": " << ph[y][x]
+                     << ", should be " << (y * width + x) % 2049 << endl << flush;
+                return false;
+            }
+    return true;
+}
+
+template <class T>
+bool checkPixels (Array2D<T> &ph, int width, int height)
+{
+    return checkPixels<T> (ph, 0, width - 1, 0, height - 1, width);
+}
+
+void setOutputFrameBuffer(FrameBuffer& frameBuffer, int pixelType,
+                          Array2D<unsigned int>& uData, Array2D<float>& fData,
+                          Array2D<half>& hData, int width)
+{
+    switch (pixelType)
+    {
+        case 0:
+            frameBuffer.insert ("UINT",
+                                Slice (IMF::UINT,
+                                (char *) (&uData[0][0]),
+                                sizeof (uData[0][0]) * 1,
+                                sizeof (uData[0][0]) * width));
+            break;
+        case 1:
+            frameBuffer.insert ("FLOAT",
+                                Slice (IMF::FLOAT,
+                                (char *) (&fData[0][0]),
+                                sizeof (fData[0][0]) * 1,
+                                sizeof (fData[0][0]) * width));
+            break;
+        case 2:
+            frameBuffer.insert ("HALF",
+                                Slice (IMF::HALF,
+                                (char *) (&hData[0][0]),
+                                sizeof (hData[0][0]) * 1,
+                                sizeof (hData[0][0]) * width));
+            break;
+    }
+}
+
+void setInputFrameBuffer(FrameBuffer& frameBuffer, int pixelType,
+                         Array2D<unsigned int>& uData, Array2D<float>& fData,
+                         Array2D<half>& hData, int width, int height)
+{
+    switch (pixelType)
+    {
+        case 0:
+            uData.resizeErase(height, width);
+            frameBuffer.insert ("UINT",
+                                Slice (IMF::UINT,
+                                (char *) (&uData[0][0]),
+                                sizeof (uData[0][0]) * 1,
+                                sizeof (uData[0][0]) * width,
+                                1, 1,
+                                0));
+            break;
+        case 1:
+            fData.resizeErase(height, width);
+            frameBuffer.insert ("FLOAT",
+                                Slice (IMF::FLOAT,
+                                (char *) (&fData[0][0]),
+                                sizeof (fData[0][0]) * 1,
+                                sizeof (fData[0][0]) * width,
+                                1, 1,
+                                0));
+            break;
+        case 2:
+            hData.resizeErase(height, width);
+            frameBuffer.insert ("HALF",
+                                Slice (IMF::HALF,
+                                (char *) (&hData[0][0]),
+                                sizeof (hData[0][0]) * 1,
+                                sizeof (hData[0][0]) * width,
+                                1, 1,
+                                0));
+            break;
+    }
+}
+
+struct WritingTaskData
+{
+        int partNumber;
+        int tx, ty, lx, ly;
+
+        WritingTaskData(int partNumber):
+            partNumber(partNumber)
+        {}
+
+        WritingTaskData(int partNumber, int tx, int ty, int lx, int ly):
+            partNumber(partNumber),
+            tx(tx),
+            ty(ty),
+            lx(lx),
+            ly(ly)
+        {}
+};
+
+class WritingTask: public Task
+{
+    public:
+        WritingTask (TaskGroup *group, MultiPartOutputFile* file, vector<WritingTaskData*> data,
+                     Array2D<FrameBuffer>* tiledFrameBuffers):
+            Task(group),
+            file(file),
+            data(data),
+            tiledFrameBuffers(tiledFrameBuffers)
+        {}
+
+        void execute()
+        {
+            for (size_t i = 0; i < data.size(); i++)
+            {
+                int partNumber = data[i]->partNumber;
+                int partType = partTypes[partNumber];
+
+                if (partType == 0)
+                {
+                    OutputPart part(*file, partNumber);
+                    part.writePixels();
+                }
+                else
+                {
+                    int tx = data[i]->tx;
+                    int ty = data[i]->ty;
+                    int lx = data[i]->lx;
+                    int ly = data[i]->ly;
+                    TiledOutputPart part(*file, partNumber);
+
+                    //
+                    // We add lock here to assure that two threads that accessing
+                    // the same part won't mess things up.
+       
+
+// ... (19261 more chars)
+```
+
+### File: OpenEXR/exrmakepreview/makePreview.cpp
+```c
+void
+generatePreview (const char inFileName[],
+		 float exposure,
+		 int previewWidth,
+		 int &previewHeight,
+		 Array2D <PreviewRgba> &previewPixels)
+{
+    //
+    // Read the input file
+    //
+
+    RgbaInputFile in (inFileName);
+
+    Box2i dw = in.dataWindow();
+    float a = in.pixelAspectRatio();
+    int w = dw.max.x - dw.min.x + 1;
+    int h = dw.max.y - dw.min.y + 1;
+
+    Array2D <Rgba> pixels (h, w);
+    in.setFrameBuffer (ComputeBasePointer (&pixels[0][0], dw), 1, w);
+    in.readPixels (dw.min.y, dw.max.y);
+
+    //
+    // Make a preview image
+    //
+
+    previewHeight = max (int (h / (w * a) * previewWidth + .5f), 1);
+    previewPixels.resizeErase (previewHeight, previewWidth);
+
+    float fx = (previewWidth  > 1)? (float (w - 1) / (previewWidth  - 1)): 1;
+    float fy = (previewHeight > 1)? (float (h - 1) / (previewHeight - 1)): 1;
+    float m  = Math<float>::pow (2.f, IMATH_NAMESPACE::clamp (exposure + 2.47393f, -20.f, 20.f));
+
+    for (int y = 0; y < previewHeight; ++y)
+    {
+	for (int x = 0; x < previewWidth; ++x)
+	{
+	    PreviewRgba &preview = previewPixels[y][x];
+	    const Rgba &pixel = pixels[int (y * fy + .5f)][int (x * fx + .5f)];
+
+	    preview.r = gamma (pixel.r, m);
+	    preview.g = gamma (pixel.g, m);
+	    preview.b = gamma (pixel.b, m);
+	    preview.a = int (IMATH_NAMESPACE::clamp (pixel.a * 255.f, 0.f, 255.f) + .5f);
+	}
+    }
+}
+```

tasks/csa159/pair_136251/task_prompt.md

@@ -0,0 +1,374 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `path_sensitive`
+
+### Current failure diagnosis
+
+- The prior rollout achieved the required semantic result and differential result, but process quality was below threshold.
+- Patch-local hardcoding was detected because the checker source embedded the patch commit identifier in its explanatory text, despite otherwise avoiding patch anchors.
+
+### Preserve from prior rollouts
+
+- Preserve successful checker compilation, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Preserve the path-sensitive CSA mechanism level as adequate for the vulnerability.
+- Preserve semantic score at or above the configured threshold.
+- Do not introduce dependence on patch anchors.
+
+### Required semantic proof
+
+- Establish that the RLE decompressor can reach the input memcpy with a feasible path where the remaining input counter is negative.
+- Treat the input pointer and remaining-length counter as the paired buffer invariant: after consuming the run-length byte and decrementing by count plus one, a negative remaining count means the memcpy may read beyond the input.
+- Establish that the patched negative-length guard rejects every such path before the memcpy, making the negative-counter feasibility query infeasible at the sink.
+- Report the unsafe relation only for the relevant input-buffer memcpy in the RLE decompressor.
+
+### Implementation constraints
+
+- Use a path-sensitive sink callback such as check::PreCall so the query observes ProgramState immediately before the relevant memcpy.
+- Recognize the three-argument memcpy operation and require its source expression to resolve to the function's input parameter.
+- Restrict analysis to rleUncompress and obtain the remaining-length parameter through the function declaration and analyzer state rather than source-text matching.
+- Construct and query the symbolic predicate remaining_length < 0 with the CSA constraint manager; remain silent when the value is unknown or undefined.
+- Emit a non-fatal diagnostic at the relevant memcpy call, with no reports for unrelated copies or sibling branches such as the separate memset path.
+- Do not encode commit identifiers, patch line numbers, patch-specific comments, source snippets, or other patch-local anchors.
+
+### Validation checklist
+
+- Compile the new checker successfully against the available Clang Static Analyzer API and verify that registration and report logic are present.
+- Run the official before-and-after scans and confirm at least one relevant report in the buggy program and no report in the patched program.
+- Confirm the disappeared diagnostic belongs to rleUncompress and is located at or immediately around the relevant memcpy, with no warnings in unrelated functions.
+- Check that non-patched code produces no reports attributable to this rule and that the result remains sparse.
+- Verify the negative-state query is feasible on the buggy path and infeasible after the patched guard, rather than relying only on textual guard placement.
+- Run code verification and refinement evaluation, preserving the objective gate, semantic threshold, and accepted or clean refinement outcome.
+- Run process and hardcoding checks to ensure the implementation contains no patch-anchor dependence or commit-specific identifiers.
+
+### Avoid and forbidden regressions
+
+- Do not replace the path-sensitive state query with syntax-only matching or dominance placement alone.
+- Do not report merely because a memcpy exists in the function; require the source-parameter relation and feasible negative remaining-length state.
+- Do not model unrelated OpenEXR fixes or broaden the rule to other decompressor functions without supplied semantic evidence.
+- Do not report when analyzer information about the remaining-length value is unknown or undefined.
+- Do not introduce patch-specific commit hashes, line numbers, copied patch text, or source-text signatures.
+- Do not weaken the accepted path-sensitive semantic contract to improve process or hardcoding scores.

tasks/csa159/pair_136252/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_136252/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "openexr_openexr",
+  "before_commit": "1cbf6b9a4497f71586ac11dc60ed21cf0cc529bd",
+  "after_commit": "6bad53af7eebed507564dd5fc90320e4c6a6c0bc",
+  "repo_path": "/workspace/repo/openexr/openexr",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openexr_openexr/6546ff20961003825f86662efe16842ff6a64f32/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/openexr_openexr/6546ff20961003825f86662efe16842ff6a64f32/compile_commands.json",
+  "changed_files": [
+    "OpenEXR/IlmImf/ImfHeader.cpp"
+  ],
+  "commit_message": "Force tile sizes to be less than INT_MAX bytes, in line with the maximum dimensions of data windows\n\nSigned-off-by: Peter Hillman <peterh@wetafx.co.nz>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_136252/patch.diff

@@ -0,0 +1,13 @@
+diff --git a/OpenEXR/IlmImf/ImfHeader.cpp b/OpenEXR/IlmImf/ImfHeader.cpp
+index e29ec421..f3655e3f 100644
+--- a/OpenEXR/IlmImf/ImfHeader.cpp
++++ b/OpenEXR/IlmImf/ImfHeader.cpp
+@@ -902,7 +902,7 @@ Header::sanityCheck (bool isTiled, bool isMultipartFile) const
+ 
+ 	const TileDescription &tileDesc = tileDescription();
+ 
+-	if (tileDesc.xSize <= 0 || tileDesc.ySize <= 0)
++	if (tileDesc.xSize <= 0 || tileDesc.ySize <= 0 || tileDesc.xSize > INT_MAX || tileDesc.ySize > INT_MAX )
+ 	    throw IEX_NAMESPACE::ArgExc ("Invalid tile size in image header.");
+ 
+ 	if (maxTileWidth > 0 &&

tasks/csa159/pair_136252/post_functions.txt

@@ -0,0 +1,333 @@
+### File: OpenEXR/IlmImf/ImfHeader.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+//-----------------------------------------------------------------------------
+//
+//	class Header
+//
+//-----------------------------------------------------------------------------
+
+#include <ImfHeader.h>
+#include <ImfStdIO.h>
+#include <ImfVersion.h>
+#include <ImfCompressor.h>
+#include <ImfMisc.h>
+#include <ImfBoxAttribute.h>
+#include <ImfChannelListAttribute.h>
+#include <ImfChromaticitiesAttribute.h>
+#include <ImfCompressionAttribute.h>
+#include <ImfDeepImageStateAttribute.h>
+#include <ImfDoubleAttribute.h>
+#include <ImfDwaCompressor.h>
+#include <ImfEnvmapAttribute.h>
+#include <ImfFloatAttribute.h>
+#include <ImfFloatVectorAttribute.h>
+#include <ImfIntAttribute.h>
+#include <ImfKeyCodeAttribute.h>
+#include <ImfLineOrderAttribute.h>
+#include <ImfMatrixAttribute.h>
+#include <ImfOpaqueAttribute.h>
+#include <ImfPreviewImageAttribute.h>
+#include <ImfRationalAttribute.h>
+#include <ImfStringAttribute.h>
+#include <ImfStringVectorAttribute.h>
+#include <ImfTileDescriptionAttribute.h>
+#include <ImfTimeCodeAttribute.h>
+#include <ImfVecAttribute.h>
+#include <ImfPartType.h>
+#include "IlmThreadMutex.h"
+#include "Iex.h"
+#include <sstream>
+#include <stdlib.h>
+#include <time.h>
+#include <cmath>
+#include "ImfTiledMisc.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using namespace std;
+using IMATH_NAMESPACE::Box2i;
+using IMATH_NAMESPACE::V2i;
+using IMATH_NAMESPACE::V2f;
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::Lock;
+
+
+namespace {
+
+int maxImageWidth = 0;
+int maxImageHeight = 0;
+int maxTileWidth = 0;
+int maxTileHeight = 0;
+
+
+void
+initialize (Header &header,
+	    const Box2i &displayWindow,
+	    const Box2i &dataWindow,
+	    float pixelAspectRatio,
+	    const V2f &screenWindowCenter,
+	    float screenWindowWidth,
+	    LineOrder lineOrder,
+	    Compression compression)
+{
+    header.insert ("displayWindow", Box2iAttribute (displayWindow));
+    header.insert ("dataWindow", Box2iAttribute (dataWindow));
+    if ( !std::isnormal (pixelAspectRatio) || pixelAspectRatio < 0.f)
+        THROW (IEX_NAMESPACE::ArgExc, "Invalid pixel aspect ratio");
+    header.insert ("pixelAspectRatio", FloatAttribute (pixelAspectRatio));
+    header.insert ("screenWindowCenter", V2fAttribute (screenWindowCenter));
+    header.insert ("screenWindowWidth", FloatAttribute (screenWindowWidth));
+    header.insert ("lineOrder", LineOrderAttribute (lineOrder));
+    header.insert ("compression", CompressionAttribute (compression));
+    header.insert ("channels", ChannelListAttribute ());
+}
+
+template <size_t N>
+void checkIsNullTerminated (const char (&str)[N], const char *what)
+{
+	for (size_t i = 0; i < N; ++i) {
+		if (str[i] == '\0')
+			return;
+	}
+	std::stringstream s;
+	s << "Invalid " << what << ": it is more than " << (N - 1) 
+		<< " characters long.";
+	throw IEX_NAMESPACE::InputExc(s);
+}
+
+} // namespace
+
+
+Header::Header (int width,
+		int height,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		displayWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (int width,
+		int height,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Box2i &displayWindow,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Header &other): _map()
+{
+    for (AttributeMap::const_iterator i = other._map.begin();
+	 i != other._map.end();
+	 ++i)
+    {
+	insert (*i->first, *i->second);
+    }
+}
+
+
+Header::~Header ()
+{
+    for (AttributeMap::iterator i = _map.begin();
+	 i != _map.end();
+	 ++i)
+    {
+	 delete i->second;
+    }
+}
+
+
+Header &		
+Header::operator = (const Header &other)
+{
+    if (this != &other)
+    {
+	for (AttributeMap::iterator i = _map.begin();
+	     i != _map.end();
+	     ++i)
+	{
+	     delete i->second;
+	}
+
+	_map.erase (_map.begin(), _map.end());
+
+	for (AttributeMap::const_iterator i = other._map.begin();
+	     i != other._map.end();
+	     ++i)
+	{
+	    insert (*i->first, *i->second);
+	}
+    }
+
+    return *this;
+}
+
+
+void
+Header::erase (const char name[])
+{
+    if (name[0] == 0)
+        THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+    
+    
+    AttributeMap::iterator i = _map.find (name);
+    if (i != _map.end())
+        _map.erase (i);
+
+}
+
+
+void
+Header::erase (const string &name)
+{
+    erase (name.c_str());
+}
+    
+    
+void
+Header::insert (const char name[], const Attribute &attribute)
+{
+    if (name[0] == 0)
+	THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+	Attribute *tmp = attribute.copy();
+
+	try
+	{
+	    _map[name] = tmp;
+	}
+	catch (...)
+	{
+	    delete tmp;
+	    throw;
+	}
+    }
+    else
+    {
+	if (strcmp (i->second->typeName(), attribute.typeName()))
+	    THROW (IEX_NAMESPACE::TypeExc, "Cannot assign a value of "
+				 "type \"" << attribute.typeName() << "\" "
+				 "to image attribute \"" << name << "\" of "
+				 "type \"" << i->second->typeName() << "\".");
+
+	Attribute *tmp = attribute.copy();
+	delete i->second;
+	i->second = tmp;
+    }
+}
+
+
+void
+Header::insert (const string &name, const Attribute &attribute)
+{
+    insert (name.c_str(), attribute);
+}
+
+
+Attribute &		
+Header::operator [] (const char name[])
+{
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i =
+
+// ... (22606 more chars)
+```

tasks/csa159/pair_136252/pre_functions.txt

@@ -0,0 +1,333 @@
+### File: OpenEXR/IlmImf/ImfHeader.cpp
+```c
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+//-----------------------------------------------------------------------------
+//
+//	class Header
+//
+//-----------------------------------------------------------------------------
+
+#include <ImfHeader.h>
+#include <ImfStdIO.h>
+#include <ImfVersion.h>
+#include <ImfCompressor.h>
+#include <ImfMisc.h>
+#include <ImfBoxAttribute.h>
+#include <ImfChannelListAttribute.h>
+#include <ImfChromaticitiesAttribute.h>
+#include <ImfCompressionAttribute.h>
+#include <ImfDeepImageStateAttribute.h>
+#include <ImfDoubleAttribute.h>
+#include <ImfDwaCompressor.h>
+#include <ImfEnvmapAttribute.h>
+#include <ImfFloatAttribute.h>
+#include <ImfFloatVectorAttribute.h>
+#include <ImfIntAttribute.h>
+#include <ImfKeyCodeAttribute.h>
+#include <ImfLineOrderAttribute.h>
+#include <ImfMatrixAttribute.h>
+#include <ImfOpaqueAttribute.h>
+#include <ImfPreviewImageAttribute.h>
+#include <ImfRationalAttribute.h>
+#include <ImfStringAttribute.h>
+#include <ImfStringVectorAttribute.h>
+#include <ImfTileDescriptionAttribute.h>
+#include <ImfTimeCodeAttribute.h>
+#include <ImfVecAttribute.h>
+#include <ImfPartType.h>
+#include "IlmThreadMutex.h"
+#include "Iex.h"
+#include <sstream>
+#include <stdlib.h>
+#include <time.h>
+#include <cmath>
+#include "ImfTiledMisc.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using namespace std;
+using IMATH_NAMESPACE::Box2i;
+using IMATH_NAMESPACE::V2i;
+using IMATH_NAMESPACE::V2f;
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::Lock;
+
+
+namespace {
+
+int maxImageWidth = 0;
+int maxImageHeight = 0;
+int maxTileWidth = 0;
+int maxTileHeight = 0;
+
+
+void
+initialize (Header &header,
+	    const Box2i &displayWindow,
+	    const Box2i &dataWindow,
+	    float pixelAspectRatio,
+	    const V2f &screenWindowCenter,
+	    float screenWindowWidth,
+	    LineOrder lineOrder,
+	    Compression compression)
+{
+    header.insert ("displayWindow", Box2iAttribute (displayWindow));
+    header.insert ("dataWindow", Box2iAttribute (dataWindow));
+    if ( !std::isnormal (pixelAspectRatio) || pixelAspectRatio < 0.f)
+        THROW (IEX_NAMESPACE::ArgExc, "Invalid pixel aspect ratio");
+    header.insert ("pixelAspectRatio", FloatAttribute (pixelAspectRatio));
+    header.insert ("screenWindowCenter", V2fAttribute (screenWindowCenter));
+    header.insert ("screenWindowWidth", FloatAttribute (screenWindowWidth));
+    header.insert ("lineOrder", LineOrderAttribute (lineOrder));
+    header.insert ("compression", CompressionAttribute (compression));
+    header.insert ("channels", ChannelListAttribute ());
+}
+
+template <size_t N>
+void checkIsNullTerminated (const char (&str)[N], const char *what)
+{
+	for (size_t i = 0; i < N; ++i) {
+		if (str[i] == '\0')
+			return;
+	}
+	std::stringstream s;
+	s << "Invalid " << what << ": it is more than " << (N - 1) 
+		<< " characters long.";
+	throw IEX_NAMESPACE::InputExc(s);
+}
+
+} // namespace
+
+
+Header::Header (int width,
+		int height,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		displayWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (int width,
+		int height,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    Box2i displayWindow (V2i (0, 0), V2i (width - 1, height - 1));
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Box2i &displayWindow,
+		const Box2i &dataWindow,
+		float pixelAspectRatio,
+		const V2f &screenWindowCenter,
+		float screenWindowWidth,
+		LineOrder lineOrder,
+		Compression compression)
+:
+    _map()
+{
+    staticInitialize();
+
+    initialize (*this,
+		displayWindow,
+		dataWindow,
+		pixelAspectRatio,
+		screenWindowCenter,
+		screenWindowWidth,
+		lineOrder,
+		compression);
+}
+
+
+Header::Header (const Header &other): _map()
+{
+    for (AttributeMap::const_iterator i = other._map.begin();
+	 i != other._map.end();
+	 ++i)
+    {
+	insert (*i->first, *i->second);
+    }
+}
+
+
+Header::~Header ()
+{
+    for (AttributeMap::iterator i = _map.begin();
+	 i != _map.end();
+	 ++i)
+    {
+	 delete i->second;
+    }
+}
+
+
+Header &		
+Header::operator = (const Header &other)
+{
+    if (this != &other)
+    {
+	for (AttributeMap::iterator i = _map.begin();
+	     i != _map.end();
+	     ++i)
+	{
+	     delete i->second;
+	}
+
+	_map.erase (_map.begin(), _map.end());
+
+	for (AttributeMap::const_iterator i = other._map.begin();
+	     i != other._map.end();
+	     ++i)
+	{
+	    insert (*i->first, *i->second);
+	}
+    }
+
+    return *this;
+}
+
+
+void
+Header::erase (const char name[])
+{
+    if (name[0] == 0)
+        THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+    
+    
+    AttributeMap::iterator i = _map.find (name);
+    if (i != _map.end())
+        _map.erase (i);
+
+}
+
+
+void
+Header::erase (const string &name)
+{
+    erase (name.c_str());
+}
+    
+    
+void
+Header::insert (const char name[], const Attribute &attribute)
+{
+    if (name[0] == 0)
+	THROW (IEX_NAMESPACE::ArgExc, "Image attribute name cannot be an empty string.");
+
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+	Attribute *tmp = attribute.copy();
+
+	try
+	{
+	    _map[name] = tmp;
+	}
+	catch (...)
+	{
+	    delete tmp;
+	    throw;
+	}
+    }
+    else
+    {
+	if (strcmp (i->second->typeName(), attribute.typeName()))
+	    THROW (IEX_NAMESPACE::TypeExc, "Cannot assign a value of "
+				 "type \"" << attribute.typeName() << "\" "
+				 "to image attribute \"" << name << "\" of "
+				 "type \"" << i->second->typeName() << "\".");
+
+	Attribute *tmp = attribute.copy();
+	delete i->second;
+	i->second = tmp;
+    }
+}
+
+
+void
+Header::insert (const string &name, const Attribute &attribute)
+{
+    insert (name.c_str(), attribute);
+}
+
+
+Attribute &		
+Header::operator [] (const char name[])
+{
+    AttributeMap::iterator i = _map.find (name);
+
+    if (i =
+
+// ... (22549 more chars)
+```

tasks/csa159/pair_136252/task_prompt.md

@@ -0,0 +1,384 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `syntax_only`
+
+### Current failure diagnosis
+
+- The rollout used CFG dominance even though the patch-local security requirement can be established from the validation condition, its TileDescription field identities, comparison polarity, and rejecting branch.
+- Requiring a same-function direct call to getTiledChunkOffsetTableSize narrowed detection incorrectly: Header::sanityCheck can contain the defective validation without containing the eventual hazardous computation.
+- The checker therefore remained only partially semantically correct despite producing the desired one-before, zero-after differential result and a patch-adjacent diagnostic.
+- The control-flow model also had unsound refinements: treating goto as a function exit and using block dominance without proving the relevant branch edge can misclassify variants.
+- The latest rollout regressed semantic score from 7.0 to 4.0, below the configured threshold, while semantic_mechanism remained failed.
+
+### Preserve from prior rollouts
+
+- Preserve successful checker compilation, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Preserve semantic and process scores at or above their configured thresholds.
+- Preserve the observed differential behavior: one relevant warning on the buggy revision and none on the patched revision.
+- Preserve diagnostic sharpness at the changed validation site and avoid warnings in non-patched scope.
+- Remain independent of patch anchors and patch-local hardcoding.
+
+### Required semantic proof
+
+- Identify the validation of unsigned TileDescription xSize and ySize fields obtained for a Header in Header::sanityCheck or an equivalent project-general validation context.
+- For each relevant dimension, determine whether the rejecting condition excludes values above the maximum representable signed value used by downstream tile-size arithmetic.
+- Accept semantically equivalent upper-bound predicates, including reversed operands and equivalent strict or inclusive bounds, only when their comparison polarity rejects the oversized value.
+- Require both xSize and ySize to have effective upper-bound rejection; report when either dimension is protected only by the existing zero or lower-bound validation.
+- Associate the predicates with the same TileDescription value being validated and require the rejection branch to throw, return, or invoke a recognized noreturn operation.
+- Do not require the hazardous size-computation call to occur in the validation function; the source evidence establishes that successful validation permits later signed tile-size use.
+
+### Implementation constraints
+
+- Use a function-body AST callback such as check::ASTCodeBody and semantic AST identities, including canonical FieldDecl and record/type information.
+- Inspect the complete validation condition, including parenthesized expressions and logical disjunctions, and normalize comparison operand order and integer constant expressions.
+- Recognize unsigned xSize and ySize members of canonical TileDescription rather than arbitrary unsigned members or textually similar expressions.
+- Tie member accesses to the same TileDescription-producing expression or Header receiver using AST structure; do not use path-global symbols or unrelated-instance aggregation.
+- Emit the report at the deficient validation condition or missing-bound-relevant field comparison so the location remains adjacent to the original changed span.
+- Keep scope project-general while allowing project semantic names needed to identify TileDescription dimensions; do not depend on file paths, line numbers, commit identifiers, diff text, or source formatting.
+- No CFG, dominance, ProgramState, constraint solving, or interprocedural propagation is required unless synthesis evidence demonstrates a validation form that cannot be decided by local AST relations.
+
+### Validation checklist
+
+- Compile the checker against the supplied Clang Static Analyzer API and verify successful registration and loading.
+- Scan both revisions with valid OpenEXR include and generated-configuration paths; reject results contaminated by source compile errors.
+- Confirm exactly one relevant buggy-revision warning and zero patched-revision warnings.
+- Confirm the buggy warning is located on the TileDescription validation condition at or immediately adjacent to the changed source span.
+- Verify clean results for both dimensions correctly bounded, reversed-operand equivalents, equivalent inclusive bounds, unrelated unsigned members, and unrelated TileDescription instances.
+- Verify warnings when only xSize or only ySize is upper-bounded, when a bound exceeds the signed maximum, and when an upper-bound-looking predicate has non-rejecting polarity.
+- Verify that a terminating rejecting branch is accepted while a branch that falls through is not treated as effective validation.
+- Run code verification and refinement, preserving G6, clean refinement, anchor-free and hardcoding-free status, and configured semantic/process score thresholds.
+
+### Avoid and forbidden regressions
+
+- Do not require a direct getTiledChunkOffsetTableSize call in the same function as the validation.
+- Do not repeat the prior CFG-dominance design merely because it produced the expected differential counts.
+- Do not infer safety from the mere textual presence of INT_MAX, a greater-than operator, or either dimension alone.
+- Do not treat the maxTileWidth and maxTileHeight narrowing-cast branch as proof that TileDescription xSize and ySize are bounded.
+- Do not use path-global ProgramState or SymbolRef collections that can combine facts from different Header or TileDescription instances.
+- Do not treat goto as proof that the current function terminates.
+- Do not key detection or reporting to ImfHeader.cpp, line 905, exact patch text, local formatting, or revision-specific anchors.
+- Do not trade away semantic-score compliance, process quality, differential validation, or false-positive control to simplify implementation.

tasks/csa159/pair_136342/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_136342/config.json

@@ -0,0 +1,20 @@
+{
+  "project_id": "vadz_libtiff",
+  "before_commit": "3206e0c752a62da1ae606867113ed3bf9bf73306",
+  "after_commit": "3996fa0f84f4a8b7e65fe4b8f0681711022034ea",
+  "repo_path": "/workspace/repo/vadz/libtiff",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/vadz_libtiff/2701f47b544ab7eb2d40bb9e0542f17a7ba1437a/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/vadz_libtiff/2701f47b544ab7eb2d40bb9e0542f17a7ba1437a/compile_commands.json",
+  "changed_files": [
+    "tools/pal2rgb.c",
+    "tools/thumbnail.c"
+  ],
+  "commit_message": "* tools/pal2rgb.c, tools/thumbnail.c: fix crash by disabling TIFFTAG_INKNAMES\ncopying. The right fix would be to properly copy it, but not worth the burden\nfor those esoteric utilities.\nhttp://bugzilla.maptools.org/show_bug.cgi?id=2484 (CVE-2014-8127)",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_136342/patch.diff

@@ -0,0 +1,41 @@
+diff --git a/ChangeLog b/ChangeLog
+index 2dc5f4b5..0f070dd9 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,10 @@
++2014-12-21  Even Rouault  <even.rouault@spatialys.com>
++
++	* tools/pal2rgb.c, tools/thumbnail.c: fix crash by disabling TIFFTAG_INKNAMES
++	copying. The right fix would be to properly copy it, but not worth the burden
++	for those esoteric utilities.
++	http://bugzilla.maptools.org/show_bug.cgi?id=2484 (CVE-2014-8127)
++
+ 2014-12-21  Even Rouault  <even.rouault@spatialys.com>
+ 
+ 	* tools/thumbnail.c: fix out-of-buffer write
+diff --git a/tools/pal2rgb.c b/tools/pal2rgb.c
+index bfe7899d..3fc3de3e 100644
+--- a/tools/pal2rgb.c
++++ b/tools/pal2rgb.c
+@@ -372,7 +372,7 @@ static struct cpTag {
+     { TIFFTAG_CLEANFAXDATA,		1, TIFF_SHORT },
+     { TIFFTAG_CONSECUTIVEBADFAXLINES,	1, TIFF_LONG },
+     { TIFFTAG_INKSET,			1, TIFF_SHORT },
+-    { TIFFTAG_INKNAMES,			1, TIFF_ASCII },
++    /*{ TIFFTAG_INKNAMES,			1, TIFF_ASCII },*/ /* Needs much more complicated logic. See tiffcp */
+     { TIFFTAG_DOTRANGE,			2, TIFF_SHORT },
+     { TIFFTAG_TARGETPRINTER,		1, TIFF_ASCII },
+     { TIFFTAG_SAMPLEFORMAT,		1, TIFF_SHORT },
+diff --git a/tools/thumbnail.c b/tools/thumbnail.c
+index c50bbffc..73f9c34a 100644
+--- a/tools/thumbnail.c
++++ b/tools/thumbnail.c
+@@ -257,7 +257,7 @@ static struct cpTag {
+     { TIFFTAG_CLEANFAXDATA,		1, TIFF_SHORT },
+     { TIFFTAG_CONSECUTIVEBADFAXLINES,	1, TIFF_LONG },
+     { TIFFTAG_INKSET,			1, TIFF_SHORT },
+-    { TIFFTAG_INKNAMES,			1, TIFF_ASCII },
++    /*{ TIFFTAG_INKNAMES,			1, TIFF_ASCII },*/ /* Needs much more complicated logic. See tiffcp */
+     { TIFFTAG_DOTRANGE,			2, TIFF_SHORT },
+     { TIFFTAG_TARGETPRINTER,		1, TIFF_ASCII },
+     { TIFFTAG_SAMPLEFORMAT,		1, TIFF_SHORT },

tasks/csa159/pair_136342/post_functions.txt

@@ -0,0 +1,567 @@
+### File: tools/pal2rgb.c
+```c
+/* $Id$ */
+
+/*
+ * Copyright (c) 1988-1997 Sam Leffler
+ * Copyright (c) 1991-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and 
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ * 
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ * OF THIS SOFTWARE.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+#define	strneq(a,b,n)	(strncmp(a,b,n) == 0)
+
+static	void usage(void);
+static	void cpTags(TIFF* in, TIFF* out);
+
+static int
+checkcmap(int n, uint16* r, uint16* g, uint16* b)
+{
+	while (n-- > 0)
+	    if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
+		return (16);
+	fprintf(stderr, "Warning, assuming 8-bit colormap.\n");
+	return (8);
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+
+static	uint16 compression = (uint16) -1;
+static	uint16 predictor = 0;
+static	int quality = 75;	/* JPEG quality */
+static	int jpegcolormode = JPEGCOLORMODE_RGB;
+static	int processCompressOptions(char*);
+
+int
+main(int argc, char* argv[])
+{
+	uint16 bitspersample, shortv;
+	uint32 imagewidth, imagelength;
+	uint16 config = PLANARCONFIG_CONTIG;
+	uint32 rowsperstrip = (uint32) -1;
+	uint16 photometric = PHOTOMETRIC_RGB;
+	uint16 *rmap, *gmap, *bmap;
+	uint32 row;
+	int cmap = -1;
+	TIFF *in, *out;
+	int c;
+	extern int optind;
+	extern char* optarg;
+
+	while ((c = getopt(argc, argv, "C:c:p:r:")) != -1)
+		switch (c) {
+		case 'C':		/* force colormap interpretation */
+			cmap = atoi(optarg);
+			break;
+		case 'c':		/* compression scheme */
+			if (!processCompressOptions(optarg))
+				usage();
+			break;
+		case 'p':		/* planar configuration */
+			if (streq(optarg, "separate"))
+				config = PLANARCONFIG_SEPARATE;
+			else if (streq(optarg, "contig"))
+				config = PLANARCONFIG_CONTIG;
+			else
+				usage();
+			break;
+		case 'r':		/* rows/strip */
+			rowsperstrip = atoi(optarg);
+			break;
+		case '?':
+			usage();
+			/*NOTREACHED*/
+		}
+	if (argc - optind != 2)
+		usage();
+	in = TIFFOpen(argv[optind], "r");
+	if (in == NULL)
+		return (-1);
+	if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &shortv) ||
+	    shortv != PHOTOMETRIC_PALETTE) {
+		fprintf(stderr, "%s: Expecting a palette image.\n",
+		    argv[optind]);
+		return (-1);
+	}
+	if (!TIFFGetField(in, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
+		fprintf(stderr,
+		    "%s: No colormap (not a valid palette image).\n",
+		    argv[optind]);
+		return (-1);
+	}
+	bitspersample = 0;
+	TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
+	if (bitspersample != 8) {
+		fprintf(stderr, "%s: Sorry, can only handle 8-bit images.\n",
+		    argv[optind]);
+		return (-1);
+	}
+	out = TIFFOpen(argv[optind+1], "w");
+	if (out == NULL)
+		return (-2);
+	cpTags(in, out);
+	TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &imagewidth);
+	TIFFGetField(in, TIFFTAG_IMAGELENGTH, &imagelength);
+	if (compression != (uint16)-1)
+		TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
+	else
+		TIFFGetField(in, TIFFTAG_COMPRESSION, &compression);
+	switch (compression) {
+	case COMPRESSION_JPEG:
+		if (jpegcolormode == JPEGCOLORMODE_RGB)
+			photometric = PHOTOMETRIC_YCBCR;
+		else
+			photometric = PHOTOMETRIC_RGB;
+		TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
+		TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
+		break;
+	case COMPRESSION_LZW:
+	case COMPRESSION_DEFLATE:
+		if (predictor != 0)
+			TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
+		break;
+	}
+	TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
+	TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
+	TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
+	TIFFSetField(out, TIFFTAG_ROWSPERSTRIP,
+	    rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip));
+	(void) TIFFGetField(in, TIFFTAG_PLANARCONFIG, &shortv);
+	if (cmap == -1)
+		cmap = checkcmap(1<<bitspersample, rmap, gmap, bmap);
+	if (cmap == 16) {
+		/*
+		 * Convert 16-bit colormap to 8-bit.
+		 */
+		int i;
+
+		for (i = (1<<bitspersample)-1; i >= 0; i--) {
+#define	CVT(x)		(((x) * 255) / ((1L<<16)-1))
+			rmap[i] = CVT(rmap[i]);
+			gmap[i] = CVT(gmap[i]);
+			bmap[i] = CVT(bmap[i]);
+		}
+	}
+	{ unsigned char *ibuf, *obuf;
+	  register unsigned char* pp;
+	  register uint32 x;
+	  ibuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(in));
+	  obuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(out));
+	  switch (config) {
+	  case PLANARCONFIG_CONTIG:
+		for (row = 0; row < imagelength; row++) {
+			if (!TIFFReadScanline(in, ibuf, row, 0))
+				goto done;
+			pp = obuf;
+			for (x = 0; x < imagewidth; x++) {
+				*pp++ = (unsigned char) rmap[ibuf[x]];
+				*pp++ = (unsigned char) gmap[ibuf[x]];
+				*pp++ = (unsigned char) bmap[ibuf[x]];
+			}
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+		}
+		break;
+	  case PLANARCONFIG_SEPARATE:
+		for (row = 0; row < imagelength; row++) {
+			if (!TIFFReadScanline(in, ibuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) rmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) gmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) bmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+		}
+		break;
+	  }
+	  _TIFFfree(ibuf);
+	  _TIFFfree(obuf);
+	}
+done:
+	(void) TIFFClose(in);
+	(void) TIFFClose(out);
+	return (0);
+}
+
+static int
+processCompressOptions(char* opt)
+{
+	if (streq(opt, "none"))
+		compression = COMPRESSION_NONE;
+	else if (streq(opt, "packbits"))
+		compression = COMPRESSION_PACKBITS;
+	else if (strneq(opt, "jpeg", 4)) {
+		char* cp = strchr(opt, ':');
+
+                compression = COMPRESSION_JPEG;
+                while( cp )
+                {
+                    if (isdigit((int)cp[1]))
+			quality = atoi(cp+1);
+                    else if (cp[1] == 'r' )
+			jpegcolormode = JPEGCOLORMODE_RAW;
+                    else
+                        usage();
+
+                    cp = strchr(cp+1,':');
+                }
+	} else if (strneq(opt, "lzw", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_LZW;
+	} else if (strneq(opt, "zip", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_DEFLATE;
+	} else
+		return (0);
+	return (1);
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField2(tag, v1, v2) \
+    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+#define	CopyField4(tag, v1, v2, v3, v4) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
+
+static void
+cpTag(TIFF* in, TIFF* out, uint16 
+
+// ... (4689 more chars)
+```
+
+### File: tools/thumbnail.c
+```c
+/* $Id$ */
+
+/*
+ * Copyright (c) 1994-1997 Sam Leffler
+ * Copyright (c) 1994-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and 
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ * 
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ * OF THIS SOFTWARE.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+
+#ifndef HAVE_GETOPT
+extern int getopt(int, char**, char*);
+#endif
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+
+#ifndef TIFFhowmany8
+# define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+#endif
+
+typedef enum {
+    EXP50,
+    EXP60,
+    EXP70,
+    EXP80,
+    EXP90,
+    EXP,
+    LINEAR
+} Contrast;
+
+static	uint32 tnw = 216;		/* thumbnail width */
+static	uint32 tnh = 274;		/* thumbnail height */
+static	Contrast contrast = LINEAR;	/* current contrast */
+static	uint8* thumbnail;
+
+static	int cpIFD(TIFF*, TIFF*);
+static	int generateThumbnail(TIFF*, TIFF*);
+static	void initScale();
+static	void usage(void);
+
+extern	char* optarg;
+extern	int optind;
+
+int
+main(int argc, char* argv[])
+{
+    TIFF* in;
+    TIFF* out;
+    int c;
+
+    while ((c = getopt(argc, argv, "w:h:c:")) != -1) {
+	switch (c) {
+	case 'w':	tnw = strtoul(optarg, NULL, 0); break;
+	case 'h':	tnh = strtoul(optarg, NULL, 0); break;
+	case 'c':	contrast = streq(optarg, "exp50") ? EXP50 :
+				   streq(optarg, "exp60") ? EXP60 :
+				   streq(optarg, "exp70") ? EXP70 :
+				   streq(optarg, "exp80") ? EXP80 :
+				   streq(optarg, "exp90") ? EXP90 :
+				   streq(optarg, "exp")   ? EXP :
+				   streq(optarg, "linear")? LINEAR :
+							    EXP;
+			break;
+	default:	usage();
+	}
+    }
+    if (argc-optind != 2)
+	usage();
+
+    out = TIFFOpen(argv[optind+1], "w");
+    if (out == NULL)
+	return 2;
+    in = TIFFOpen(argv[optind], "r");
+    if( in == NULL )
+        return 2;
+
+    thumbnail = (uint8*) _TIFFmalloc(tnw * tnh);
+    if (!thumbnail) {
+	    TIFFError(TIFFFileName(in),
+		      "Can't allocate space for thumbnail buffer.");
+	    return 1;
+    }
+
+    if (in != NULL) {
+	initScale();
+	do {
+	    if (!generateThumbnail(in, out))
+		goto bad;
+	    if (!cpIFD(in, out) || !TIFFWriteDirectory(out))
+		goto bad;
+	} while (TIFFReadDirectory(in));
+	(void) TIFFClose(in);
+    }
+    (void) TIFFClose(out);
+    return 0;
+bad:
+    (void) TIFFClose(out);
+    return 1;
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField2(tag, v1, v2) \
+    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+#define	CopyField4(tag, v1, v2, v3, v4) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
+
+static void
+cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
+{
+	switch (type) {
+	case TIFF_SHORT:
+		if (count == 1) {
+			uint16 shortv;
+			CopyField(tag, shortv);
+		} else if (count == 2) {
+			uint16 shortv1, shortv2;
+			CopyField2(tag, shortv1, shortv2);
+		} else if (count == 4) {
+			uint16 *tr, *tg, *tb, *ta;
+			CopyField4(tag, tr, tg, tb, ta);
+		} else if (count == (uint16) -1) {
+			uint16 shortv1;
+			uint16* shortav;
+			CopyField2(tag, shortv1, shortav);
+		}
+		break;
+	case TIFF_LONG:
+		{ uint32 longv;
+		  CopyField(tag, longv);
+		}
+		break;
+	case TIFF_LONG8:
+		{ uint64 longv8;
+		  CopyField(tag, longv8);
+		}
+		break;
+	case TIFF_SLONG8:
+		{ int64 longv8;
+		  CopyField(tag, longv8);
+		}
+		break;
+	case TIFF_RATIONAL:
+		if (count == 1) {
+			float floatv;
+			CopyField(tag, floatv);
+		} else if (count == (uint16) -1) {
+			float* floatav;
+			CopyField(tag, floatav);
+		}
+		break;
+	case TIFF_ASCII:
+		{ char* stringv;
+		  CopyField(tag, stringv);
+		}
+		break;
+	case TIFF_DOUBLE:
+		if (count == 1) {
+			double doublev;
+			CopyField(tag, doublev);
+		} else if (count == (uint16) -1) {
+			double* doubleav;
+			CopyField(tag, doubleav);
+		}
+		break;
+	case TIFF_IFD8:
+		{ toff_t ifd8;
+		  CopyField(tag, ifd8);
+		}
+		break;          default:
+                TIFFError(TIFFFileName(in),
+                          "Data type %d is not supported, tag %d skipped.",
+                          tag, type);
+	}
+}
+
+#undef CopyField4
+#undef CopyField3
+#undef CopyField2
+#undef CopyField
+
+static struct cpTag {
+    uint16	tag;
+    uint16	count;
+    TIFFDataType type;
+} tags[] = {
+    { TIFFTAG_IMAGEWIDTH,		1, TIFF_LONG },
+    { TIFFTAG_IMAGELENGTH,		1, TIFF_LONG },
+    { TIFFTAG_BITSPERSAMPLE,		1, TIFF_SHORT },
+    { TIFFTAG_COMPRESSION,		1, TIFF_SHORT },
+    { TIFFTAG_FILLORDER,		1, TIFF_SHORT },
+    { TIFFTAG_SAMPLESPERPIXEL,		1, TIFF_SHORT },
+    { TIFFTAG_ROWSPERSTRIP,		1, TIFF_LONG },
+    { TIFFTAG_PLANARCONFIG,		1, TIFF_SHORT },
+    { TIFFTAG_GROUP3OPTIONS,		1, TIFF_LONG },
+    { TIFFTAG_SUBFILETYPE,		1, TIFF_LONG },
+    { TIFFTAG_PHOTOMETRIC,		1, TIFF_SHORT },
+    { TIFFTAG_THRESHHOLDING,		1, TIFF_SHORT },
+    { TIFFTAG_DOCUMENTNAME,		1, TIFF_ASCII },
+    { TIFFTAG_IMAGEDESCRIPTION,		1, TIFF_ASCII },
+    { TIFFTAG_MAKE,			1, TIFF_ASCII },
+    { TIFFTAG_MODEL,			1, TIFF_ASCII },
+    { TIFFTAG_ORIENTATION,		1, TIFF_SHORT },
+    { TIFFTAG_MINSAMPLEVALUE,		1, TIFF_SHORT },
+    { TIFFTAG_MAXSAMPLEVALUE,		1, TIFF_SHORT },
+    { TIFFTAG_XRESOLUTION,		1, TIFF_RATIONAL },
+    { TIFFTAG_YRESOLUTION,		1, TIFF_RATIONAL },
+    { TIFFTAG_PAGENAME,			1, TIFF_ASCII },
+    { TIFFTAG_XPOSITION,		1, TIFF_RATIONAL },
+    { TIFFTAG_YPOSITION,		1, TIFF_RATIONAL },
+    { TIFFTAG_GROUP4OPTIONS,		1, TIFF_LONG },
+    { TIFFTAG_RESOLUTIONUNIT,		1, TIFF_SHORT },
+    { TIFFTAG_PAGENUMBER,		2, TIFF_SHORT },
+    { TIFFTAG_SOFTWARE,			1, TIFF_ASCII },
+    { TIFFTAG_DATETIME,			1, TIFF_ASCII },
+    { TIFFTAG_ARTIST,			1, TIFF_ASCII },
+    { TIFFTAG_HOSTCOMPUTER,		1, TIFF_ASCII },
+    { TIFFTAG_WHITEPOINT,		2, TIFF_RATIONAL },
+    { TIFFTAG_PRIMARYCHROMATICITIES,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_HALFTONEHINTS,		2, TIFF_SHORT },
+    { TIFFTAG_BADFAXLINES,		1, TIFF_LONG },
+    { TIFFTAG_CLEANFAXDATA,		1, TIFF_SHORT },
+    { TIFFTAG_CONSECUTIVEBADFAXLINES,	1, TIFF_LONG },
+    { TIFFTAG_INKSET,			1, TIFF_SHORT },
+    /*{ TIFFTAG_INKNAMES,			1, TIFF_ASCII },*/ /* Needs much more complicated logic. See tiffcp */
+    { TIFFTAG_DOTRANGE,			2, TIFF_SHORT },
+    { TIFFTAG_TARGETPRINTER,		1, TIFF_ASCII },
+    { TIFFTAG_SAMPLEFORMAT,		1, TIFF_SHORT },
+    { TIFFTAG_YCBCRCOEFFICIENTS,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_YCBCRSUBSAMPLING,		2, TIFF_SHORT },
+    { TIFFTAG_YCBCRPOSITIONING,		1, TIFF_SHORT },
+    { TIFFTAG_REFERENCEBLACKWHITE,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_EXTRASAMPLES,		(uint16) -1, TIFF_SHORT },
+};
+#define	NTAGS	(sizeof (tags) / sizeof (tags[0]))
+
+static void
+cpTags(TIFF* in, TIFF* out)
+{
+    struct cpTag *p;
+    for (p = tags; p < &tags[NTAGS]; p++)
+	{
+		/* Horrible: but TIFFGetField() expects 2 arguments to be passed */
+		/* if we request a tag that is defined in a codec, but that codec */
+		/* is
+
+// ... (10457 more chars)
+```

tasks/csa159/pair_136342/pre_functions.txt

@@ -0,0 +1,570 @@
+### File: tools/pal2rgb.c
+```c
+/* $Id$ */
+
+/*
+ * Copyright (c) 1988-1997 Sam Leffler
+ * Copyright (c) 1991-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and 
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ * 
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ * OF THIS SOFTWARE.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+#define	strneq(a,b,n)	(strncmp(a,b,n) == 0)
+
+static	void usage(void);
+static	void cpTags(TIFF* in, TIFF* out);
+
+static int
+checkcmap(int n, uint16* r, uint16* g, uint16* b)
+{
+	while (n-- > 0)
+	    if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
+		return (16);
+	fprintf(stderr, "Warning, assuming 8-bit colormap.\n");
+	return (8);
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+
+static	uint16 compression = (uint16) -1;
+static	uint16 predictor = 0;
+static	int quality = 75;	/* JPEG quality */
+static	int jpegcolormode = JPEGCOLORMODE_RGB;
+static	int processCompressOptions(char*);
+
+int
+main(int argc, char* argv[])
+{
+	uint16 bitspersample, shortv;
+	uint32 imagewidth, imagelength;
+	uint16 config = PLANARCONFIG_CONTIG;
+	uint32 rowsperstrip = (uint32) -1;
+	uint16 photometric = PHOTOMETRIC_RGB;
+	uint16 *rmap, *gmap, *bmap;
+	uint32 row;
+	int cmap = -1;
+	TIFF *in, *out;
+	int c;
+	extern int optind;
+	extern char* optarg;
+
+	while ((c = getopt(argc, argv, "C:c:p:r:")) != -1)
+		switch (c) {
+		case 'C':		/* force colormap interpretation */
+			cmap = atoi(optarg);
+			break;
+		case 'c':		/* compression scheme */
+			if (!processCompressOptions(optarg))
+				usage();
+			break;
+		case 'p':		/* planar configuration */
+			if (streq(optarg, "separate"))
+				config = PLANARCONFIG_SEPARATE;
+			else if (streq(optarg, "contig"))
+				config = PLANARCONFIG_CONTIG;
+			else
+				usage();
+			break;
+		case 'r':		/* rows/strip */
+			rowsperstrip = atoi(optarg);
+			break;
+		case '?':
+			usage();
+			/*NOTREACHED*/
+		}
+	if (argc - optind != 2)
+		usage();
+	in = TIFFOpen(argv[optind], "r");
+	if (in == NULL)
+		return (-1);
+	if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &shortv) ||
+	    shortv != PHOTOMETRIC_PALETTE) {
+		fprintf(stderr, "%s: Expecting a palette image.\n",
+		    argv[optind]);
+		return (-1);
+	}
+	if (!TIFFGetField(in, TIFFTAG_COLORMAP, &rmap, &gmap, &bmap)) {
+		fprintf(stderr,
+		    "%s: No colormap (not a valid palette image).\n",
+		    argv[optind]);
+		return (-1);
+	}
+	bitspersample = 0;
+	TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
+	if (bitspersample != 8) {
+		fprintf(stderr, "%s: Sorry, can only handle 8-bit images.\n",
+		    argv[optind]);
+		return (-1);
+	}
+	out = TIFFOpen(argv[optind+1], "w");
+	if (out == NULL)
+		return (-2);
+	cpTags(in, out);
+	TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &imagewidth);
+	TIFFGetField(in, TIFFTAG_IMAGELENGTH, &imagelength);
+	if (compression != (uint16)-1)
+		TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
+	else
+		TIFFGetField(in, TIFFTAG_COMPRESSION, &compression);
+	switch (compression) {
+	case COMPRESSION_JPEG:
+		if (jpegcolormode == JPEGCOLORMODE_RGB)
+			photometric = PHOTOMETRIC_YCBCR;
+		else
+			photometric = PHOTOMETRIC_RGB;
+		TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
+		TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
+		break;
+	case COMPRESSION_LZW:
+	case COMPRESSION_DEFLATE:
+		if (predictor != 0)
+			TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
+		break;
+	}
+	TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
+	TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3);
+	TIFFSetField(out, TIFFTAG_PLANARCONFIG, config);
+	TIFFSetField(out, TIFFTAG_ROWSPERSTRIP,
+	    rowsperstrip = TIFFDefaultStripSize(out, rowsperstrip));
+	(void) TIFFGetField(in, TIFFTAG_PLANARCONFIG, &shortv);
+	if (cmap == -1)
+		cmap = checkcmap(1<<bitspersample, rmap, gmap, bmap);
+	if (cmap == 16) {
+		/*
+		 * Convert 16-bit colormap to 8-bit.
+		 */
+		int i;
+
+		for (i = (1<<bitspersample)-1; i >= 0; i--) {
+#define	CVT(x)		(((x) * 255) / ((1L<<16)-1))
+			rmap[i] = CVT(rmap[i]);
+			gmap[i] = CVT(gmap[i]);
+			bmap[i] = CVT(bmap[i]);
+		}
+	}
+	{ unsigned char *ibuf, *obuf;
+	  register unsigned char* pp;
+	  register uint32 x;
+	  ibuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(in));
+	  obuf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(out));
+	  switch (config) {
+	  case PLANARCONFIG_CONTIG:
+		for (row = 0; row < imagelength; row++) {
+			if (!TIFFReadScanline(in, ibuf, row, 0))
+				goto done;
+			pp = obuf;
+			for (x = 0; x < imagewidth; x++) {
+				*pp++ = (unsigned char) rmap[ibuf[x]];
+				*pp++ = (unsigned char) gmap[ibuf[x]];
+				*pp++ = (unsigned char) bmap[ibuf[x]];
+			}
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+		}
+		break;
+	  case PLANARCONFIG_SEPARATE:
+		for (row = 0; row < imagelength; row++) {
+			if (!TIFFReadScanline(in, ibuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) rmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) gmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+			for (pp = obuf, x = 0; x < imagewidth; x++)
+				*pp++ = (unsigned char) bmap[ibuf[x]];
+			if (!TIFFWriteScanline(out, obuf, row, 0))
+				goto done;
+		}
+		break;
+	  }
+	  _TIFFfree(ibuf);
+	  _TIFFfree(obuf);
+	}
+done:
+	(void) TIFFClose(in);
+	(void) TIFFClose(out);
+	return (0);
+}
+
+static int
+processCompressOptions(char* opt)
+{
+	if (streq(opt, "none"))
+		compression = COMPRESSION_NONE;
+	else if (streq(opt, "packbits"))
+		compression = COMPRESSION_PACKBITS;
+	else if (strneq(opt, "jpeg", 4)) {
+		char* cp = strchr(opt, ':');
+
+                compression = COMPRESSION_JPEG;
+                while( cp )
+                {
+                    if (isdigit((int)cp[1]))
+			quality = atoi(cp+1);
+                    else if (cp[1] == 'r' )
+			jpegcolormode = JPEGCOLORMODE_RAW;
+                    else
+                        usage();
+
+                    cp = strchr(cp+1,':');
+                }
+	} else if (strneq(opt, "lzw", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_LZW;
+	} else if (strneq(opt, "zip", 3)) {
+		char* cp = strchr(opt, ':');
+		if (cp)
+			predictor = atoi(cp+1);
+		compression = COMPRESSION_DEFLATE;
+	} else
+		return (0);
+	return (1);
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField2(tag, v1, v2) \
+    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+#define	CopyField4(tag, v1, v2, v3, v4) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
+
+static void
+cpTag(TIFF* in, TIFF* out, uint16 
+
+// ... (4633 more chars)
+```
+
+### File: tools/thumbnail.c
+```c
+/* $Id$ */
+
+/*
+ * Copyright (c) 1994-1997 Sam Leffler
+ * Copyright (c) 1994-1997 Silicon Graphics, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and 
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that (i) the above copyright notices and this permission notice appear in
+ * all copies of the software and related documentation, and (ii) the names of
+ * Sam Leffler and Silicon Graphics may not be used in any advertising or
+ * publicity relating to the software without the specific, prior written
+ * permission of Sam Leffler and Silicon Graphics.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ * 
+ * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
+ * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
+ * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
+ * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
+ * OF THIS SOFTWARE.
+ */
+
+#include "tif_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef NEED_LIBPORT
+# include "libport.h"
+#endif
+
+#include "tiffio.h"
+
+#ifndef HAVE_GETOPT
+extern int getopt(int, char**, char*);
+#endif
+
+#define	streq(a,b)	(strcmp(a,b) == 0)
+
+#ifndef TIFFhowmany8
+# define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
+#endif
+
+typedef enum {
+    EXP50,
+    EXP60,
+    EXP70,
+    EXP80,
+    EXP90,
+    EXP,
+    LINEAR
+} Contrast;
+
+static	uint32 tnw = 216;		/* thumbnail width */
+static	uint32 tnh = 274;		/* thumbnail height */
+static	Contrast contrast = LINEAR;	/* current contrast */
+static	uint8* thumbnail;
+
+static	int cpIFD(TIFF*, TIFF*);
+static	int generateThumbnail(TIFF*, TIFF*);
+static	void initScale();
+static	void usage(void);
+
+extern	char* optarg;
+extern	int optind;
+
+int
+main(int argc, char* argv[])
+{
+    TIFF* in;
+    TIFF* out;
+    int c;
+
+    while ((c = getopt(argc, argv, "w:h:c:")) != -1) {
+	switch (c) {
+	case 'w':	tnw = strtoul(optarg, NULL, 0); break;
+	case 'h':	tnh = strtoul(optarg, NULL, 0); break;
+	case 'c':	contrast = streq(optarg, "exp50") ? EXP50 :
+				   streq(optarg, "exp60") ? EXP60 :
+				   streq(optarg, "exp70") ? EXP70 :
+				   streq(optarg, "exp80") ? EXP80 :
+				   streq(optarg, "exp90") ? EXP90 :
+				   streq(optarg, "exp")   ? EXP :
+				   streq(optarg, "linear")? LINEAR :
+							    EXP;
+			break;
+	default:	usage();
+	}
+    }
+    if (argc-optind != 2)
+	usage();
+
+    out = TIFFOpen(argv[optind+1], "w");
+    if (out == NULL)
+	return 2;
+    in = TIFFOpen(argv[optind], "r");
+    if( in == NULL )
+        return 2;
+
+    thumbnail = (uint8*) _TIFFmalloc(tnw * tnh);
+    if (!thumbnail) {
+	    TIFFError(TIFFFileName(in),
+		      "Can't allocate space for thumbnail buffer.");
+	    return 1;
+    }
+
+    if (in != NULL) {
+	initScale();
+	do {
+	    if (!generateThumbnail(in, out))
+		goto bad;
+	    if (!cpIFD(in, out) || !TIFFWriteDirectory(out))
+		goto bad;
+	} while (TIFFReadDirectory(in));
+	(void) TIFFClose(in);
+    }
+    (void) TIFFClose(out);
+    return 0;
+bad:
+    (void) TIFFClose(out);
+    return 1;
+}
+
+#define	CopyField(tag, v) \
+    if (TIFFGetField(in, tag, &v)) TIFFSetField(out, tag, v)
+#define	CopyField2(tag, v1, v2) \
+    if (TIFFGetField(in, tag, &v1, &v2)) TIFFSetField(out, tag, v1, v2)
+#define	CopyField3(tag, v1, v2, v3) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3)) TIFFSetField(out, tag, v1, v2, v3)
+#define	CopyField4(tag, v1, v2, v3, v4) \
+    if (TIFFGetField(in, tag, &v1, &v2, &v3, &v4)) TIFFSetField(out, tag, v1, v2, v3, v4)
+
+static void
+cpTag(TIFF* in, TIFF* out, uint16 tag, uint16 count, TIFFDataType type)
+{
+	switch (type) {
+	case TIFF_SHORT:
+		if (count == 1) {
+			uint16 shortv;
+			CopyField(tag, shortv);
+		} else if (count == 2) {
+			uint16 shortv1, shortv2;
+			CopyField2(tag, shortv1, shortv2);
+		} else if (count == 4) {
+			uint16 *tr, *tg, *tb, *ta;
+			CopyField4(tag, tr, tg, tb, ta);
+		} else if (count == (uint16) -1) {
+			uint16 shortv1;
+			uint16* shortav;
+			CopyField2(tag, shortv1, shortav);
+		}
+		break;
+	case TIFF_LONG:
+		{ uint32 longv;
+		  CopyField(tag, longv);
+		}
+		break;
+	case TIFF_LONG8:
+		{ uint64 longv8;
+		  CopyField(tag, longv8);
+		}
+		break;
+	case TIFF_SLONG8:
+		{ int64 longv8;
+		  CopyField(tag, longv8);
+		}
+		break;
+	case TIFF_RATIONAL:
+		if (count == 1) {
+			float floatv;
+			CopyField(tag, floatv);
+		} else if (count == (uint16) -1) {
+			float* floatav;
+			CopyField(tag, floatav);
+		}
+		break;
+	case TIFF_ASCII:
+		{ char* stringv;
+		  CopyField(tag, stringv);
+		}
+		break;
+	case TIFF_DOUBLE:
+		if (count == 1) {
+			double doublev;
+			CopyField(tag, doublev);
+		} else if (count == (uint16) -1) {
+			double* doubleav;
+			CopyField(tag, doubleav);
+		}
+		break;
+	case TIFF_IFD8:
+		{ toff_t ifd8;
+		  CopyField(tag, ifd8);
+		}
+		break;          default:
+                TIFFError(TIFFFileName(in),
+                          "Data type %d is not supported, tag %d skipped.",
+                          tag, type);
+	}
+}
+
+#undef CopyField4
+#undef CopyField3
+#undef CopyField2
+#undef CopyField
+
+static struct cpTag {
+    uint16	tag;
+    uint16	count;
+    TIFFDataType type;
+} tags[] = {
+    { TIFFTAG_IMAGEWIDTH,		1, TIFF_LONG },
+    { TIFFTAG_IMAGELENGTH,		1, TIFF_LONG },
+    { TIFFTAG_BITSPERSAMPLE,		1, TIFF_SHORT },
+    { TIFFTAG_COMPRESSION,		1, TIFF_SHORT },
+    { TIFFTAG_FILLORDER,		1, TIFF_SHORT },
+    { TIFFTAG_SAMPLESPERPIXEL,		1, TIFF_SHORT },
+    { TIFFTAG_ROWSPERSTRIP,		1, TIFF_LONG },
+    { TIFFTAG_PLANARCONFIG,		1, TIFF_SHORT },
+    { TIFFTAG_GROUP3OPTIONS,		1, TIFF_LONG },
+    { TIFFTAG_SUBFILETYPE,		1, TIFF_LONG },
+    { TIFFTAG_PHOTOMETRIC,		1, TIFF_SHORT },
+    { TIFFTAG_THRESHHOLDING,		1, TIFF_SHORT },
+    { TIFFTAG_DOCUMENTNAME,		1, TIFF_ASCII },
+    { TIFFTAG_IMAGEDESCRIPTION,		1, TIFF_ASCII },
+    { TIFFTAG_MAKE,			1, TIFF_ASCII },
+    { TIFFTAG_MODEL,			1, TIFF_ASCII },
+    { TIFFTAG_ORIENTATION,		1, TIFF_SHORT },
+    { TIFFTAG_MINSAMPLEVALUE,		1, TIFF_SHORT },
+    { TIFFTAG_MAXSAMPLEVALUE,		1, TIFF_SHORT },
+    { TIFFTAG_XRESOLUTION,		1, TIFF_RATIONAL },
+    { TIFFTAG_YRESOLUTION,		1, TIFF_RATIONAL },
+    { TIFFTAG_PAGENAME,			1, TIFF_ASCII },
+    { TIFFTAG_XPOSITION,		1, TIFF_RATIONAL },
+    { TIFFTAG_YPOSITION,		1, TIFF_RATIONAL },
+    { TIFFTAG_GROUP4OPTIONS,		1, TIFF_LONG },
+    { TIFFTAG_RESOLUTIONUNIT,		1, TIFF_SHORT },
+    { TIFFTAG_PAGENUMBER,		2, TIFF_SHORT },
+    { TIFFTAG_SOFTWARE,			1, TIFF_ASCII },
+    { TIFFTAG_DATETIME,			1, TIFF_ASCII },
+    { TIFFTAG_ARTIST,			1, TIFF_ASCII },
+    { TIFFTAG_HOSTCOMPUTER,		1, TIFF_ASCII },
+    { TIFFTAG_WHITEPOINT,		2, TIFF_RATIONAL },
+    { TIFFTAG_PRIMARYCHROMATICITIES,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_HALFTONEHINTS,		2, TIFF_SHORT },
+    { TIFFTAG_BADFAXLINES,		1, TIFF_LONG },
+    { TIFFTAG_CLEANFAXDATA,		1, TIFF_SHORT },
+    { TIFFTAG_CONSECUTIVEBADFAXLINES,	1, TIFF_LONG },
+    { TIFFTAG_INKSET,			1, TIFF_SHORT },
+    { TIFFTAG_INKNAMES,			1, TIFF_ASCII },
+    { TIFFTAG_DOTRANGE,			2, TIFF_SHORT },
+    { TIFFTAG_TARGETPRINTER,		1, TIFF_ASCII },
+    { TIFFTAG_SAMPLEFORMAT,		1, TIFF_SHORT },
+    { TIFFTAG_YCBCRCOEFFICIENTS,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_YCBCRSUBSAMPLING,		2, TIFF_SHORT },
+    { TIFFTAG_YCBCRPOSITIONING,		1, TIFF_SHORT },
+    { TIFFTAG_REFERENCEBLACKWHITE,	(uint16) -1,TIFF_RATIONAL },
+    { TIFFTAG_EXTRASAMPLES,		(uint16) -1, TIFF_SHORT },
+};
+#define	NTAGS	(sizeof (tags) / sizeof (tags[0]))
+
+static void
+cpTags(TIFF* in, TIFF* out)
+{
+    struct cpTag *p;
+    for (p = tags; p < &tags[NTAGS]; p++)
+	{
+		/* Horrible: but TIFFGetField() expects 2 arguments to be passed */
+		/* if we request a tag that is defined in a codec, but that codec */
+		/* isn't used */
+		if( p->tag == TIFFTAG_GROUP3OPTIONS )
+		{
+
+
+// ... (10401 more chars)
+```

tasks/csa159/pair_136342/task_prompt.md

@@ -0,0 +1,318 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```

tasks/csa159/pair_136864/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_136864/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "ImageMagick_ImageMagick6",
+  "before_commit": "b466a96965afc1308a4ace93f5535c2b770f294b",
+  "after_commit": "7486477aa00c5c7856b111506da075b6cdfa8b73",
+  "repo_path": "/workspace/repo/ImageMagick/ImageMagick6",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/ImageMagick_ImageMagick6/b7c9c8972ef11481d92b1f57172fe72c54b0c4a2/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/ImageMagick_ImageMagick6/b7c9c8972ef11481d92b1f57172fe72c54b0c4a2/compile_commands.json",
+  "changed_files": [
+    "coders/tiff.c"
+  ],
+  "commit_message": "https://github.com/ImageMagick/ImageMagick/issues/1857",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_136864/patch.diff

@@ -0,0 +1,23 @@
+diff --git a/coders/tiff.c b/coders/tiff.c
+index 0256a6c1e..15c993364 100644
+--- a/coders/tiff.c
++++ b/coders/tiff.c
+@@ -1701,7 +1701,8 @@ RestoreMSCWarning
+       }
+     if (TIFFIsTiled(tiff) != MagickFalse)
+       method=ReadTileMethod;
+-    if (photometric == PHOTOMETRIC_LOGLUV)
++    if ((photometric == PHOTOMETRIC_LOGLUV) ||
++        (photometric == PHOTOMETRIC_YCBCR))
+       method=ReadGenericMethod;
+     if (image->compression == JPEGCompression)
+       method=GetJPEGMethod(image,tiff,photometric,bits_per_sample,
+@@ -1834,8 +1835,6 @@ RestoreMSCWarning
+           Convert stripped TIFF image.
+         */
+         extent=TIFFStripSize(tiff)+sizeof(uint32);
+-        if (photometric == PHOTOMETRIC_YCBCR)
+-          extent<<=1;
+         strip_pixels=(unsigned char *) AcquireQuantumMemory(extent,
+           sizeof(*strip_pixels));
+         if (strip_pixels == (unsigned char *) NULL)

tasks/csa159/pair_136864/post_functions.txt

@@ -0,0 +1,282 @@
+### File: coders/tiff.c
+```c
+static Image *ReadTIFFImage(const ImageInfo *image_info,
+  ExceptionInfo *exception)
+{
+#define ThrowTIFFException(severity,message) \
+{ \
+  if (pixel_info != (MemoryInfo *) NULL) \
+    pixel_info=RelinquishVirtualMemory(pixel_info); \
+  if (quantum_info != (QuantumInfo *) NULL) \
+    quantum_info=DestroyQuantumInfo(quantum_info); \
+  TIFFClose(tiff); \
+  ThrowReaderException(severity,message); \
+}
+
+  const char
+    *option;
+
+  float
+    *chromaticity,
+    x_position,
+    y_position,
+    x_resolution,
+    y_resolution;
+
+  Image
+    *image;
+
+  int
+    tiff_status;
+
+  MagickBooleanType
+    more_frames,
+    status;
+
+  MemoryInfo
+    *pixel_info = (MemoryInfo *) NULL;
+
+  QuantumInfo
+    *quantum_info;
+
+  QuantumType
+    quantum_type;
+
+  register ssize_t
+    i;
+
+  size_t
+    number_pixels,
+    pad;
+
+  ssize_t
+    y;
+
+  TIFF
+    *tiff;
+
+  TIFFMethodType
+    method;
+
+  uint16
+    compress_tag,
+    bits_per_sample,
+    endian,
+    extra_samples,
+    interlace,
+    max_sample_value,
+    min_sample_value,
+    orientation,
+    pages,
+    photometric,
+    *sample_info,
+    sample_format,
+    samples_per_pixel,
+    units,
+    value;
+
+  uint32
+    height,
+    rows_per_strip,
+    width;
+
+  unsigned char
+    *pixels;
+
+  void
+    *sans[2] = { NULL, NULL };
+
+  /*
+    Open image.
+  */
+  assert(image_info != (const ImageInfo *) NULL);
+  assert(image_info->signature == MagickCoreSignature);
+  if (image_info->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
+      image_info->filename);
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickCoreSignature);
+  image=AcquireImage(image_info);
+  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
+  if (status == MagickFalse)
+    {
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  (void) SetMagickThreadValue(tiff_exception,exception);
+  tiff=TIFFClientOpen(image->filename,"rb",(thandle_t) image,TIFFReadBlob,
+    TIFFWriteBlob,TIFFSeekBlob,TIFFCloseBlob,TIFFGetBlobSize,TIFFMapBlob,
+    TIFFUnmapBlob);
+  if (tiff == (TIFF *) NULL)
+    {
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  if (exception->severity > ErrorException)
+    {
+      TIFFClose(tiff);
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  if (image_info->number_scenes != 0)
+    {
+      /*
+        Generate blank images for subimage specification (e.g. image.tif[4].
+        We need to check the number of directores because it is possible that
+        the subimage(s) are stored in the photoshop profile.
+      */
+      if (image_info->scene < (size_t)TIFFNumberOfDirectories(tiff))
+        {
+          for (i=0; i < (ssize_t) image_info->scene; i++)
+          {
+            status=TIFFReadDirectory(tiff) != 0 ? MagickTrue : MagickFalse;
+            if (status == MagickFalse)
+              {
+                TIFFClose(tiff);
+                image=DestroyImageList(image);
+                return((Image *) NULL);
+              }
+            AcquireNextImage(image_info,image);
+            if (GetNextImageInList(image) == (Image *) NULL)
+              {
+                TIFFClose(tiff);
+                image=DestroyImageList(image);
+                return((Image *) NULL);
+              }
+            image=SyncNextImageInList(image);
+          }
+        }
+    }
+  more_frames=MagickTrue;
+  do
+  {
+DisableMSCWarning(4127)
+    if (0 && (image_info->verbose != MagickFalse))
+      TIFFPrintDirectory(tiff,stdout,MagickFalse);
+RestoreMSCWarning
+    photometric=PHOTOMETRIC_RGB;
+    if ((TIFFGetField(tiff,TIFFTAG_IMAGEWIDTH,&width) != 1) ||
+        (TIFFGetField(tiff,TIFFTAG_IMAGELENGTH,&height) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_PHOTOMETRIC,&photometric,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_COMPRESSION,&compress_tag,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_FILLORDER,&endian,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_PLANARCONFIG,&interlace,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLESPERPIXEL,&samples_per_pixel,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,&bits_per_sample,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLEFORMAT,&sample_format,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_MINSAMPLEVALUE,&min_sample_value,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_MAXSAMPLEVALUE,&max_sample_value,sans) != 1))
+      {
+        TIFFClose(tiff);
+        ThrowReaderException(CorruptImageError,"ImproperImageHeader");
+      }
+    if (((sample_format != SAMPLEFORMAT_IEEEFP) || (bits_per_sample != 64)) &&
+        ((bits_per_sample <= 0) || (bits_per_sample > 32)))
+      {
+        TIFFClose(tiff);
+        ThrowReaderException(CorruptImageError,"UnsupportedBitsPerPixel");
+      }
+    if (sample_format == SAMPLEFORMAT_IEEEFP)
+      (void) SetImageProperty(image,"quantum:format","floating-point");
+    switch (photometric)
+    {
+      case PHOTOMETRIC_MINISBLACK:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","min-is-black");
+        break;
+      }
+      case PHOTOMETRIC_MINISWHITE:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","min-is-white");
+        break;
+      }
+      case PHOTOMETRIC_PALETTE:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","palette");
+        break;
+      }
+      case PHOTOMETRIC_RGB:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","RGB");
+        break;
+      }
+      case PHOTOMETRIC_CIELAB:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","CIELAB");
+        break;
+      }
+      case PHOTOMETRIC_LOGL:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","CIE Log2(L)");
+        break;
+      }
+      case PHOTOMETRIC_LOGLUV:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","LOGLUV");
+        break;
+      }
+#if defined(PHOTOMETRIC_MASK)
+      case PHOTOMETRIC_MASK:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","MASK");
+        break;
+      }
+#endif
+      case PHOTOMETRIC_SEPARATED:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","separated");
+        break;
+      }
+      case PHOTOMETRIC_YCBCR:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","YCBCR");
+        break;
+      }
+      default:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","unknown");
+        break;
+      }
+    }
+    if (image->debug != MagickFalse)
+      {
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Geometry: %ux%u",
+          (unsigned int) width,(unsigned int) height);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Interlace: %u",
+          interlace);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Bits per sample: %u",bits_per_sample);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Min sample value: %u",min_sample_value);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Max sample value: %u",max_sample_value);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Photometric "
+          "interpretation: %s",GetImageProperty(image,"tiff:photometric"));
+      }
+    image->columns=(size_t) width;
+    image->rows=(size_t) height;
+    image->depth=(size_t) bits_per_sample;
+    if (image->debug != MagickFalse)
+      (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Image depth: %.20g",
+        (double) image->depth);
+    image->endian=MSBEndian;
+    if (endian == FILLORDER_LSB2MSB)
+      image->endian=LSBEndian;
+#if defined(MAGICKCORE_HAVE_TIFFISBIGENDIAN)
+    if (TIFFIsBigEndian(tiff) == 0)
+      {
+        (void) SetImageProperty(image,"tiff:endian","lsb");
+        image->endian=LSBEndian;
+      }
+    else
+      {
+        (void) SetImageProperty(image,"tiff:endian","msb");
+        image->endian=MSBEndian;
+      }
+#endif
+    if ((photometric == PHOTOMETRIC_MINISBLACK) ||
+        (photometric == PHOTOMETRIC_MINISWHITE))
+     
+
+// ... (24492 more chars)
+```

tasks/csa159/pair_136864/pre_functions.txt

@@ -0,0 +1,282 @@
+### File: coders/tiff.c
+```c
+static Image *ReadTIFFImage(const ImageInfo *image_info,
+  ExceptionInfo *exception)
+{
+#define ThrowTIFFException(severity,message) \
+{ \
+  if (pixel_info != (MemoryInfo *) NULL) \
+    pixel_info=RelinquishVirtualMemory(pixel_info); \
+  if (quantum_info != (QuantumInfo *) NULL) \
+    quantum_info=DestroyQuantumInfo(quantum_info); \
+  TIFFClose(tiff); \
+  ThrowReaderException(severity,message); \
+}
+
+  const char
+    *option;
+
+  float
+    *chromaticity,
+    x_position,
+    y_position,
+    x_resolution,
+    y_resolution;
+
+  Image
+    *image;
+
+  int
+    tiff_status;
+
+  MagickBooleanType
+    more_frames,
+    status;
+
+  MemoryInfo
+    *pixel_info = (MemoryInfo *) NULL;
+
+  QuantumInfo
+    *quantum_info;
+
+  QuantumType
+    quantum_type;
+
+  register ssize_t
+    i;
+
+  size_t
+    number_pixels,
+    pad;
+
+  ssize_t
+    y;
+
+  TIFF
+    *tiff;
+
+  TIFFMethodType
+    method;
+
+  uint16
+    compress_tag,
+    bits_per_sample,
+    endian,
+    extra_samples,
+    interlace,
+    max_sample_value,
+    min_sample_value,
+    orientation,
+    pages,
+    photometric,
+    *sample_info,
+    sample_format,
+    samples_per_pixel,
+    units,
+    value;
+
+  uint32
+    height,
+    rows_per_strip,
+    width;
+
+  unsigned char
+    *pixels;
+
+  void
+    *sans[2] = { NULL, NULL };
+
+  /*
+    Open image.
+  */
+  assert(image_info != (const ImageInfo *) NULL);
+  assert(image_info->signature == MagickCoreSignature);
+  if (image_info->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
+      image_info->filename);
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickCoreSignature);
+  image=AcquireImage(image_info);
+  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
+  if (status == MagickFalse)
+    {
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  (void) SetMagickThreadValue(tiff_exception,exception);
+  tiff=TIFFClientOpen(image->filename,"rb",(thandle_t) image,TIFFReadBlob,
+    TIFFWriteBlob,TIFFSeekBlob,TIFFCloseBlob,TIFFGetBlobSize,TIFFMapBlob,
+    TIFFUnmapBlob);
+  if (tiff == (TIFF *) NULL)
+    {
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  if (exception->severity > ErrorException)
+    {
+      TIFFClose(tiff);
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  if (image_info->number_scenes != 0)
+    {
+      /*
+        Generate blank images for subimage specification (e.g. image.tif[4].
+        We need to check the number of directores because it is possible that
+        the subimage(s) are stored in the photoshop profile.
+      */
+      if (image_info->scene < (size_t)TIFFNumberOfDirectories(tiff))
+        {
+          for (i=0; i < (ssize_t) image_info->scene; i++)
+          {
+            status=TIFFReadDirectory(tiff) != 0 ? MagickTrue : MagickFalse;
+            if (status == MagickFalse)
+              {
+                TIFFClose(tiff);
+                image=DestroyImageList(image);
+                return((Image *) NULL);
+              }
+            AcquireNextImage(image_info,image);
+            if (GetNextImageInList(image) == (Image *) NULL)
+              {
+                TIFFClose(tiff);
+                image=DestroyImageList(image);
+                return((Image *) NULL);
+              }
+            image=SyncNextImageInList(image);
+          }
+        }
+    }
+  more_frames=MagickTrue;
+  do
+  {
+DisableMSCWarning(4127)
+    if (0 && (image_info->verbose != MagickFalse))
+      TIFFPrintDirectory(tiff,stdout,MagickFalse);
+RestoreMSCWarning
+    photometric=PHOTOMETRIC_RGB;
+    if ((TIFFGetField(tiff,TIFFTAG_IMAGEWIDTH,&width) != 1) ||
+        (TIFFGetField(tiff,TIFFTAG_IMAGELENGTH,&height) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_PHOTOMETRIC,&photometric,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_COMPRESSION,&compress_tag,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_FILLORDER,&endian,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_PLANARCONFIG,&interlace,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLESPERPIXEL,&samples_per_pixel,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,&bits_per_sample,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLEFORMAT,&sample_format,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_MINSAMPLEVALUE,&min_sample_value,sans) != 1) ||
+        (TIFFGetFieldDefaulted(tiff,TIFFTAG_MAXSAMPLEVALUE,&max_sample_value,sans) != 1))
+      {
+        TIFFClose(tiff);
+        ThrowReaderException(CorruptImageError,"ImproperImageHeader");
+      }
+    if (((sample_format != SAMPLEFORMAT_IEEEFP) || (bits_per_sample != 64)) &&
+        ((bits_per_sample <= 0) || (bits_per_sample > 32)))
+      {
+        TIFFClose(tiff);
+        ThrowReaderException(CorruptImageError,"UnsupportedBitsPerPixel");
+      }
+    if (sample_format == SAMPLEFORMAT_IEEEFP)
+      (void) SetImageProperty(image,"quantum:format","floating-point");
+    switch (photometric)
+    {
+      case PHOTOMETRIC_MINISBLACK:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","min-is-black");
+        break;
+      }
+      case PHOTOMETRIC_MINISWHITE:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","min-is-white");
+        break;
+      }
+      case PHOTOMETRIC_PALETTE:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","palette");
+        break;
+      }
+      case PHOTOMETRIC_RGB:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","RGB");
+        break;
+      }
+      case PHOTOMETRIC_CIELAB:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","CIELAB");
+        break;
+      }
+      case PHOTOMETRIC_LOGL:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","CIE Log2(L)");
+        break;
+      }
+      case PHOTOMETRIC_LOGLUV:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","LOGLUV");
+        break;
+      }
+#if defined(PHOTOMETRIC_MASK)
+      case PHOTOMETRIC_MASK:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","MASK");
+        break;
+      }
+#endif
+      case PHOTOMETRIC_SEPARATED:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","separated");
+        break;
+      }
+      case PHOTOMETRIC_YCBCR:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","YCBCR");
+        break;
+      }
+      default:
+      {
+        (void) SetImageProperty(image,"tiff:photometric","unknown");
+        break;
+      }
+    }
+    if (image->debug != MagickFalse)
+      {
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Geometry: %ux%u",
+          (unsigned int) width,(unsigned int) height);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Interlace: %u",
+          interlace);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Bits per sample: %u",bits_per_sample);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Min sample value: %u",min_sample_value);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+          "Max sample value: %u",max_sample_value);
+        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Photometric "
+          "interpretation: %s",GetImageProperty(image,"tiff:photometric"));
+      }
+    image->columns=(size_t) width;
+    image->rows=(size_t) height;
+    image->depth=(size_t) bits_per_sample;
+    if (image->debug != MagickFalse)
+      (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Image depth: %.20g",
+        (double) image->depth);
+    image->endian=MSBEndian;
+    if (endian == FILLORDER_LSB2MSB)
+      image->endian=LSBEndian;
+#if defined(MAGICKCORE_HAVE_TIFFISBIGENDIAN)
+    if (TIFFIsBigEndian(tiff) == 0)
+      {
+        (void) SetImageProperty(image,"tiff:endian","lsb");
+        image->endian=LSBEndian;
+      }
+    else
+      {
+        (void) SetImageProperty(image,"tiff:endian","msb");
+        image->endian=MSBEndian;
+      }
+#endif
+    if ((photometric == PHOTOMETRIC_MINISBLACK) ||
+        (photometric == PHOTOMETRIC_MINISWHITE))
+     
+
+// ... (24512 more chars)
+```