Add files using upload-large-folder tool

benchmark/IOL/ioling_hf/reports/answer_given_rationale/Qwen_Qwen3-4B-Instruct-2507__v11_answer_target_act_uninformed_n4.md

@@ -0,0 +1,246 @@
+# Answer-Given Rationale Probe
+
+- generated: `2026-07-11T23:36:51.389454+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- data: `data/rl/ioling_qwen3_4b_manual_v11_clean_prompt`
+- samples: `96` across `24` records
+- exact final-box samples: `0.938`
+- valid final-box samples: `0.948`
+- truncation rate: `0.000`
+- mean rationale chars: `1256.9`
+
+## Per Record
+
+| record | samples | exact boxes | valid boxes | best score | mean rationale chars |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| iol-2015-individual-p1-sub-b-atomic-b.1 | 4 | 4 | 4 | 1.000 | 1114.8 |
+| iol-2015-individual-p1-sub-b-atomic-b.2 | 4 | 4 | 4 | 1.000 | 1104.2 |
+| iol-2015-individual-p1-sub-c-atomic-c.1 | 4 | 4 | 4 | 1.000 | 868.0 |
+| iol-2015-individual-p1-sub-c-atomic-c.2 | 4 | 4 | 4 | 1.000 | 927.5 |
+| iol-2016-individual-p3-sub-a-atomic-a.1 | 4 | 4 | 4 | 1.000 | 881.0 |
+| iol-2016-individual-p3-sub-a-atomic-a.2 | 4 | 4 | 4 | 1.000 | 1331.5 |
+| iol-2016-individual-p3-sub-a-atomic-a.3 | 4 | 4 | 4 | 1.000 | 3546.2 |
+| iol-2016-individual-p3-sub-a-atomic-a.4 | 4 | 4 | 4 | 1.000 | 1148.8 |
+| iol-2016-individual-p3-sub-a-atomic-a.5 | 4 | 4 | 4 | 1.000 | 1148.0 |
+| iol-2016-individual-p3-sub-b-atomic-b.1 | 4 | 2 | 3 | 1.000 | 1061.2 |
+| iol-2016-individual-p3-sub-b-atomic-b.2 | 4 | 3 | 3 | 1.000 | 1311.0 |
+| iol-2016-individual-p3-sub-b-atomic-b.3 | 4 | 4 | 4 | 1.000 | 1133.2 |
+| iol-2016-individual-p3-sub-b-atomic-b.4 | 4 | 4 | 4 | 1.000 | 1240.0 |
+| iol-2016-individual-p3-sub-b-atomic-b.5 | 4 | 4 | 4 | 1.000 | 1246.5 |
+| iol-2021-individual-p3-sub-a-atomic-a.1 | 4 | 4 | 4 | 1.000 | 1159.2 |
+| iol-2021-individual-p3-sub-a-atomic-a.2 | 4 | 4 | 4 | 1.000 | 1126.5 |
+| iol-2021-individual-p3-sub-a-atomic-a.3 | 4 | 4 | 4 | 1.000 | 1142.2 |
+| iol-2021-individual-p3-sub-a-atomic-a.4 | 4 | 4 | 4 | 1.000 | 1290.0 |
+| iol-2021-individual-p3-sub-a-atomic-a.5 | 4 | 4 | 4 | 1.000 | 1334.0 |
+| iol-2021-individual-p3-sub-b-atomic-b.1 | 4 | 3 | 3 | 1.000 | 1173.5 |
+| iol-2021-individual-p3-sub-b-atomic-b.2 | 4 | 2 | 2 | 1.000 | 1120.0 |
+| iol-2021-individual-p3-sub-b-atomic-b.3 | 4 | 4 | 4 | 1.000 | 1100.2 |
+| iol-2021-individual-p3-sub-b-atomic-b.4 | 4 | 4 | 4 | 1.000 | 1398.8 |
+| iol-2021-individual-p3-sub-b-atomic-b.5 | 4 | 4 | 4 | 1.000 | 1259.2 |
+
+## Sample Outputs
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating multiplication of mahtlactli yields a structure with pöhualli and mahtlactli components.  
+- Equation (4) confirms mäcuïlli + öme = chicöme, establishing that mäcuïlli and öme combine to form chicöme, suggesting additive decomposition of chicöme.  
+- Equation (3) demonstrates yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, showing that the addition of pöhualli and chicöme structures leads to pöhualli-on-cë with a nested structure.  
+- Equation (2) reveals cem-pöhualli × öme = öm-pöhualli, indicating that cem-pöhualli multiplied by öme results in öm-pöhualli, supporting a morpheme shift from cem to öm under multiplication.  
+- Equation (5) shows mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, implying multiplication of a base with ëyi produces components with cem-pöhualli, caxtölli, and nähui.  
+- Equation (6) confirms mäcuïlli × ëyi = caxtölli, indicating that mäcuïlli times ëyi directly yields caxtölli, reinforcing the multiplicative rule involving mäcuïlli and ëyi.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating multiplication produces a compound with pöhualli and om, suggesting pöhualli relates to 20.  
+- Equation (2) gives cem-pöhualli × öme = öm-pöhualli, implying cem-pöhualli × öme = öm-pöhualli shows öme acts as a unit multiplier, consistent with öme = 1.  
+- Equation (4) states mäcuïlli + öme = chicöme, and (1) shows mahtlactli × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating mäcuïlli = 20, so 20 + 1 = chicöme.  
+- Equation (3) has yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, showing addition combines components with pöhualli, indicating cumulative structure.  
+- Equation (5) shows mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, and (6) gives mäcuïlli × ëyi = caxtölli; since mäcuïlli = 20, 20 × ëyi = caxtölli, so ëyi = 5, as 20 × 5 = 100.  
+- From (1): mahtlactli × mahtlactli = mäcuïl-pöhualli-om-mahtlactli; if mahtlactli = 20, then 20 × 20 = 400, and mäcuïl-pöhualli-om-mahtlactli = 400, so 400 = 400, supporting the base system.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating multiplication yields a compound structure where one factor is replicated with a base morpheme.  
+- Equation (4) confirms mäcuïlli + öme = chicöme, showing that adding a base unit to a modified form produces a known compound, allowing reconstruction via component addition.  
+- Equation (2) reveals cem-pöhualli × öme = öm-pöhualli, demonstrating a reversal of order due to multiplication with öme, implying öme acts as a unit that inverts constituent order.  
+- Equation (3) shows yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, confirming that adding two structures yields a new compound with preserved morpheme sequences and balanced components.  
+- Equation (5) demonstrates mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, revealing that multiplication generates a longer structure with nested units, suggesting a pattern where base × factor = derived structure.  
+- Equation (6) shows mäcuïlli × ëyi = caxtölli, indicating multiplication of base units produces a direct result, establishing a consistent multiplicative rule for base morphemes.
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli; the product of two mahtlactli units is a composite with pöhualli and mahtlactli.  
+- Equation (4) establishes that mäcuïlli + öme = chicöme, indicating that both mäcuïlli and öme are components of chicöme, suggesting additive structure.  
+- Equation (2) demonstrates cem-pöhualli × öme = öm-pöhualli, showing that multiplication by öme results in a reversal of the initial component, implying symmetry in operations.  
+- Equation (5) reveals mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, indicating that multilayered compound multiplication yields a specific structured output with cem and caxtölli.  
+- Equation (6) shows mäcuïlli × ëyi = caxtölli, confirming a direct multiplicative component that maps to caxtölli, supporting number decomposition via multiplication.  
+- Equation (13) expresses yë-tzontli-on-näuh-pöhualli-on-caxtölli-on-cë = ndamno, linking compound structure involving pöhualli and caxtölli to a known value, implying pöhualli-based counts are part of a base-14 system.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli; comparing to (2), cem-pöhualli × öme = öm-pöhualli confirms multiplicative structure with öme as unit.  
+- Equation (4) establishes mäcuïlli + öme = chicöme, supporting the additive base of cem-pöhualli in (2), where cem-pöhualli × öme yields öm-pöhualli.  
+- Equation (3) demonstrates yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, showing that adding mahtlactli-on-nähui yields the result on the right, confirming nähui’s role in additive chains.  
+- Equation (6) shows mäcuïlli × ëyi = caxtölli, and (5) gives mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, aligning the multiplication of a compound with ëyi producing a term with caxtölli and nähui.  
+- Equation (14) states cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, implying the structure cen-tzontli on compound terms matches the additive-multiplicative expansion of known values.  
+- Equation (15) gives cen-tzontli = tarumba tambaroy fete asàr; since tarumba = nimbo × fete and tambaroy = ngámbi + asàr, this confirms that cen-tzontli is a derived value based on known multiplicative combinations.  
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating multiplication of compound forms involving mahtlactli and cë.  
+- Equation (2) demonstrates cem-pöhualli × öme = öm-pöhualli, showing that cem-pöhualli × öme yields a form with öm- prefix, implying öme is compatible with multiplication and prefix shifting.  
+- Equation (3) reveals yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, confirming additive composition where suffixes like -on and -nähui group with specific roots.  
+- Equation (4) establishes mäcuïlli + öme = chicöme, showing that the sum of mäcuïlli and öme forms chicöme, a key component in building larger numerals.  
+- Equation (5) displays mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, indicating that multiplication with ëyi produces a chain of compound forms involving cem-pöhualli and caxtölli.  
+- Equation (6) shows mäcuïlli × ëyi = caxtölli, directly mapping multiplication of mäcuïlli and ëyi to form caxtölli, a component used in constructing 494 via multiplicative decomposition.
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating multiplication of units with additive components.  
+- Equation (2) confirms cem-pöhualli × öme = öm-pöhualli, showing that cem-pöhualli × öme results in a term with only öm-pöhualli, implying öme acts as a multiplicative unit.  
+- Equation (4) mäcuïlli + öme = chicöme demonstrates that adding mäcuïlli and öme yields chicöme, establishing a core additive relationship.  
+- Equation (6) mäcuïlli × ëyi = caxtölli shows that multiplication produces a distinct morpheme, unlike addition, revealing multiplicative derivation rules.  
+- Equation (13) yë-tzontli-on-näuh-pöhualli-on-caxtölli-on-cë = ndamno establishes that tzontli, pöhualli, and caxtölli components are multiplicative units tied to specific values.  
+- Equation (14) cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba links cen-tzontli with cem-pöhualli and öme, showing that cen-tzontli units scale multiplicatively via known components.
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, implying multiplication of compound terms follows a pattern where "on-cë" and "öme" are components tied to counts.  
+- Equation (2) confirms cem-pöhualli × öme = öm-pöhualli, indicating that multiplying cem-pöhualli by öme results in öm-pöhualli, establishing öme as a unit of 1.  
+- Equation (3) reveals that yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, showing addition of compound terms with additive structure tied to specific morphemes.  
+- Equation (5) demonstrates mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, supporting that multiplying a term containing ëyi yields a compound with cem-pöhualli and caxtölli, suggesting ëyi = 7.  
+- Equation (6) confirms mäcuïlli × ëyi = caxtölli, so if mäcuïlli × 7 = caxtölli, then mäcuïlli = 14 (since caxtölli is a known composite).  
+- Equation (14) states cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, and from (2), öme = 1, so the multiplier of mäcuïl-pöhualli is derived and tied to 42 via addition and multiplication patterns.
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows nimbo × fete = tarumba, indicating multiplicative composition where nimbo and fete produce tarumba.  
+- Equation (12) shows nimbo + yànparo tàxwo = yenówe tàxwo, establishing addition as a distinct operation from multiplication.  
+- Equation (9) shows yànparo tàxwo + fete asàr tàxwo = yànparo fete, implying that combining terms with tàxwo yields a compound with no tàxwo marker.  
+- Equation (10) shows yenówe × yenówe tàxwo = fete yenówe tàxwo, indicating that repeated multiplication produces a product with both fete and retained tàxwo.  
+- Equation (7) shows ngámbi + ngámbi = ngámbi × yànparo, asserting that addition of two ngámbi units equals multiplication involving yànparo.  
+- Equation (8) shows ngámbi + asàr = tambaroy, establishing a direct additive rule that produces a compound value.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows nimbo × fete = tarumba, establishing a multiplication rule where nimbo and fete combine to form tarumba.  
+- Equation (12) shows nimbo + yànparo tàxwo = yenówe tàxwo, linking addition to a transformation involving yànparo and yenówe.  
+- Equation (9) states yànparo tàxwo + fete asàr tàxwo = yànparo fete, indicating that addition of components with tàxwo suffixes yields a product without the suffix.  
+- Equation (8) shows ngámbi + asàr = tambaroy, demonstrating that specific morphemes combine to form a compound unit.  
+- Equation (7) shows ngámbi + ngámbi = ngámbi × yànparo, indicating that doubling ngámbi results in a multiplication involving yànparo, implying ngámbi acts as a unit in multiplication.  
+- Equation (15) gives cen-tzontli = tarumba tambaroy fete asàr, which indicates tarumba, tambaroy, and fete asàr are additive components, supporting that tarumba = nimbo × fete from (11).  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows nimbo × fete = tarumba, indicating a multiplicative relationship between nimbo, fete, and tarumba.  
+- Equation (12) states nimbo + yànparo tàxwo = yenówe tàxwo, showing addition and a component structure with tàxwo.  
+- Equation (9) demonstrates yànparo tàxwo + fete asàr tàxwo = yànparo fete, confirming that combinations of elements with tàxwo yield a simplified form.  
+- Equation (10) reveals yenówe × yenówe tàxwo = fete yenówe tàxwo, indicating fete emerges from multiplication involving yenówe.  
+- Equation (13) links yë-tzontli-on-näuh-pöhualli-on-caxtölli-on-cë to ndamno, where cumulative components imply a recursive structure tied to counts.  
+- Equation (15) gives cen-tzontli = tarumba tambaroy fete asàr, showing tarumba, tambaroy, and fete are components of a base value corresponding to 1.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows nimbo × fete = tarumba, indicating multiplication yields tarumba when nimbo and fete are combined.  
+- Equation (12) shows nimbo + yànparo tàxwo = yenówe tàxwo, establishing addition as a distinct operation from multiplication.  
+- Equation (9) shows yànparo tàxwo + fete asàr tàxwo = yànparo fete, demonstrating that adding a unit to a structured form produces a merged form.  
+- Equation (10) shows yenówe × yenówe tàxwo = fete yenówe tàxwo, indicating a multiplicative rule where yenówe and its version with tàxwo yield fete + yenówe tàxwo.  
+- Equation (13) equates a complex Nahuatl expression to ndamno, suggesting a known equivalent in Arammba that can be used to derive values.  
+- Equation (14) shows cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, linking a compound Nahuatl structure to yànparo tarumba, which appears in Arammba multiplication.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+

benchmark/IOL/ioling_hf/reports/answer_given_rationale/Qwen_Qwen3-4B-Instruct-2507__v11_official_rules_act_uninformed_n4.md

@@ -0,0 +1,246 @@
+# Answer-Given Rationale Probe
+
+- generated: `2026-07-11T23:38:24.533112+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- data: `data/rl/ioling_qwen3_4b_manual_v11_clean_prompt`
+- samples: `96` across `24` records
+- exact final-box samples: `0.927`
+- valid final-box samples: `0.927`
+- truncation rate: `0.000`
+- mean rationale chars: `1131.2`
+
+## Per Record
+
+| record | samples | exact boxes | valid boxes | best score | mean rationale chars |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| iol-2015-individual-p1-sub-b-atomic-b.1 | 4 | 4 | 4 | 1.000 | 925.0 |
+| iol-2015-individual-p1-sub-b-atomic-b.2 | 4 | 4 | 4 | 1.000 | 1003.2 |
+| iol-2015-individual-p1-sub-c-atomic-c.1 | 4 | 4 | 4 | 1.000 | 744.0 |
+| iol-2015-individual-p1-sub-c-atomic-c.2 | 4 | 4 | 4 | 1.000 | 819.2 |
+| iol-2016-individual-p3-sub-a-atomic-a.1 | 4 | 3 | 3 | 1.000 | 1223.5 |
+| iol-2016-individual-p3-sub-a-atomic-a.2 | 4 | 4 | 4 | 1.000 | 1594.8 |
+| iol-2016-individual-p3-sub-a-atomic-a.3 | 4 | 4 | 4 | 1.000 | 1230.0 |
+| iol-2016-individual-p3-sub-a-atomic-a.4 | 4 | 4 | 4 | 1.000 | 1233.2 |
+| iol-2016-individual-p3-sub-a-atomic-a.5 | 4 | 4 | 4 | 1.000 | 1072.8 |
+| iol-2016-individual-p3-sub-b-atomic-b.1 | 4 | 2 | 2 | 1.000 | 1203.2 |
+| iol-2016-individual-p3-sub-b-atomic-b.2 | 4 | 4 | 4 | 1.000 | 1293.5 |
+| iol-2016-individual-p3-sub-b-atomic-b.3 | 4 | 3 | 3 | 1.000 | 1062.8 |
+| iol-2016-individual-p3-sub-b-atomic-b.4 | 4 | 3 | 3 | 1.000 | 1264.5 |
+| iol-2016-individual-p3-sub-b-atomic-b.5 | 4 | 3 | 3 | 1.000 | 1130.2 |
+| iol-2021-individual-p3-sub-a-atomic-a.1 | 4 | 4 | 4 | 1.000 | 1293.0 |
+| iol-2021-individual-p3-sub-a-atomic-a.2 | 4 | 4 | 4 | 1.000 | 1087.2 |
+| iol-2021-individual-p3-sub-a-atomic-a.3 | 4 | 4 | 4 | 1.000 | 1089.5 |
+| iol-2021-individual-p3-sub-a-atomic-a.4 | 4 | 4 | 4 | 1.000 | 1261.2 |
+| iol-2021-individual-p3-sub-a-atomic-a.5 | 4 | 4 | 4 | 1.000 | 1093.8 |
+| iol-2021-individual-p3-sub-b-atomic-b.1 | 4 | 4 | 4 | 1.000 | 1051.2 |
+| iol-2021-individual-p3-sub-b-atomic-b.2 | 4 | 4 | 4 | 1.000 | 1208.8 |
+| iol-2021-individual-p3-sub-b-atomic-b.3 | 4 | 4 | 4 | 1.000 | 1093.8 |
+| iol-2021-individual-p3-sub-b-atomic-b.4 | 4 | 4 | 4 | 1.000 | 1119.8 |
+| iol-2021-individual-p3-sub-b-atomic-b.5 | 4 | 3 | 3 | 1.000 | 1050.2 |
+
+## Sample Outputs
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, indicating that cë acts as a unit multiplier for 20, aligning with pöhualli as a base unit.  
+- Equation (2) demonstrates cem-pöhualli × öme = öm-pöhualli, showing öme functions as a multiplicative factor of 20, consistent with pöhualli as a 20-based unit.  
+- Equation (3) reveals yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, showing that nähui is a component in addition that integrates with multiplicative units.  
+- Equation (4) states mäcuïlli + öme = chicöme, confirming that mäcuïlli (a 10-unit) combines with öme (a 20-unit) to form a compound value, supporting a 20-based numeral system with additive components.  
+- Equation (5) shows mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, indicating that mahtlactli (base unit) multiplied by ëyi (a 400-unit multiplier) produces a structure with tzontli and caxtölli, confirming 400 as a unit for 10-fold increments.  
+- Equation (13) establishes yë-tzontli-on-näuh-pöhualli-on-caxtölli-on-cë = ndamno, where 1296 = 3×400 + 4×20 + (15+1), confirming that 400 and 20 are fundamental units used in representing larger numbers.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that 20 × cë = mäcuïl-pöhualli-om-mahtlactli, supporting 20 as a base unit in the numeral system.  
+- Equation (2) demonstrates that cem-pöhualli × öme = öm-pöhualli, indicating that öme doubles a unit when combined with cem-pöhualli.  
+- Equation (3) reveals that yë-pöhualli-on-chicöme + mahtlactli-on-nähui produces näuh-pöhualli-on-cë, confirming the additive structure with nähui as a component.  
+- Equation (4) shows mäcuïlli + öme = chicöme, establishing that mäcuïlli and öme combine to form a compound numeral unit.  
+- Equation (5) exhibits mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, confirming that multiplication of mahtlactli-om-ëyi by ëyi yields a compound with caxtölli.  
+- Equation (13) shows 10 + 1 = 11 × 10 = 110, with 13 × 3 = 39 and 3 × 400 + 4 × 20 + (15 + 1) = 1296, confirming the base-400 system where 400 is tzontli and 20 is pöhualli.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that 20 × 20 = 400, supporting that pöhualli corresponds to 20 in the Nahuatl base system.  
+- Equation (2) demonstrates öme × 20 = pöhualli, confirming öme = 1 and pöhualli = 20.  
+- Equation (4) states mäcuïlli + öme = chicöme; with öme = 1, mäcuïlli = 19, so 19 + 1 = 20, indicating a hybrid base system.  
+- In equation (13), 10 + 1 = 11, mapped as 1 × 400 + 1 × 20 + (10 + 2), validating that 400 = 10 × 40 and 20 = 1 × 20.  
+- 42 = 2 × 20 + 2, directly derived from 2 × 20 = 40 and 40 + 2 = 42, matching the known form öm-pöhualli-om-öme.  
+- In equation (14), 432 = 1 × 400 + 1 × 20 + (10 + 2), confirming the additive structure with 400, 20, and remainder, consistent with 42’s decomposition.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.1` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that 20 × 20 = 400, and mäcuïl-pöhualli-om-mahtlactli corresponds to 400, confirming the base unit of 20.  
+- Equation (2) demonstrates that cem-pöhualli × öme = öm-pöhualli, showing öme as a unit value of 20, and the inversion rule for multiplication.  
+- Equation (13) confirms that 1296 = 3×400 + 4×20 + (15+1), establishing that 400 and 20 are base values in the system.  
+- In equation (4), mäcuïlli + öme = chicöme, indicating that 20 + 1 = 21 is not simple addition, and full decomposition requires context from multiplication tables.  
+- Equation (5) shows mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, indicating that 20×20 = 400 and 1×20 = 20 are embedded in compound multiplicative terms.  
+- The structure öm-pöhualli-om-öme appears in (2), where öme = 20, and the pattern 2×20 + 2 matches the decomposition of 42 as 2×20 + 2.  
+
+\boxed{b.1: öm-pöhualli-om-öme}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that mahtlactli-on-cë × mahtlactli yields mäcuïl-pöhualli-om-mahtlactli, aligning number decomposition where cë (1) and mahtlactli (20) form a multiplicative base.  
+- Equation (3) confirms yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë; here, the addition of 400 and 8000 units with nähui (4) and cë (1) indicates that 400 + 4 = 404 maps to tzontli-on-nähui.  
+- Equation (5) demonstrates mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, establishing that mahtlactli (20) × ëyi (1) yields a result with caxtölli (400), proving that 20 × 1 = 20 gives the component caxtölli-on-nähui.  
+- From equation (14), cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, and given that tarumba = 216, correspondence between 1×400 + 4×20 + 10 + 4 = 494 and the base structure confirms the required syntactic order.  
+- In equation (15), cen-tzontli = tarumba tambaroy fete asàr, where 400 → cen-tzontli and 216 + 36 + 4 = 256, but 400 alone is 400, verifying that units are expressed as base-20 units with additive supplements.  
+- Equation (13) shows yë-tzontli-on-näuh-pöhualli-on-caxtölli-on-cë = ndamno, and 1296 = 3×400 + 4×20 + (15+1) = 1200 + 80 + 16 = 1296, validating the decomposition of 494 as 1×400 + 4×20 + 10 + 4 with components on-nähui and on-pöhualli.  
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (14) shows that 432 = 1×400 + 1×20 + (10+2), mapping to cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui via consistent digit positioning and additive rule.  
+- The structure of 494 = 1×400 + 4×20 + 10 + 4 mirrors the pattern in (13) and (14), where 400 is represented by tzontli and 20 by pöhualli.  
+- In (15), 400 = 1×400 confirms that the base 400 value is always cen-tzontli, maintaining consistency in magnitude and form.  
+- Equation (3) demonstrates that adding units to a base like pöhualli with a base of 20 requires attaching -on- and incrementing the suffix, supporting the -on- linkage in derived forms.  
+- The decomposition 494 = 400 + 180 + 14 matches the additive pattern in (9) and (10), where 180 = 4×20 + 10 and 14 = 10 + 4, enforcing correct morpheme ordering.  
+- In (16), 8000 = 1×8000 shows that xiquipilli is a fixed base, linked to 8000, ensuring that 494’s part 4×20 + 10 aligns with pöhualli and nähui despite the larger base.  
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows mahtlactli-on-cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, confirming cë represents 20 and mahtlactli represents 1.  
+- Equation (2) shows cem-pöhualli × öme = öm-pöhualli, supporting öme as 1 and cem as 20.  
+- Equation (3) reveals yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, indicating nähui = 100 and cë = 20.  
+- Equation (5) demonstrates mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, showing ëyi = 2 and caxtölli = 10.  
+- Equation (14) establishes cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, where tarumba = 216 = 6³, supporting 1×400 + 1×20 + (10+2) = 432.  
+- Equation (15) shows cen-tzontli = tarumba tambaroy fete asàr, confirming 400 = 1×400, consistent with base 1 and units in 100s, 20s, and units.  
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-b-atomic-b.2` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (1) shows that cë × mahtlactli = mäcuïl-pöhualli-om-mahtlactli, confirming that cë acts as a unit multiplier in multiplication.  
+- Equation (3) reveals yë-pöhualli-on-chicöme + mahtlactli-on-nähui = näuh-pöhualli-on-cë, indicating that nähui combines with mahtlactli in additive formation.  
+- Equation (4) establishes mäcuïlli + öme = chicöme, showing öme is a direct additive component in compound numbers.  
+- Equation (5) demonstrates mahtlactli-om-ëyi × ëyi = cem-pöhualli-on-caxtölli-on-nähui, linking caxtölli to multiplication involving mahtlactli and ëyi.  
+- Equation (14) shows cen-tzontli-on-cem-pöhualli-om-mahtlactli-om-öme = yànparo tarumba, mapping 42 to öm-pöhualli-om-öme and confirming the structure for units of 400 and 20.  
+- Equation (16) confirms cen-xiquipilli = weremeke tarumba nimbo yànparo, revealing xiquipilli as 8000 and anchoring the decomposition of 494 as 400 + 80 + 10 + 4.  
+
+\boxed{b.2: cen-tzontli-on-näuh-pöhualli-om-mahtlactli-on-nähui.}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows 6³ = 216 = tarumba, establishing that 216 corresponds to tarumba in Arammba.  
+- Equation (9) demonstrates that 36 + 4×6 = 60 + 36 = 96, but 6² = 36, confirming that fete = 6².  
+- Equation (8) shows ngámbi + asàr = tambaroy, and since 6² = 36 and 6⁰ = 1, asàr = 6, thus asàr = 6.  
+- Equation (12) shows nimbo + yànparo tàxwo = yenówe tàxwo, indicating nimbo = 6, as 6×1 = 6.  
+- Equation (15) reveals tarumba tambaroy fete asàr = 400 + 216 + 36 + 6, matching 43 = 36 + 6 + 1.  
+- In equation (14), 432 = 400 + 32 yields 400 + 36 + (4×6) = 1×400 + 36 + 24 = 1×400 + 6×6, confirming 43 = 36 + 6 + 1.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (11) shows that 6³ = 216 corresponds to tarumba, establishing that 36 → fete and 216 → tarumba.  
+- Equation (9) proves that α × 6β + δ with α=1, β=2, δ=4 yields fete yànparo, supporting base-6 expansion.  
+- Equation (7) confirms ngámbi + ngámbi = ngámbi × yànparo, showing ngámbi acts as a unit with multiplicative identity.  
+- Equation (15) confirms 400 = 1×400, indicating 400 is a base unit in the Arammba numeral system.  
+- Equation (14) verifies 432 = 1×400 + 1×20 + (10+2), matching 432 = 400 + 20 + 12, implying 43 = 36 + 6 + 1.  
+- The decomposition 43 = 36 + 6 + 1 maps to fete (6²), nimbo (6¹), and ngámbi (1), aligning with (c) derivation via additive structuring.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (10) shows that yenówe × yenówe tàxwo = fete yenówe tàxwo, indicating fete is the product of yenówe × yenówe in a specific structure.  
+- Equation (11) confirms nimbo × fete = tarumba, establishing that tarumba is derived from nimbo and fete.  
+- Equation (12) shows nimbo + yànparo tàxwo = yenówe tàxwo, linking nimbo, yànparo, and yenówe via addition.  
+- Equation (9) demonstrates yànparo tàxwo + fete asàr tàxwo = yànparo fete, showing that fete asàr tàxwo is a component added to yànparo tàxwo.  
+- Equation (14) supports 432 = 1×400 + 1×20 + (10 + 2), which maps to 43 in the form of 36 + 6 + 1, corresponding to fete, nimbo, and ngámbi.  
+- The decomposition 43 = 36 + 6 + 1 aligns with the Arammba numeral system where 36 = fete, 6 = nimbo, and 1 = ngámbi, as verified by the consistent structure in the examples.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+
+### `iol-2015-individual-p1-sub-c-atomic-c.1` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- Equation (9) shows that 1 + 1 = 1 × 2 in Arammba, establishing that fete (6²) is the base unit for multiplicative expressions.  
+- Equation (11) confirms 6³ = 216 corresponds to tarumba, indicating that powers of 6 define core numerals in Arammba.  
+- Equation (12) demonstrates that nimbo + yànparo tàxwo = yenówe tàxwo, showing that nimbo (6⁺¹) functions as a subunit in additive combinations.  
+- Equation (7) establishes that ngámbi + ngámbi = ngámbi × yànparo, proving ngámbi is a unit that combines multiplicatively via yànparo.  
+- 43 = 36 + 6 + 1 corresponds to fete (6²) + nimbo (6¹) + ngámbi (6⁰), directly matching the breakdown in the provided arithmetic.  
+- The additive construction in equation (9) and the multiplicative rules in equations (7) and (8) confirm the pattern α × 6β + δ is used to derive numeral forms.  
+
+\boxed{c.1: fete nimbo ngámbi}
+```
+

benchmark/IOL/ioling_hf/reports/answer_given_rationale/Qwen_Qwen3-4B-Instruct-2507__v14_exact_trace_repair_manual_derivation_n8.md

@@ -0,0 +1,226 @@
+# Answer-Given Rationale Probe
+
+- generated: `2026-07-12T02:13:14.932209+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- data: `data/rl/ioling_qwen3_4b_manual_v14_expanded_clean`
+- samples: `32` across `4` records
+- exact final-box samples: `1.000`
+- valid final-box samples: `1.000`
+- truncation rate: `0.000`
+- mean rationale chars: `922.8`
+
+## Per Record
+
+| record | samples | exact boxes | valid boxes | best score | mean rationale chars |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| iol-2017-individual-p3-sub-a-atomic-a.2 | 8 | 8 | 8 | 1.000 | 979.9 |
+| iol-2017-individual-p3-sub-a-atomic-a.3 | 8 | 8 | 8 | 1.000 | 901.6 |
+| iol-2018-individual-p2-sub-a-atomic-a.5 | 8 | 8 | 8 | 1.000 | 886.5 |
+| iol-2018-individual-p3-sub-a-atomic-a.5 | 8 | 8 | 8 | 1.000 | 923.1 |
+
+## Sample Outputs
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá 'stars' is plural, established by the noun-class marker ʒì- from the plural form in item 4, where múdjúlù mwálà ʒìtéténbwà means "There are stars in the sky".  
+- The verb ʒjálà is a plural present tense form meaning "are", verified in item 4 where mùdjúlù ʒìtéténbwà is a statement of existence with the same structure.  
+- In item 13, the word order ʒìtéténbwá ʒjálà mùdjúlù mirrors the construction of item 4, where existence is marked by verb placement after the subject and place.  
+- The place phrase mùdjúlù 'in the sky' is structurally consistent with item 4, where it appears after the verb in a statement of existence.  
+- The derived English translation "There are stars in the sky" matches the established pattern of subject-verb-place order with plural noun-class concord.  
+- The low tone at the end of the sentence aligns with a declarative statement, as contrasted with questions in items 6 and 10, where high tone marks interrogative syntax.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá 'stars' appears in plural noun-class form with ʒì-, confirmed by item 4 where múdjúlù mwálà ʒìtéténbwà indicates "There are stars in the sky."  
+- In item 13, ʒìtéténbwá is not modified by a possessive, showing it functions as an unpossessed plural noun independent of possessive pronouns.  
+- Place phrase mùdjúlù 'in the sky' follows the verb ʒjálà 'are', aligning with the fronting rule where X V L = L V X, as seen in item 4 and 8.  
+- The verb ʒjálà used in 13 is equivalent to ʒjálà in item 2, indicating "are" in the plural and used as a copula in statements.  
+- The final tone of ʒìtéténbwá is low, assimilating to the first tone of ʒjálà, consistent with the tonal rule that the last tone of a word matches the first tone of the next.  
+- The structure ʒìtéténbwá ʒjálà mùdjúlù mirrors item 4's "There are stars in the sky," confirming that "are" is the copula and the place phrase is post-verbal.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The word ʒìtéténbwá functions as a plural verb "are" in the context of existential presence, confirmed by its use in "There are stars in the sky" (sentence 4).  
+- The phrase mùdjúlù 'in the sky' appears as a place expression with the prefix mú-, consistent with place phrases in Kimbundu carrying the mù- prefix.  
+- In sentence 4, "There are stars in the sky" uses the structure L V X (place-verb-subject), validated by example 8 and 9 where place phrases follow the verb core.  
+- The verb ʒìtéténbwá in sentence 13 is not conjugated for person, indicating a general existential or state verb, matching the structure of "There are" in sentence 4.  
+- The word order ʒìtéténbwá ʒjálà mùdjúlù follows the pattern of place-fronting (L V X), directly mirrored in sentence 4 and sentence 10.  
+- Tone contrast confirms the low tone at the end of ʒìtéténbwá and the high tone of ʒjálà, aligning with the rule that sentence-final tone indicates questions, but in this case the sentence is declarative, so final tone must be low, contradicting the presence of high tone in the question form.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá 'stars' is plural, requiring the noun-class prefix ʒì- and matching the plural class in the noun-concord system.  
+- The verb ʒjálà functions as "are" and agrees in class with the plural noun ʒìtéténbwá, confirming a plural state in the sentence.  
+- The place phrase mùdjúlù 'in the sky' appears after the verb, aligning with the option of placing the location at the end of the sentence.  
+- A fronted place phrase like "in the sky" is grammatically valid in Kimbundu, where X V L is syntactically equivalent to L V X.  
+- The sentence structure "are stars in the sky" matches the English translation of the word order and grammar from example 4: "mùdjúlù mwálà ʒìtéténbwà — There are stars in the sky."  
+- The tone pattern shows a low final tone indicating a declarative statement, consistent with the lack of question markers or interrogative markers in the sentence.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `4`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá 'stars' is plural, matching the plural noun-class marker ʒì- in Kimbundu, confirming its use in place-based statements.  
+- The verb ʒjálà 'are' functions as a linking verb, structurally equivalent to the verb in "There are stars in the sky," supporting the existential interpretation.  
+- The place phrase mùdjúlù 'in the sky' follows the standard pattern of being postposed after the verb, consistent with the grammatical order of subject-verb-place.  
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" means "There are stars in the sky," directly establishing the lexical and syntactic pattern of existential constructions.  
+- The verb ʒjálà is in a finite state with a low tone, as required for declarative statements, contrasting with high-tone verbs in questions.  
+- The structure ʒìtéténbwá ʒjálà mùdjúlù mirrors sentence 4's form and order, showing consistent alignment between word order and semantic content in existential clauses.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `5`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá ʒjálà mùdjúlù follows a place-fronting pattern where the location mùdjúlù 'in the sky' appears before the verb phrase.  
+- In sentence 4, mùdjúlù mwálà ʒìtéténbwà demonstrates that "in the sky" precedes the verb "there are stars" when used as a location marker.  
+- The verb ʒjálà in ʒìtéténbwá ʒjálà mùdjúlù matches the structure of "are" in sentence 4, where the copula is used with a plural noun to indicate existence.  
+- The noun ʒìtéténbwá in the target matches the plural form of "star" in sentence 4, where "stars" is marked with the plural class -ʒì- and is not singular.  
+- The tonal pattern shows that the final tone of ʒìtéténbwá is low, consistent with a statement, not a question, supporting a declarative translation.  
+- Sentence 13 contrasts with sentence 10, both using place phrases with the same structure, confirming that the verb "are" (ʒjálà) applies to the plural noun "stars" in a locative context.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `6`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The phrase ʒìtéténbwá 'stars' is plural, confirmed by the noun class ʒì- in ʒìtéténbwá, matching the plural marker in ʒìtéténbwá ʒjálà mùdjúlù.  
+- The verb ʒjálà means "are" and is used in a descriptive statement, as in ʒìtéténbwá ʒjálà mùdjúlù, which translates to "There are stars in the sky."  
+- The place phrase mùdjúlù 'in the sky' is not fronted and remains at the end, aligning with standard word order where place is post-verbal in descriptive sentences.  
+- The tone pattern shows a low final tone in the statement, consistent with declarative sentences as opposed to questions, proving it is not a query.  
+- The structure "NOUN VERB PLACE" matches the known pattern in sentence 4, "mùdjúlù mwálà ʒìtéténbwà — There are stars in the sky."  
+- The verb ʒjálà is grammatically parallel to ʒìtéténbwá in construction, verifying it functions as a copula in possessive or state descriptions.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `7`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù ʒìtéténbwà" means "There are stars in the sky", confirming that "mùdjúlù" is the place phrase and "ʒìtéténbwà" is the plural noun for stars.  
+- In sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù" mirrors sentence 4's structure but with place fronting: place phrase "mùdjúlù" moves to the end, showing that place can be fronted without altering meaning.  
+- Sentence 4 uses "ʒìtéténbwà" as a plural noun (class ʒì-) and "mùdjúlù" as the place, directly supporting the interpretation of "ʒìtéténbwá" as "stars" in plural.  
+- Sentence 13's word order "ʒìtéténbwá ʒjálà mùdjúlù" parallels the statement in (a)13, where "are" (ʒjálà) is used with the noun and place, confirming that "ʒjálà" is the verb "to be" in present tense.  
+- The tone pattern in sentence 4 ends with a low tone, indicating a statement, while sentence 10 (question) ends with a high tone, establishing tone as a reliability marker for question vs. statement.  
+- In sentence 5, "djámí djáʃíkà" implies "sang and danced" with verb sequence indicating action order, supporting that verb placement and sequence reflect event progression in Kimbundu.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The word ŋgákínà contains the ŋg- prefix, which denotes first-person singular subject in Kimbundu.  
+- The root kínà directly corresponds to "dance" based on parallel forms like djámí (sang) and djáʃíkà (danced) in example 5.  
+- Example 5 shows djáʃíkà meaning "danced," confirming that kínà is a distinct verb form for "to dance."  
+- The absence of a place or object in ŋgákínà aligns with the standalone verb structure where first-person subject is implied.  
+- In example 6, ŋgámónà dìkúŋgú djámí is a question, while ŋgákínà has a low final tone—indicating a declarative statement.  
+- The low tone at the end of ŋgákínà, consistent with declarative sentence tone rules, confirms it is not a question.  
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The root kínà means "dance" and appears in sentence 3 where ŋgádjà dìhónʒó djámì translates to "I ate my banana", showing that kínà is a standalone verb.  
+- The form ŋgákínà uses the first-person singular prefix ŋg- as seen in sentence 1, where ŋgámónà means "I saw", establishing ŋg- as subject marker for "I".  
+- In sentence 5, "dìkámbá djámí djáʃíkà nì djákínà", "djákínà" appears in a list of actions with "sang and danced", confirming "kínà" as the verb for "dance" in a compound sequence.  
+- The word ŋgákínà lacks a place or object and is structured as subject-verb, matching the pattern of declarative statements in items like 1 and 7.  
+- The absence of tone markers in the given form implies a low-final tone, consistent with declarative statements, as contrasted with question sentences like 10 and 11 which have high final tones.  
+- Comparing to sentence 13, where ʒìtéténbwá ʒjálà mùdjúlù translates to "There are stars in the sky", the verb form ʒìtéténbwá is a separate clause; thus, ŋgákínà must be a simple declarative "I danced" with no additional elements.  
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The word ŋgákínà contains the first-person singular prefix ŋg- indicating "I" and the verb root kínà meaning "dance".  
+- In sentence 3, "ĩgádjà dìhónʒó djámì" shows "I ate my banana", confirming that ŋg- with a verb root forms first-person actions.  
+- The absence of a place or object in ŋgákínà suggests a simple statement about a first-person action without additional context.  
+- Comparing to sentence 5, "dìkámbá djámí djáʃíkà nì djákínà" where "djákínà" appears with a high tone and separate from others, confirms kínà as a standalone verb.  
+- The low tone at the end of ŋgákínà matches the sentence-final low tone in declarative statements, as seen in sentence 1, which ends with a low tone.  
+- Unlike interrogative forms in 10 and 11, which begin with "Did", ŋgákínà lacks a question prefix, confirming it is a declarative sentence.  
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- The root kínà means "dance" and appears in the verb form ŋgákínà, where ŋg- indicates first-person singular subject.  
+- In sentence 3, ŋgádjà dìhónʒó djámì means "I ate my banana," confirming ŋg- as first-person singular with a verb meaning "to eat."  
+- The verb form kínà in ŋgákínà matches the translation of "I danced" based on parallel structure with ŋgámónà in sentence 1 meaning "I saw."  
+- In sentence 5, dìkámbá djámí djáʃíkà nì djákínà shows "sang and danced," where djákínà is a separate verb, indicating that kínà is a distinct verb for "dance."  
+- Sentence 6, ŋgámónà dìkúŋgú djámí, asks "Did I see my cave?" confirming that ŋg- marks first-person subject and negates the action, showing verb alignment with subject.  
+- The final tone is low, indicating a declarative sentence, consistent with the declarative nature of "I danced" and contrasting with high-tone questions like in item 11.  
+
+\boxed{a.3: I danced.}
+```
+

benchmark/IOL/ioling_hf/reports/answer_given_rationale/Qwen_Qwen3-4B-Instruct-2507__v14_exact_trace_repair_manual_rules_n8.md

@@ -0,0 +1,226 @@
+# Answer-Given Rationale Probe
+
+- generated: `2026-07-12T02:11:16.347619+00:00`
+- model: `Qwen/Qwen3-4B-Instruct-2507`
+- data: `data/rl/ioling_qwen3_4b_manual_v14_expanded_clean`
+- samples: `32` across `4` records
+- exact final-box samples: `1.000`
+- valid final-box samples: `1.000`
+- truncation rate: `0.000`
+- mean rationale chars: `1204.1`
+
+## Per Record
+
+| record | samples | exact boxes | valid boxes | best score | mean rationale chars |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| iol-2017-individual-p3-sub-a-atomic-a.2 | 8 | 8 | 8 | 1.000 | 1180.4 |
+| iol-2017-individual-p3-sub-a-atomic-a.3 | 8 | 8 | 8 | 1.000 | 1176.0 |
+| iol-2018-individual-p2-sub-a-atomic-a.5 | 8 | 8 | 8 | 1.000 | 1166.4 |
+| iol-2018-individual-p3-sub-a-atomic-a.5 | 8 | 8 | 8 | 1.000 | 1293.6 |
+
+## Sample Outputs
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" is stated as "There are stars in the sky," confirming that "ʒìtéténbwà" means "stars" and "mùdjúlù" means "in the sky."  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù," follows the place-fronting pattern seen in sentence 8, where "mùdjúlù" (in the sky) appears after the place marker, indicating "in the sky" is a fixed phrase.  
+- The word order in sentence 13 places "ʒìtéténbwá" (stars) before the place phrase, matching the pattern in sentence 4 where "stars in the sky" appears as "ʒìtéténbwà mùdjúlù" but is restructured.  
+- In sentence 12, "múlóʒí mwámónà ʒìtéténbwá," the subject "múlóʒí" (the sorcerer) precedes the verb "mwámónà" (saw), and "ʒìtéténbwá" is the object, showing that possessed nouns follow possessors.  
+- Contrast between sentence 9 ("mùkìtándà mwálá djálá djámì") and sentence 13 reveals that when a place is fronted, the verb must remain in a form that allows the object to follow the place, validating object placement.  
+- Sentence 11, "àtú ádjà dìhónʒò mùlwándá," shows that "dìhónʒò" (the banana) is the object, confirming that "ʒìtéténbwá" is a noun that takes the same grammatical role as "dìhónʒò" in object position.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" meaning "There are stars in the sky" shows that the place phrase "in the sky" follows the verb, confirming place postverbal placement in statements.  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù", mirrors sentence 4's structure but with reversed word order, indicating that "in the sky" can be fronted as a place phrase.  
+- Sentence 5, "dìkámbá djámí djáʃíkà nì djákínà", features a verb sequence with "and" implied by "djáʃíkà nì djákínà", showing parallel action verbs with spatial or temporal separators.  
+- Sentence 3, "ŋgádjà dìhónʒó djámì" and sentence 12, "múlóʒí mwámónà ʒìtéténbwá", demonstrate that "see" and "saw" are expressed with the ŋg- or mú- verb prefixes, with first-person subjects requiring ŋg- or a subject-specific prefix.  
+- Sentence 8, "ŋgásáŋgá múlóʒí mwámì mùlwándà", and sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù", confirm that subject-verb-object (SVO) order is maintained when a place phrase is fronted, validating alignment with SVO base.  
+- In sentence 10, "mùdìkúŋgù ŋgámónà màkòlómbóló", the question form uses high final tone, contrasting with sentence 4's low final tone, confirming tone patterns indicate questions versus statements.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" translates to "There are stars in the sky", confirming that "ʒìtéténbwà" refers to stars and is used in declarative statements with a low final tone.  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù", mirrors the word order of sentence 4 but with place fronted, showing that "ʒìtéténbwá" (stars) can be relocated before the place phrase without altering meaning.  
+- Sentence 12, "múlóʒí mwámónà ʒìtéténbwá", has "múlóʒí" (the sorcerer) as subject and "mwámónà" (saw) as verb, with "ʒìtéténbwá" as object, aligning with the subject-verb-object structure in Kimbundu.  
+- Contrasting sentence 3 ("ĩgádjà dìhónʒó djámì" = I ate my banana) with sentence 12 shows that "djámì" and "mwámónà" are verbs of perception, confirming "mwámónà" means "saw" and can be used with "stars".  
+- Sentence 11, "àtú ádjà dìhónʒò mùlwándá", uses "ádjà" (ate) with object and place, confirming that object-verb-place order is permissible when place is not fronted.  
+- In sentence 13, the fronting of "ʒìtéténbwá" to before "ʒjálà mùdjúlù" preserves semantic equivalence to "There are stars in the sky", confirming that the noun phrase must remain associated with the place despite word order shifts.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" means "There are stars in the sky," confirming that "ʒìtéténbwà" is the noun for "stars" and "mùdjúlù" is the linking verb for existence.  
+- In sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù" structurally mirrors sentence 4 with place fronting, where "ʒjálà" (in the sky) replaces "mwálà" (on the plate), showing place phrases can precede the verb.  
+- Sentence 5 shows "djámí djáʃíkà" (sang and danced) with verb sequence, indicating "djámí" is "sang" and "djáʃíkà" is "danced," supporting that "djámí" is a verb that acts as a standalone action.  
+- Sentence 12, "múlóʒí mwámónà ʒìtéténbwá," follows the pattern of "subject + verb + object," where "múlóʒí" (the sorcerer) is subject, "mwámónà" (saw) is verb, and "ʒìtéténbwá" (stars) is object—aligning with parallel structure to sentence 1.  
+- In sentence 11, "àtú ádjà dìhónʒò mùlwándá" questions past action with "àtú" as "did," showing "dìhónʒò" (eat) and "mùlwándá" (in Luanda) only when coordinated by a question marker, indicating object placement in questions.  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù," when compared to 4, confirms the syntactic equivalence of place-fronting in declarative and non-declarative contexts, maintaining verb-object structure while shifting focus to location.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `4`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" translates to "There are stars in the sky," confirming that "ʒìtéténbwà" means "stars" and appears as the object in a location-based existential clause.  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù," mirrors sentence 4 in structure, showing that "ʒìtéténbwá" is the subject and "mùdjúlù" is the place, supporting the interpretation that "ʒìtéténbwá" is the entity being located.  
+- Contrasting sentence 12 ("múlóʒí mwámónà ʒìtéténbwá") with sentence 4, the verb "mwámónà" (to see) is used with "ʒìtéténbwá," confirming that "ʒìtéténbwá" is the object of the verb and not a location.  
+- In sentence 9, "mùkìtándà mwálá djálá djámì" aligns with "mùkìtándà" (is in) followed by a place, indicating that place phrases follow after verbs when not positioned at the front.  
+- Sentence 11, "àtú ádjà dìhónʒò mùlwándá," uses "dìhónʒò" (the banana) as object after "àtú" (the people), showing that objects follow verbs in simple clauses when not fronted.  
+- In sentence 10, "mùdìkúŋgù ŋgámónà màkòlómbóló," the verb "ŋgámónà" (saw) is fronted with "mùdìkúŋgù" (the cave) as the object, confirming that object placement depends on syntactic structure and not default order.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `5`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" means "There are stars in the sky," confirming that "ʒìtéténbwà" denotes "stars" and "mùdjúlù" refers to the existential "there are."  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù," follows the place-fronting pattern seen in sentence 8 ("mùkìtándà mwálá djálá djámì"), where "ʒjálà" (in the cave) precedes the verb and location is fronted.  
+- The order "ʒìtéténbwá ʒjálà mùdjúlù" mirrors the structure of sentence 4 (place after verb), showing that place phrases follow the verb when not fronted.  
+- Contrasting with sentence 3 ("ŋgádjà dìhónʒó djámì"), where "djà" is the verb and object appears afterward, sentence 13 places the noun first, indicating a shift to a locative focus.  
+- In sentence 10 ("mùdìkúŋgù ŋgámónà màkòlómbóló"), the question marker "mùdìkúŋgù" precedes the verb, but in 13, the absence of a question marker and verb-first order indicates a declarative statement.  
+- The tone pattern in "ʒìtéténbwá" ending with a high tone, followed by a low tone in "ʒjálà," aligns with the rule that sentence-final tone is low in statements, ensuring the declarative nature of the sentence.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `6`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" translates to "There are stars in the sky," showing that "ʒìtéténbwà" is the noun for "stars" and "mùdjúlù" is the existential verb.  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù," mirrors sentence 4's structure but with place fronting: "ʒjálà" (in the sky) precedes the verb, confirming that place phrases can be moved to the front.  
+- The word "ʒìtéténbwà" appears in both sentence 4 and 13, demonstrating consistent use as the noun for "stars" regardless of position or question status.  
+- Sentence 13 starts with "ʒìtéténbwá," with a low final tone, indicating a declarative statement, matching the low tone pattern in statements from the tone rules.  
+- In sentence 11, "àtú ádjà dìhónʒò mùlwándá" asks if people ate the banana in Luanda, showing that a question begins with “Did” and contains a verb (ádjà) and object (dìhónʒò), confirming that question markers are fronted with verb shifts.  
+- Sentence 13 has no do-support verb, yet is declarative, unlike questions, showing that noun phrases precede verb-place structures when the sentence is a statement rather than a question.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.2` sample `7`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 4, "mùdjúlù mwálà ʒìtéténbwà" means "There are stars in the sky", confirming that "ʒìtéténbwà" is a direct translation of "stars".  
+- Sentence 13, "ʒìtéténbwá ʒjálà mùdjúlù", follows the pattern of place fronting: "L V X" becomes "X V L" with "ʒjálà" (in the cave) placing "mùdjúlù" (there are stars) as the clause endpoint.  
+- The verb "ʒìtéténbwá" appears in item 4 as "there are stars", indicating it is a declarative "there is/are" construction used for existence.  
+- In sentence 5, "dìkámbá djámí djáʃíkà nì djákínà", "djáʃíkà" and "djákínà" are separated by "nì", showing that "nì" introduces a parallel action, but does not alter word order of the core verb-object.  
+- Sentence 13 has "ʒjálà" before "mùdjúlù", identical in structure to sentence 2 ("àlóʒí ásáŋgá djálà mùdìkúŋgù"), where "met the man in the cave" implies place fronting of "djálà" to "in the cave".  
+- The presence of "ʒìtéténbwá" in both 4 and 13, with consistent structure and tone patterns, supports its role as a star noun phrase, not a verb or action.  
+
+\boxed{a.2: There are stars in the sky.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `0`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In example 1, "ŋgámónà dìhónʒò mùdìlóŋgà" (I saw the banana on the plate) shows that "on the plate" follows the verb, confirming that place phrases follow the verb in basic order.  
+- Example 6, "ŋgámónà dìkúŋgú djámí" (Did I see my cave?), contrasts with 5, where "sang and danced" is a verb compound, indicating that "did" questions use the same verb structure but shift to a question tone.  
+- Example 13, "ʒìtéténbwá ʒjálà mùdjúlù", establishes that "there are stars in the sky" has the place phrase after the verb, confirming fronted location syntax where place phrases can invert structure.  
+- Example 4, "mudjúlù mwálà ʒìtéténbwà", shows place-initial structure with "in the sky" at the end, indicating that when place is at the beginning, it is constructed as a copular or existential phrase.  
+- Example 14, "ŋgákínà", contains only a verb root without subject or object, and no grammatical markers, suggesting a first-person singular verb (based on ŋg-) with a missing subject, thus implying "I sang" or "I did it".  
+- Comparing with example 3, "ŋgádjà dìhónʒó djámì" (I ate my banana), the verb "djà" is first-person singular, and "ŋg-" indicates subject, so "ŋgákínà" logically must be "I sang" in this context.  
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `1`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 14, 'ŋgákínà', the verb 'kínà' (to eat) appears without a subject, but the context and parallels with 'àlóʒí ásáŋgá djálà' (the sorcerers met...) show that the subject must be implied as "I" due to first-person prefix absence in non-vocalic contexts.  
+- Sentence 3, 'ŋgádjà dìhónʒó djámì' (I ate my banana), confirms that "my" is marked by the possessive pronoun 'djámì' and that first person is marked by the verb without prefix in present tense.  
+- Sentence 6, 'ŋgámónà dìkúŋgú djámí' (Did I see my cave?), shows that first-person subject is encoded with 'ŋgámónà' and that the present tense question form retains the subject prefix.  
+- In sentence 14, the lack of a subject prefix and the presence of the verb 'kínà' with no object or place, contrast with 'ŋgámónà dìhónʒò' (I saw the banana), suggesting the subject is "I" and the verb is "ate".  
+- Sentence 11, 'àtú ádjà dìhónʒò mùlwándá' (Did the people eat the banana in Luanda?), confirms that "did" is used in questions with third-person plural, implying first-person questions use "did I" only when structure requires auxiliary.  
+- Sentence 14’s structure mirrors 'ŋgámónà dìhónʒò' in form and tone, and no verb affix or place follows, confirming it is a simple first-person statement of eating, thus translating to "I ate".  
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `2`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 14, 'ŋgákínà', the noun 'ŋgákínà' corresponds to 'I saw' based on morpheme alignment with 'ŋgámónà' (I saw) in sentence 1.  
+- The verb 'kínà' appears in 'ŋgámónà' (I saw) and 'ŋgákínà', indicating that the verb root 'kínà' means 'to see' regardless of possessive prefix.  
+- Structurally, 'ŋgákínà' mirrors sentence 1 where the first-person prefix ŋg- is replaced by ŋgá- indicating a contracted or possessive form, still denoting 'I'.  
+- Comparison with sentence 3, 'ŋgádjà dìhónʒó djámì' (I ate my banana), confirms that first-person verb forms retain the ŋg- prefix and are used as standalone clauses.  
+- Sentence 10, 'mùdìkúŋgù ŋgámónà màkòlómbóló' (Did I see the roosters in the cave?), uses a question structure with high tone and verb prefix, confirming that standalone 'ŋgámónà' means 'I saw' in statements or questions.  
+- In sentence 14, absence of object or place implies a minimal clause, consistent with 'I saw' being a stand-alone declarative, supported by tone pattern where final tone is low in statements, as per sentence 1’s tone marking.
+
+\boxed{a.3: I danced.}
+```
+
+### `iol-2017-individual-p3-sub-a-atomic-a.3` sample `3`
+
+- score: `1.0`
+- exact: `1.0`
+- final box valid: `True`
+
+```text
+- In sentence 14, 'ŋgákínà', the root 'ŋgákínà' corresponds to 'I saw' due to the presence of the first-person prefix ŋg- and the verb 'kínà' meaning 'to see'.  
+- Sentence 3 states 'ŋgádjà dìhónʒó djámì — I ate my banana', confirming that 'ŋgá-' marks first-person subject and 'dìhónʒó' means 'ate', showing consistent subject-verb structure.  
+- The verb in 'ŋgákínà' follows the same pattern as 'ŋgámónà' in sentence 1, where 'ŋgá-' denotes first person and the verb 'kínà' functions as 'to see'.  
+- Sentence 6, 'ŋgámónà dìkúŋgú djámí — Did I see my cave?', shows that 'ŋgámónà' is a first-person subject with a question marker, validating that 'ŋgákínà' must mean 'I saw' in a declarative form.  
+- In sentence 11, 'àtú ádjà dìhónʒò mùlwándá — Did the people eat the banana in Luanda?', the verb comes after the subject and object, supporting the subject-verb-object order where the verb is central and contextually recoverable.  
+- The absence of a place or object in 'ŋgákínà' indicates a minimal statement with only subject-verb, confirming that 'I saw' is the only logical translation given the morpheme base and prior verb patterns.
+
+\boxed{a.3: I danced.}
+```
+

benchmark/IOL/ioling_hf/rl/ioling_qwen3_4b_manual_v10_expanded/summary.json

@@ -0,0 +1,14 @@
+{
+  "schema_version": "ioling_rl_manual_expanded_v10",
+  "parent_data": "data/rl/ioling_qwen3_4b_manual_v9_atomic_with_prior",
+  "manual_expansion_ledger": "data/manual_overrides/train_expansion_v10.json",
+  "train_count": 61,
+  "val_count": 24,
+  "total_count": 85,
+  "expansion_count": 23,
+  "train_source_problem_count": 9,
+  "val_source_problem_count": 3,
+  "source_overlap": [],
+  "prompt_style": "strict_keyed_atomic_with_prior_v10",
+  "note": "Adds three manually transcribed source problems and 23 fact-checked atomic targets to v9 train; validation is unchanged."
+}

benchmark/IOL/ioling_hf/rl/ioling_qwen3_4b_manual_v11_clean_prompt/summary.json

@@ -0,0 +1,10 @@
+{
+  "train_count": 61,
+  "train_source_problem_count": 9,
+  "val_count": 24,
+  "val_source_problem_count": 3,
+  "schema_version": "ioling_rl_manual_clean_prompt_v11",
+  "parent_data": "data/rl/ioling_qwen3_4b_manual_v10_expanded",
+  "prompt_style": "strict_keyed_atomic_clean_v11",
+  "note": "Same manually checked tasks and labels as v10; only the reasoning and answer-contract wording is simplified."
+}

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_dummy_thread/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+import sys
+__future_module__ = True
+
+if sys.version_info[0] < 3:
+    from dummy_thread import *
+else:
+    raise ImportError('This package should not be accessible on Python 3. '
+                      'Either you are trying to run from the python-future src folder '
+                      'or your installation of python-future is corrupted.')

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_markupbase/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+import sys
+__future_module__ = True
+
+if sys.version_info[0] < 3:
+    from markupbase import *
+else:
+    raise ImportError('This package should not be accessible on Python 3. '
+                      'Either you are trying to run from the python-future src folder '
+                      'or your installation of python-future is corrupted.')

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_pytest/cacheprovider.py

@@ -0,0 +1,438 @@
+# -*- coding: utf-8 -*-
+"""
+merged implementation of the cache provider
+
+the name cache was not chosen to ensure pluggy automatically
+ignores the external pytest-cache
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import json
+import os
+from collections import OrderedDict
+
+import attr
+import py
+import six
+
+import pytest
+from .compat import _PY2 as PY2
+from .pathlib import Path
+from .pathlib import resolve_from_str
+from .pathlib import rm_rf
+
+README_CONTENT = u"""\
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/latest/cache.html) for more information.
+"""
+
+CACHEDIR_TAG_CONTENT = b"""\
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	http://www.bford.info/cachedir/spec.html
+"""
+
+
+@attr.s
+class Cache(object):
+    _cachedir = attr.ib(repr=False)
+    _config = attr.ib(repr=False)
+
+    @classmethod
+    def for_config(cls, config):
+        cachedir = cls.cache_dir_from_config(config)
+        if config.getoption("cacheclear") and cachedir.exists():
+            rm_rf(cachedir)
+            cachedir.mkdir()
+        return cls(cachedir, config)
+
+    @staticmethod
+    def cache_dir_from_config(config):
+        return resolve_from_str(config.getini("cache_dir"), config.rootdir)
+
+    def warn(self, fmt, **args):
+        from _pytest.warnings import _issue_warning_captured
+        from _pytest.warning_types import PytestCacheWarning
+
+        _issue_warning_captured(
+            PytestCacheWarning(fmt.format(**args) if args else fmt),
+            self._config.hook,
+            stacklevel=3,
+        )
+
+    def makedir(self, name):
+        """ return a directory path object with the given name.  If the
+        directory does not yet exist, it will be created.  You can use it
+        to manage files likes e. g. store/retrieve database
+        dumps across test sessions.
+
+        :param name: must be a string not containing a ``/`` separator.
+             Make sure the name contains your plugin or application
+             identifiers to prevent clashes with other cache users.
+        """
+        name = Path(name)
+        if len(name.parts) > 1:
+            raise ValueError("name is not allowed to contain path separators")
+        res = self._cachedir.joinpath("d", name)
+        res.mkdir(exist_ok=True, parents=True)
+        return py.path.local(res)
+
+    def _getvaluepath(self, key):
+        return self._cachedir.joinpath("v", Path(key))
+
+    def get(self, key, default):
+        """ return cached value for the given key.  If no value
+        was yet cached or the value cannot be read, the specified
+        default is returned.
+
+        :param key: must be a ``/`` separated value. Usually the first
+             name is the name of your plugin or your application.
+        :param default: must be provided in case of a cache-miss or
+             invalid cache values.
+
+        """
+        path = self._getvaluepath(key)
+        try:
+            with path.open("r") as f:
+                return json.load(f)
+        except (ValueError, IOError, OSError):
+            return default
+
+    def set(self, key, value):
+        """ save value for the given key.
+
+        :param key: must be a ``/`` separated value. Usually the first
+             name is the name of your plugin or your application.
+        :param value: must be of any combination of basic
+               python types, including nested types
+               like e. g. lists of dictionaries.
+        """
+        path = self._getvaluepath(key)
+        try:
+            if path.parent.is_dir():
+                cache_dir_exists_already = True
+            else:
+                cache_dir_exists_already = self._cachedir.exists()
+                path.parent.mkdir(exist_ok=True, parents=True)
+        except (IOError, OSError):
+            self.warn("could not create cache path {path}", path=path)
+            return
+        if not cache_dir_exists_already:
+            self._ensure_supporting_files()
+        try:
+            f = path.open("wb" if PY2 else "w")
+        except (IOError, OSError):
+            self.warn("cache could not write path {path}", path=path)
+        else:
+            with f:
+                json.dump(value, f, indent=2, sort_keys=True)
+
+    def _ensure_supporting_files(self):
+        """Create supporting files in the cache dir that are not really part of the cache."""
+        readme_path = self._cachedir / "README.md"
+        readme_path.write_text(README_CONTENT)
+
+        gitignore_path = self._cachedir.joinpath(".gitignore")
+        msg = u"# Created by pytest automatically.\n*"
+        gitignore_path.write_text(msg, encoding="UTF-8")
+
+        cachedir_tag_path = self._cachedir.joinpath("CACHEDIR.TAG")
+        cachedir_tag_path.write_bytes(CACHEDIR_TAG_CONTENT)
+
+
+class LFPlugin(object):
+    """ Plugin which implements the --lf (run last-failing) option """
+
+    def __init__(self, config):
+        self.config = config
+        active_keys = "lf", "failedfirst"
+        self.active = any(config.getoption(key) for key in active_keys)
+        self.lastfailed = config.cache.get("cache/lastfailed", {})
+        self._previously_failed_count = None
+        self._report_status = None
+        self._skipped_files = 0  # count skipped files during collection due to --lf
+
+    def last_failed_paths(self):
+        """Returns a set with all Paths()s of the previously failed nodeids (cached).
+        """
+        try:
+            return self._last_failed_paths
+        except AttributeError:
+            rootpath = Path(self.config.rootdir)
+            result = {rootpath / nodeid.split("::")[0] for nodeid in self.lastfailed}
+            result = {x for x in result if x.exists()}
+            self._last_failed_paths = result
+            return result
+
+    def pytest_ignore_collect(self, path):
+        """
+        Ignore this file path if we are in --lf mode and it is not in the list of
+        previously failed files.
+        """
+        if self.active and self.config.getoption("lf") and path.isfile():
+            last_failed_paths = self.last_failed_paths()
+            if last_failed_paths:
+                skip_it = Path(path) not in self.last_failed_paths()
+                if skip_it:
+                    self._skipped_files += 1
+                return skip_it
+
+    def pytest_report_collectionfinish(self):
+        if self.active and self.config.getoption("verbose") >= 0:
+            return "run-last-failure: %s" % self._report_status
+
+    def pytest_runtest_logreport(self, report):
+        if (report.when == "call" and report.passed) or report.skipped:
+            self.lastfailed.pop(report.nodeid, None)
+        elif report.failed:
+            self.lastfailed[report.nodeid] = True
+
+    def pytest_collectreport(self, report):
+        passed = report.outcome in ("passed", "skipped")
+        if passed:
+            if report.nodeid in self.lastfailed:
+                self.lastfailed.pop(report.nodeid)
+                self.lastfailed.update((item.nodeid, True) for item in report.result)
+        else:
+            self.lastfailed[report.nodeid] = True
+
+    def pytest_collection_modifyitems(self, session, config, items):
+        if not self.active:
+            return
+
+        if self.lastfailed:
+            previously_failed = []
+            previously_passed = []
+            for item in items:
+                if item.nodeid in self.lastfailed:
+                    previously_failed.append(item)
+                else:
+                    previously_passed.append(item)
+            self._previously_failed_count = len(previously_failed)
+
+            if not previously_failed:
+                # Running a subset of all tests with recorded failures
+                # only outside of it.
+                self._report_status = "%d known failures not in selected tests" % (
+                    len(self.lastfailed),
+                )
+            else:
+                if self.config.getoption("lf"):
+                    items[:] = previously_failed
+                    config.hook.pytest_deselected(items=previously_passed)
+                else:  # --failedfirst
+                    items[:] = previously_failed + previously_passed
+
+                noun = "failure" if self._previously_failed_count == 1 else "failures"
+                suffix = " first" if self.config.getoption("failedfirst") else ""
+                self._report_status = "rerun previous {count} {noun}{suffix}".format(
+                    count=self._previously_failed_count, suffix=suffix, noun=noun
+                )
+
+            if self._skipped_files > 0:
+                files_noun = "file" if self._skipped_files == 1 else "files"
+                self._report_status += " (skipped {files} {files_noun})".format(
+                    files=self._skipped_files, files_noun=files_noun
+                )
+        else:
+            self._report_status = "no previously failed tests, "
+            if self.config.getoption("last_failed_no_failures") == "none":
+                self._report_status += "deselecting all items."
+                config.hook.pytest_deselected(items=items)
+                items[:] = []
+            else:
+                self._report_status += "not deselecting items."
+
+    def pytest_sessionfinish(self, session):
+        config = self.config
+        if config.getoption("cacheshow") or hasattr(config, "slaveinput"):
+            return
+
+        saved_lastfailed = config.cache.get("cache/lastfailed", {})
+        if saved_lastfailed != self.lastfailed:
+            config.cache.set("cache/lastfailed", self.lastfailed)
+
+
+class NFPlugin(object):
+    """ Plugin which implements the --nf (run new-first) option """
+
+    def __init__(self, config):
+        self.config = config
+        self.active = config.option.newfirst
+        self.cached_nodeids = config.cache.get("cache/nodeids", [])
+
+    def pytest_collection_modifyitems(self, session, config, items):
+        if self.active:
+            new_items = OrderedDict()
+            other_items = OrderedDict()
+            for item in items:
+                if item.nodeid not in self.cached_nodeids:
+                    new_items[item.nodeid] = item
+                else:
+                    other_items[item.nodeid] = item
+
+            items[:] = self._get_increasing_order(
+                six.itervalues(new_items)
+            ) + self._get_increasing_order(six.itervalues(other_items))
+        self.cached_nodeids = [x.nodeid for x in items if isinstance(x, pytest.Item)]
+
+    def _get_increasing_order(self, items):
+        return sorted(items, key=lambda item: item.fspath.mtime(), reverse=True)
+
+    def pytest_sessionfinish(self, session):
+        config = self.config
+        if config.getoption("cacheshow") or hasattr(config, "slaveinput"):
+            return
+
+        config.cache.set("cache/nodeids", self.cached_nodeids)
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group.addoption(
+        "--lf",
+        "--last-failed",
+        action="store_true",
+        dest="lf",
+        help="rerun only the tests that failed "
+        "at the last run (or all if none failed)",
+    )
+    group.addoption(
+        "--ff",
+        "--failed-first",
+        action="store_true",
+        dest="failedfirst",
+        help="run all tests but run the last failures first.  "
+        "This may re-order tests and thus lead to "
+        "repeated fixture setup/teardown",
+    )
+    group.addoption(
+        "--nf",
+        "--new-first",
+        action="store_true",
+        dest="newfirst",
+        help="run tests from new files first, then the rest of the tests "
+        "sorted by file mtime",
+    )
+    group.addoption(
+        "--cache-show",
+        action="append",
+        nargs="?",
+        dest="cacheshow",
+        help=(
+            "show cache contents, don't perform collection or tests. "
+            "Optional argument: glob (default: '*')."
+        ),
+    )
+    group.addoption(
+        "--cache-clear",
+        action="store_true",
+        dest="cacheclear",
+        help="remove all cache contents at start of test run.",
+    )
+    cache_dir_default = ".pytest_cache"
+    if "TOX_ENV_DIR" in os.environ:
+        cache_dir_default = os.path.join(os.environ["TOX_ENV_DIR"], cache_dir_default)
+    parser.addini("cache_dir", default=cache_dir_default, help="cache directory path.")
+    group.addoption(
+        "--lfnf",
+        "--last-failed-no-failures",
+        action="store",
+        dest="last_failed_no_failures",
+        choices=("all", "none"),
+        default="all",
+        help="which tests to run with no previously (known) failures.",
+    )
+
+
+def pytest_cmdline_main(config):
+    if config.option.cacheshow:
+        from _pytest.main import wrap_session
+
+        return wrap_session(config, cacheshow)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config):
+    config.cache = Cache.for_config(config)
+    config.pluginmanager.register(LFPlugin(config), "lfplugin")
+    config.pluginmanager.register(NFPlugin(config), "nfplugin")
+
+
+@pytest.fixture
+def cache(request):
+    """
+    Return a cache object that can persist state between testing sessions.
+
+    cache.get(key, default)
+    cache.set(key, value)
+
+    Keys must be a ``/`` separated value, where the first part is usually the
+    name of your plugin or application to avoid clashes with other cache users.
+
+    Values can be any object handled by the json stdlib module.
+    """
+    return request.config.cache
+
+
+def pytest_report_header(config):
+    """Display cachedir with --cache-show and if non-default."""
+    if config.option.verbose > 0 or config.getini("cache_dir") != ".pytest_cache":
+        cachedir = config.cache._cachedir
+        # TODO: evaluate generating upward relative paths
+        # starting with .., ../.. if sensible
+
+        try:
+            displaypath = cachedir.relative_to(config.rootdir)
+        except ValueError:
+            displaypath = cachedir
+        return "cachedir: {}".format(displaypath)
+
+
+def cacheshow(config, session):
+    from pprint import pformat
+
+    tw = py.io.TerminalWriter()
+    tw.line("cachedir: " + str(config.cache._cachedir))
+    if not config.cache._cachedir.is_dir():
+        tw.line("cache is empty")
+        return 0
+
+    glob = config.option.cacheshow[0]
+    if glob is None:
+        glob = "*"
+
+    dummy = object()
+    basedir = config.cache._cachedir
+    vdir = basedir / "v"
+    tw.sep("-", "cache values for %r" % glob)
+    for valpath in sorted(x for x in vdir.rglob(glob) if x.is_file()):
+        key = valpath.relative_to(vdir)
+        val = config.cache.get(key, dummy)
+        if val is dummy:
+            tw.line("%s contains unreadable content, will be ignored" % key)
+        else:
+            tw.line("%s contains:" % key)
+            for line in pformat(val).splitlines():
+                tw.line("  " + line)
+
+    ddir = basedir / "d"
+    if ddir.is_dir():
+        contents = sorted(ddir.rglob(glob))
+        tw.sep("-", "cache directories for %r" % glob)
+        for p in contents:
+            # if p.check(dir=1):
+            #    print("%s/" % p.relto(basedir))
+            if p.is_file():
+                key = p.relative_to(basedir)
+                tw.line("{} is a file of length {:d}".format(key, p.stat().st_size))
+    return 0

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_pytest/capture.py

@@ -0,0 +1,850 @@
+# -*- coding: utf-8 -*-
+"""
+per-test stdout/stderr capturing mechanism.
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import contextlib
+import io
+import os
+import sys
+from io import UnsupportedOperation
+from tempfile import TemporaryFile
+
+import six
+
+import pytest
+from _pytest.compat import _PY3
+from _pytest.compat import CaptureIO
+
+patchsysdict = {0: "stdin", 1: "stdout", 2: "stderr"}
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group._addoption(
+        "--capture",
+        action="store",
+        default="fd" if hasattr(os, "dup") else "sys",
+        metavar="method",
+        choices=["fd", "sys", "no"],
+        help="per-test capturing method: one of fd|sys|no.",
+    )
+    group._addoption(
+        "-s",
+        action="store_const",
+        const="no",
+        dest="capture",
+        help="shortcut for --capture=no.",
+    )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_load_initial_conftests(early_config, parser, args):
+    ns = early_config.known_args_namespace
+    if ns.capture == "fd":
+        _py36_windowsconsoleio_workaround(sys.stdout)
+    _colorama_workaround()
+    _readline_workaround()
+    pluginmanager = early_config.pluginmanager
+    capman = CaptureManager(ns.capture)
+    pluginmanager.register(capman, "capturemanager")
+
+    # make sure that capturemanager is properly reset at final shutdown
+    early_config.add_cleanup(capman.stop_global_capturing)
+
+    # finally trigger conftest loading but while capturing (issue93)
+    capman.start_global_capturing()
+    outcome = yield
+    capman.suspend_global_capture()
+    if outcome.excinfo is not None:
+        out, err = capman.read_global_capture()
+        sys.stdout.write(out)
+        sys.stderr.write(err)
+
+
+class CaptureManager(object):
+    """
+    Capture plugin, manages that the appropriate capture method is enabled/disabled during collection and each
+    test phase (setup, call, teardown). After each of those points, the captured output is obtained and
+    attached to the collection/runtest report.
+
+    There are two levels of capture:
+    * global: which is enabled by default and can be suppressed by the ``-s`` option. This is always enabled/disabled
+      during collection and each test phase.
+    * fixture: when a test function or one of its fixture depend on the ``capsys`` or ``capfd`` fixtures. In this
+      case special handling is needed to ensure the fixtures take precedence over the global capture.
+    """
+
+    def __init__(self, method):
+        self._method = method
+        self._global_capturing = None
+        self._current_item = None
+
+    def __repr__(self):
+        return "<CaptureManager _method=%r _global_capturing=%r _current_item=%r>" % (
+            self._method,
+            self._global_capturing,
+            self._current_item,
+        )
+
+    def _getcapture(self, method):
+        if method == "fd":
+            return MultiCapture(out=True, err=True, Capture=FDCapture)
+        elif method == "sys":
+            return MultiCapture(out=True, err=True, Capture=SysCapture)
+        elif method == "no":
+            return MultiCapture(out=False, err=False, in_=False)
+        raise ValueError("unknown capturing method: %r" % method)  # pragma: no cover
+
+    def is_capturing(self):
+        if self.is_globally_capturing():
+            return "global"
+        capture_fixture = getattr(self._current_item, "_capture_fixture", None)
+        if capture_fixture is not None:
+            return (
+                "fixture %s" % self._current_item._capture_fixture.request.fixturename
+            )
+        return False
+
+    # Global capturing control
+
+    def is_globally_capturing(self):
+        return self._method != "no"
+
+    def start_global_capturing(self):
+        assert self._global_capturing is None
+        self._global_capturing = self._getcapture(self._method)
+        self._global_capturing.start_capturing()
+
+    def stop_global_capturing(self):
+        if self._global_capturing is not None:
+            self._global_capturing.pop_outerr_to_orig()
+            self._global_capturing.stop_capturing()
+            self._global_capturing = None
+
+    def resume_global_capture(self):
+        # During teardown of the python process, and on rare occasions, capture
+        # attributes can be `None` while trying to resume global capture.
+        if self._global_capturing is not None:
+            self._global_capturing.resume_capturing()
+
+    def suspend_global_capture(self, in_=False):
+        cap = getattr(self, "_global_capturing", None)
+        if cap is not None:
+            cap.suspend_capturing(in_=in_)
+
+    def suspend(self, in_=False):
+        # Need to undo local capsys-et-al if it exists before disabling global capture.
+        self.suspend_fixture(self._current_item)
+        self.suspend_global_capture(in_)
+
+    def resume(self):
+        self.resume_global_capture()
+        self.resume_fixture(self._current_item)
+
+    def read_global_capture(self):
+        return self._global_capturing.readouterr()
+
+    # Fixture Control (it's just forwarding, think about removing this later)
+
+    def activate_fixture(self, item):
+        """If the current item is using ``capsys`` or ``capfd``, activate them so they take precedence over
+        the global capture.
+        """
+        fixture = getattr(item, "_capture_fixture", None)
+        if fixture is not None:
+            fixture._start()
+
+    def deactivate_fixture(self, item):
+        """Deactivates the ``capsys`` or ``capfd`` fixture of this item, if any."""
+        fixture = getattr(item, "_capture_fixture", None)
+        if fixture is not None:
+            fixture.close()
+
+    def suspend_fixture(self, item):
+        fixture = getattr(item, "_capture_fixture", None)
+        if fixture is not None:
+            fixture._suspend()
+
+    def resume_fixture(self, item):
+        fixture = getattr(item, "_capture_fixture", None)
+        if fixture is not None:
+            fixture._resume()
+
+    # Helper context managers
+
+    @contextlib.contextmanager
+    def global_and_fixture_disabled(self):
+        """Context manager to temporarily disable global and current fixture capturing."""
+        self.suspend()
+        try:
+            yield
+        finally:
+            self.resume()
+
+    @contextlib.contextmanager
+    def item_capture(self, when, item):
+        self.resume_global_capture()
+        self.activate_fixture(item)
+        try:
+            yield
+        finally:
+            self.deactivate_fixture(item)
+            self.suspend_global_capture(in_=False)
+
+        out, err = self.read_global_capture()
+        item.add_report_section(when, "stdout", out)
+        item.add_report_section(when, "stderr", err)
+
+    # Hooks
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_make_collect_report(self, collector):
+        if isinstance(collector, pytest.File):
+            self.resume_global_capture()
+            outcome = yield
+            self.suspend_global_capture()
+            out, err = self.read_global_capture()
+            rep = outcome.get_result()
+            if out:
+                rep.sections.append(("Captured stdout", out))
+            if err:
+                rep.sections.append(("Captured stderr", err))
+        else:
+            yield
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_protocol(self, item):
+        self._current_item = item
+        yield
+        self._current_item = None
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_setup(self, item):
+        with self.item_capture("setup", item):
+            yield
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        with self.item_capture("call", item):
+            yield
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_teardown(self, item):
+        with self.item_capture("teardown", item):
+            yield
+
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_keyboard_interrupt(self, excinfo):
+        self.stop_global_capturing()
+
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_internalerror(self, excinfo):
+        self.stop_global_capturing()
+
+
+capture_fixtures = {"capfd", "capfdbinary", "capsys", "capsysbinary"}
+
+
+def _ensure_only_one_capture_fixture(request, name):
+    fixtures = set(request.fixturenames) & capture_fixtures - {name}
+    if fixtures:
+        fixtures = sorted(fixtures)
+        fixtures = fixtures[0] if len(fixtures) == 1 else fixtures
+        raise request.raiseerror(
+            "cannot use {} and {} at the same time".format(fixtures, name)
+        )
+
+
+@pytest.fixture
+def capsys(request):
+    """Enable text capturing of writes to ``sys.stdout`` and ``sys.stderr``.
+
+    The captured output is made available via ``capsys.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``text`` objects.
+    """
+    _ensure_only_one_capture_fixture(request, "capsys")
+    with _install_capture_fixture_on_item(request, SysCapture) as fixture:
+        yield fixture
+
+
+@pytest.fixture
+def capsysbinary(request):
+    """Enable bytes capturing of writes to ``sys.stdout`` and ``sys.stderr``.
+
+    The captured output is made available via ``capsysbinary.readouterr()``
+    method calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``bytes`` objects.
+    """
+    _ensure_only_one_capture_fixture(request, "capsysbinary")
+    # Currently, the implementation uses the python3 specific `.buffer`
+    # property of CaptureIO.
+    if sys.version_info < (3,):
+        raise request.raiseerror("capsysbinary is only supported on Python 3")
+    with _install_capture_fixture_on_item(request, SysCaptureBinary) as fixture:
+        yield fixture
+
+
+@pytest.fixture
+def capfd(request):
+    """Enable text capturing of writes to file descriptors ``1`` and ``2``.
+
+    The captured output is made available via ``capfd.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``text`` objects.
+    """
+    _ensure_only_one_capture_fixture(request, "capfd")
+    if not hasattr(os, "dup"):
+        pytest.skip(
+            "capfd fixture needs os.dup function which is not available in this system"
+        )
+    with _install_capture_fixture_on_item(request, FDCapture) as fixture:
+        yield fixture
+
+
+@pytest.fixture
+def capfdbinary(request):
+    """Enable bytes capturing of writes to file descriptors ``1`` and ``2``.
+
+    The captured output is made available via ``capfd.readouterr()`` method
+    calls, which return a ``(out, err)`` namedtuple.
+    ``out`` and ``err`` will be ``byte`` objects.
+    """
+    _ensure_only_one_capture_fixture(request, "capfdbinary")
+    if not hasattr(os, "dup"):
+        pytest.skip(
+            "capfdbinary fixture needs os.dup function which is not available in this system"
+        )
+    with _install_capture_fixture_on_item(request, FDCaptureBinary) as fixture:
+        yield fixture
+
+
+@contextlib.contextmanager
+def _install_capture_fixture_on_item(request, capture_class):
+    """
+    Context manager which creates a ``CaptureFixture`` instance and "installs" it on
+    the item/node of the given request. Used by ``capsys`` and ``capfd``.
+
+    The CaptureFixture is added as attribute of the item because it needs to accessed
+    by ``CaptureManager`` during its ``pytest_runtest_*`` hooks.
+    """
+    request.node._capture_fixture = fixture = CaptureFixture(capture_class, request)
+    capmanager = request.config.pluginmanager.getplugin("capturemanager")
+    # Need to active this fixture right away in case it is being used by another fixture (setup phase).
+    # If this fixture is being used only by a test function (call phase), then we wouldn't need this
+    # activation, but it doesn't hurt.
+    capmanager.activate_fixture(request.node)
+    yield fixture
+    fixture.close()
+    del request.node._capture_fixture
+
+
+class CaptureFixture(object):
+    """
+    Object returned by :py:func:`capsys`, :py:func:`capsysbinary`, :py:func:`capfd` and :py:func:`capfdbinary`
+    fixtures.
+    """
+
+    def __init__(self, captureclass, request):
+        self.captureclass = captureclass
+        self.request = request
+        self._capture = None
+        self._captured_out = self.captureclass.EMPTY_BUFFER
+        self._captured_err = self.captureclass.EMPTY_BUFFER
+
+    def _start(self):
+        if self._capture is None:
+            self._capture = MultiCapture(
+                out=True, err=True, in_=False, Capture=self.captureclass
+            )
+            self._capture.start_capturing()
+
+    def close(self):
+        if self._capture is not None:
+            out, err = self._capture.pop_outerr_to_orig()
+            self._captured_out += out
+            self._captured_err += err
+            self._capture.stop_capturing()
+            self._capture = None
+
+    def readouterr(self):
+        """Read and return the captured output so far, resetting the internal buffer.
+
+        :return: captured content as a namedtuple with ``out`` and ``err`` string attributes
+        """
+        captured_out, captured_err = self._captured_out, self._captured_err
+        if self._capture is not None:
+            out, err = self._capture.readouterr()
+            captured_out += out
+            captured_err += err
+        self._captured_out = self.captureclass.EMPTY_BUFFER
+        self._captured_err = self.captureclass.EMPTY_BUFFER
+        return CaptureResult(captured_out, captured_err)
+
+    def _suspend(self):
+        """Suspends this fixture's own capturing temporarily."""
+        if self._capture is not None:
+            self._capture.suspend_capturing()
+
+    def _resume(self):
+        """Resumes this fixture's own capturing temporarily."""
+        if self._capture is not None:
+            self._capture.resume_capturing()
+
+    @contextlib.contextmanager
+    def disabled(self):
+        """Temporarily disables capture while inside the 'with' block."""
+        capmanager = self.request.config.pluginmanager.getplugin("capturemanager")
+        with capmanager.global_and_fixture_disabled():
+            yield
+
+
+def safe_text_dupfile(f, mode, default_encoding="UTF8"):
+    """ return an open text file object that's a duplicate of f on the
+        FD-level if possible.
+    """
+    encoding = getattr(f, "encoding", None)
+    try:
+        fd = f.fileno()
+    except Exception:
+        if "b" not in getattr(f, "mode", "") and hasattr(f, "encoding"):
+            # we seem to have a text stream, let's just use it
+            return f
+    else:
+        newfd = os.dup(fd)
+        if "b" not in mode:
+            mode += "b"
+        f = os.fdopen(newfd, mode, 0)  # no buffering
+    return EncodedFile(f, encoding or default_encoding)
+
+
+class EncodedFile(object):
+    errors = "strict"  # possibly needed by py3 code (issue555)
+
+    def __init__(self, buffer, encoding):
+        self.buffer = buffer
+        self.encoding = encoding
+
+    def write(self, obj):
+        if isinstance(obj, six.text_type):
+            obj = obj.encode(self.encoding, "replace")
+        elif _PY3:
+            raise TypeError(
+                "write() argument must be str, not {}".format(type(obj).__name__)
+            )
+        self.buffer.write(obj)
+
+    def writelines(self, linelist):
+        data = "".join(linelist)
+        self.write(data)
+
+    @property
+    def name(self):
+        """Ensure that file.name is a string."""
+        return repr(self.buffer)
+
+    @property
+    def mode(self):
+        return self.buffer.mode.replace("b", "")
+
+    def __getattr__(self, name):
+        return getattr(object.__getattribute__(self, "buffer"), name)
+
+
+CaptureResult = collections.namedtuple("CaptureResult", ["out", "err"])
+
+
+class MultiCapture(object):
+    out = err = in_ = None
+    _state = None
+
+    def __init__(self, out=True, err=True, in_=True, Capture=None):
+        if in_:
+            self.in_ = Capture(0)
+        if out:
+            self.out = Capture(1)
+        if err:
+            self.err = Capture(2)
+
+    def __repr__(self):
+        return "<MultiCapture out=%r err=%r in_=%r _state=%r _in_suspended=%r>" % (
+            self.out,
+            self.err,
+            self.in_,
+            self._state,
+            getattr(self, "_in_suspended", "<UNSET>"),
+        )
+
+    def start_capturing(self):
+        self._state = "started"
+        if self.in_:
+            self.in_.start()
+        if self.out:
+            self.out.start()
+        if self.err:
+            self.err.start()
+
+    def pop_outerr_to_orig(self):
+        """ pop current snapshot out/err capture and flush to orig streams. """
+        out, err = self.readouterr()
+        if out:
+            self.out.writeorg(out)
+        if err:
+            self.err.writeorg(err)
+        return out, err
+
+    def suspend_capturing(self, in_=False):
+        self._state = "suspended"
+        if self.out:
+            self.out.suspend()
+        if self.err:
+            self.err.suspend()
+        if in_ and self.in_:
+            self.in_.suspend()
+            self._in_suspended = True
+
+    def resume_capturing(self):
+        self._state = "resumed"
+        if self.out:
+            self.out.resume()
+        if self.err:
+            self.err.resume()
+        if hasattr(self, "_in_suspended"):
+            self.in_.resume()
+            del self._in_suspended
+
+    def stop_capturing(self):
+        """ stop capturing and reset capturing streams """
+        if self._state == "stopped":
+            raise ValueError("was already stopped")
+        self._state = "stopped"
+        if self.out:
+            self.out.done()
+        if self.err:
+            self.err.done()
+        if self.in_:
+            self.in_.done()
+
+    def readouterr(self):
+        """ return snapshot unicode value of stdout/stderr capturings. """
+        return CaptureResult(
+            self.out.snap() if self.out is not None else "",
+            self.err.snap() if self.err is not None else "",
+        )
+
+
+class NoCapture(object):
+    EMPTY_BUFFER = None
+    __init__ = start = done = suspend = resume = lambda *args: None
+
+
+class FDCaptureBinary(object):
+    """Capture IO to/from a given os-level filedescriptor.
+
+    snap() produces `bytes`
+    """
+
+    EMPTY_BUFFER = b""
+    _state = None
+
+    def __init__(self, targetfd, tmpfile=None):
+        self.targetfd = targetfd
+        try:
+            self.targetfd_save = os.dup(self.targetfd)
+        except OSError:
+            self.start = lambda: None
+            self.done = lambda: None
+        else:
+            if targetfd == 0:
+                assert not tmpfile, "cannot set tmpfile with stdin"
+                tmpfile = open(os.devnull, "r")
+                self.syscapture = SysCapture(targetfd)
+            else:
+                if tmpfile is None:
+                    f = TemporaryFile()
+                    with f:
+                        tmpfile = safe_text_dupfile(f, mode="wb+")
+                if targetfd in patchsysdict:
+                    self.syscapture = SysCapture(targetfd, tmpfile)
+                else:
+                    self.syscapture = NoCapture()
+            self.tmpfile = tmpfile
+            self.tmpfile_fd = tmpfile.fileno()
+
+    def __repr__(self):
+        return "<FDCapture %s oldfd=%s _state=%r>" % (
+            self.targetfd,
+            getattr(self, "targetfd_save", None),
+            self._state,
+        )
+
+    def start(self):
+        """ Start capturing on targetfd using memorized tmpfile. """
+        try:
+            os.fstat(self.targetfd_save)
+        except (AttributeError, OSError):
+            raise ValueError("saved filedescriptor not valid anymore")
+        os.dup2(self.tmpfile_fd, self.targetfd)
+        self.syscapture.start()
+        self._state = "started"
+
+    def snap(self):
+        self.tmpfile.seek(0)
+        res = self.tmpfile.read()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def done(self):
+        """ stop capturing, restore streams, return original capture file,
+        seeked to position zero. """
+        targetfd_save = self.__dict__.pop("targetfd_save")
+        os.dup2(targetfd_save, self.targetfd)
+        os.close(targetfd_save)
+        self.syscapture.done()
+        _attempt_to_close_capture_file(self.tmpfile)
+        self._state = "done"
+
+    def suspend(self):
+        self.syscapture.suspend()
+        os.dup2(self.targetfd_save, self.targetfd)
+        self._state = "suspended"
+
+    def resume(self):
+        self.syscapture.resume()
+        os.dup2(self.tmpfile_fd, self.targetfd)
+        self._state = "resumed"
+
+    def writeorg(self, data):
+        """ write to original file descriptor. """
+        if isinstance(data, six.text_type):
+            data = data.encode("utf8")  # XXX use encoding of original stream
+        os.write(self.targetfd_save, data)
+
+
+class FDCapture(FDCaptureBinary):
+    """Capture IO to/from a given os-level filedescriptor.
+
+    snap() produces text
+    """
+
+    EMPTY_BUFFER = str()
+
+    def snap(self):
+        res = super(FDCapture, self).snap()
+        enc = getattr(self.tmpfile, "encoding", None)
+        if enc and isinstance(res, bytes):
+            res = six.text_type(res, enc, "replace")
+        return res
+
+
+class SysCapture(object):
+
+    EMPTY_BUFFER = str()
+    _state = None
+
+    def __init__(self, fd, tmpfile=None):
+        name = patchsysdict[fd]
+        self._old = getattr(sys, name)
+        self.name = name
+        if tmpfile is None:
+            if name == "stdin":
+                tmpfile = DontReadFromInput()
+            else:
+                tmpfile = CaptureIO()
+        self.tmpfile = tmpfile
+
+    def __repr__(self):
+        return "<SysCapture %s _old=%r, tmpfile=%r _state=%r>" % (
+            self.name,
+            self._old,
+            self.tmpfile,
+            self._state,
+        )
+
+    def start(self):
+        setattr(sys, self.name, self.tmpfile)
+        self._state = "started"
+
+    def snap(self):
+        res = self.tmpfile.getvalue()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+    def done(self):
+        setattr(sys, self.name, self._old)
+        del self._old
+        _attempt_to_close_capture_file(self.tmpfile)
+        self._state = "done"
+
+    def suspend(self):
+        setattr(sys, self.name, self._old)
+        self._state = "suspended"
+
+    def resume(self):
+        setattr(sys, self.name, self.tmpfile)
+        self._state = "resumed"
+
+    def writeorg(self, data):
+        self._old.write(data)
+        self._old.flush()
+
+
+class SysCaptureBinary(SysCapture):
+    EMPTY_BUFFER = b""
+
+    def snap(self):
+        res = self.tmpfile.buffer.getvalue()
+        self.tmpfile.seek(0)
+        self.tmpfile.truncate()
+        return res
+
+
+class DontReadFromInput(six.Iterator):
+    """Temporary stub class.  Ideally when stdin is accessed, the
+    capturing should be turned off, with possibly all data captured
+    so far sent to the screen.  This should be configurable, though,
+    because in automated test runs it is better to crash than
+    hang indefinitely.
+    """
+
+    encoding = None
+
+    def read(self, *args):
+        raise IOError("reading from stdin while output is captured")
+
+    readline = read
+    readlines = read
+    __next__ = read
+
+    def __iter__(self):
+        return self
+
+    def fileno(self):
+        raise UnsupportedOperation("redirected stdin is pseudofile, has no fileno()")
+
+    def isatty(self):
+        return False
+
+    def close(self):
+        pass
+
+    @property
+    def buffer(self):
+        if sys.version_info >= (3, 0):
+            return self
+        else:
+            raise AttributeError("redirected stdin has no attribute buffer")
+
+
+def _colorama_workaround():
+    """
+    Ensure colorama is imported so that it attaches to the correct stdio
+    handles on Windows.
+
+    colorama uses the terminal on import time. So if something does the
+    first import of colorama while I/O capture is active, colorama will
+    fail in various ways.
+    """
+    if sys.platform.startswith("win32"):
+        try:
+            import colorama  # noqa: F401
+        except ImportError:
+            pass
+
+
+def _readline_workaround():
+    """
+    Ensure readline is imported so that it attaches to the correct stdio
+    handles on Windows.
+
+    Pdb uses readline support where available--when not running from the Python
+    prompt, the readline module is not imported until running the pdb REPL.  If
+    running pytest with the --pdb option this means the readline module is not
+    imported until after I/O capture has been started.
+
+    This is a problem for pyreadline, which is often used to implement readline
+    support on Windows, as it does not attach to the correct handles for stdout
+    and/or stdin if they have been redirected by the FDCapture mechanism.  This
+    workaround ensures that readline is imported before I/O capture is setup so
+    that it can attach to the actual stdin/out for the console.
+
+    See https://github.com/pytest-dev/pytest/pull/1281
+    """
+    if sys.platform.startswith("win32"):
+        try:
+            import readline  # noqa: F401
+        except ImportError:
+            pass
+
+
+def _py36_windowsconsoleio_workaround(stream):
+    """
+    Python 3.6 implemented unicode console handling for Windows. This works
+    by reading/writing to the raw console handle using
+    ``{Read,Write}ConsoleW``.
+
+    The problem is that we are going to ``dup2`` over the stdio file
+    descriptors when doing ``FDCapture`` and this will ``CloseHandle`` the
+    handles used by Python to write to the console. Though there is still some
+    weirdness and the console handle seems to only be closed randomly and not
+    on the first call to ``CloseHandle``, or maybe it gets reopened with the
+    same handle value when we suspend capturing.
+
+    The workaround in this case will reopen stdio with a different fd which
+    also means a different handle by replicating the logic in
+    "Py_lifecycle.c:initstdio/create_stdio".
+
+    :param stream: in practice ``sys.stdout`` or ``sys.stderr``, but given
+        here as parameter for unittesting purposes.
+
+    See https://github.com/pytest-dev/py/issues/103
+    """
+    if not sys.platform.startswith("win32") or sys.version_info[:2] < (3, 6):
+        return
+
+    # bail out if ``stream`` doesn't seem like a proper ``io`` stream (#2666)
+    if not hasattr(stream, "buffer"):
+        return
+
+    buffered = hasattr(stream.buffer, "raw")
+    raw_stdout = stream.buffer.raw if buffered else stream.buffer
+
+    if not isinstance(raw_stdout, io._WindowsConsoleIO):
+        return
+
+    def _reopen_stdio(f, mode):
+        if not buffered and mode[0] == "w":
+            buffering = 0
+        else:
+            buffering = -1
+
+        return io.TextIOWrapper(
+            open(os.dup(f.fileno()), mode, buffering),
+            f.encoding,
+            f.errors,
+            f.newlines,
+            f.line_buffering,
+        )
+
+    sys.stdin = _reopen_stdio(sys.stdin, "rb")
+    sys.stdout = _reopen_stdio(sys.stdout, "wb")
+    sys.stderr = _reopen_stdio(sys.stderr, "wb")
+
+
+def _attempt_to_close_capture_file(f):
+    """Suppress IOError when closing the temporary file used for capturing streams in py27 (#2370)"""
+    if six.PY2:
+        try:
+            f.close()
+        except IOError:
+            pass
+    else:
+        f.close()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_pytest/compat.py

@@ -0,0 +1,457 @@
+# -*- coding: utf-8 -*-
+"""
+python version compatibility code
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import codecs
+import functools
+import inspect
+import re
+import sys
+from contextlib import contextmanager
+
+import py
+import six
+from six import text_type
+
+import _pytest
+from _pytest._io.saferepr import saferepr
+from _pytest.outcomes import fail
+from _pytest.outcomes import TEST_OUTCOME
+
+try:
+    import enum
+except ImportError:  # pragma: no cover
+    # Only available in Python 3.4+ or as a backport
+    enum = None
+
+_PY3 = sys.version_info > (3, 0)
+_PY2 = not _PY3
+
+
+if _PY3:
+    from inspect import signature, Parameter as Parameter
+else:
+    from funcsigs import signature, Parameter as Parameter
+
+NOTSET = object()
+
+PY35 = sys.version_info[:2] >= (3, 5)
+PY36 = sys.version_info[:2] >= (3, 6)
+MODULE_NOT_FOUND_ERROR = "ModuleNotFoundError" if PY36 else "ImportError"
+
+
+if _PY3:
+    from collections.abc import MutableMapping as MappingMixin
+    from collections.abc import Iterable, Mapping, Sequence, Sized
+else:
+    # those raise DeprecationWarnings in Python >=3.7
+    from collections import MutableMapping as MappingMixin  # noqa
+    from collections import Iterable, Mapping, Sequence, Sized  # noqa
+
+
+if sys.version_info >= (3, 4):
+    from importlib.util import spec_from_file_location
+else:
+
+    def spec_from_file_location(*_, **__):
+        return None
+
+
+def _format_args(func):
+    return str(signature(func))
+
+
+isfunction = inspect.isfunction
+isclass = inspect.isclass
+# used to work around a python2 exception info leak
+exc_clear = getattr(sys, "exc_clear", lambda: None)
+# The type of re.compile objects is not exposed in Python.
+REGEX_TYPE = type(re.compile(""))
+
+
+def is_generator(func):
+    genfunc = inspect.isgeneratorfunction(func)
+    return genfunc and not iscoroutinefunction(func)
+
+
+def iscoroutinefunction(func):
+    """Return True if func is a decorated coroutine function.
+
+    Note: copied and modified from Python 3.5's builtin couroutines.py to avoid import asyncio directly,
+    which in turns also initializes the "logging" module as side-effect (see issue #8).
+    """
+    return getattr(func, "_is_coroutine", False) or (
+        hasattr(inspect, "iscoroutinefunction") and inspect.iscoroutinefunction(func)
+    )
+
+
+def getlocation(function, curdir):
+    function = get_real_func(function)
+    fn = py.path.local(inspect.getfile(function))
+    lineno = function.__code__.co_firstlineno
+    if fn.relto(curdir):
+        fn = fn.relto(curdir)
+    return "%s:%d" % (fn, lineno + 1)
+
+
+def num_mock_patch_args(function):
+    """ return number of arguments used up by mock arguments (if any) """
+    patchings = getattr(function, "patchings", None)
+    if not patchings:
+        return 0
+    mock_modules = [sys.modules.get("mock"), sys.modules.get("unittest.mock")]
+    if any(mock_modules):
+        sentinels = [m.DEFAULT for m in mock_modules if m is not None]
+        return len(
+            [p for p in patchings if not p.attribute_name and p.new in sentinels]
+        )
+    return len(patchings)
+
+
+def getfuncargnames(function, is_method=False, cls=None):
+    """Returns the names of a function's mandatory arguments.
+
+    This should return the names of all function arguments that:
+        * Aren't bound to an instance or type as in instance or class methods.
+        * Don't have default values.
+        * Aren't bound with functools.partial.
+        * Aren't replaced with mocks.
+
+    The is_method and cls arguments indicate that the function should
+    be treated as a bound method even though it's not unless, only in
+    the case of cls, the function is a static method.
+
+    @RonnyPfannschmidt: This function should be refactored when we
+    revisit fixtures. The fixture mechanism should ask the node for
+    the fixture names, and not try to obtain directly from the
+    function object well after collection has occurred.
+
+    """
+    # The parameters attribute of a Signature object contains an
+    # ordered mapping of parameter names to Parameter instances.  This
+    # creates a tuple of the names of the parameters that don't have
+    # defaults.
+    try:
+        parameters = signature(function).parameters
+    except (ValueError, TypeError) as e:
+        fail(
+            "Could not determine arguments of {!r}: {}".format(function, e),
+            pytrace=False,
+        )
+
+    arg_names = tuple(
+        p.name
+        for p in parameters.values()
+        if (
+            p.kind is Parameter.POSITIONAL_OR_KEYWORD
+            or p.kind is Parameter.KEYWORD_ONLY
+        )
+        and p.default is Parameter.empty
+    )
+    # If this function should be treated as a bound method even though
+    # it's passed as an unbound method or function, remove the first
+    # parameter name.
+    if is_method or (
+        cls and not isinstance(cls.__dict__.get(function.__name__, None), staticmethod)
+    ):
+        arg_names = arg_names[1:]
+    # Remove any names that will be replaced with mocks.
+    if hasattr(function, "__wrapped__"):
+        arg_names = arg_names[num_mock_patch_args(function) :]
+    return arg_names
+
+
+@contextmanager
+def dummy_context_manager():
+    """Context manager that does nothing, useful in situations where you might need an actual context manager or not
+    depending on some condition. Using this allow to keep the same code"""
+    yield
+
+
+def get_default_arg_names(function):
+    # Note: this code intentionally mirrors the code at the beginning of getfuncargnames,
+    # to get the arguments which were excluded from its result because they had default values
+    return tuple(
+        p.name
+        for p in signature(function).parameters.values()
+        if p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
+        and p.default is not Parameter.empty
+    )
+
+
+_non_printable_ascii_translate_table = {
+    i: u"\\x{:02x}".format(i) for i in range(128) if i not in range(32, 127)
+}
+_non_printable_ascii_translate_table.update(
+    {ord("\t"): u"\\t", ord("\r"): u"\\r", ord("\n"): u"\\n"}
+)
+
+
+def _translate_non_printable(s):
+    return s.translate(_non_printable_ascii_translate_table)
+
+
+if _PY3:
+    STRING_TYPES = bytes, str
+    UNICODE_TYPES = six.text_type
+
+    if PY35:
+
+        def _bytes_to_ascii(val):
+            return val.decode("ascii", "backslashreplace")
+
+    else:
+
+        def _bytes_to_ascii(val):
+            if val:
+                # source: http://goo.gl/bGsnwC
+                encoded_bytes, _ = codecs.escape_encode(val)
+                return encoded_bytes.decode("ascii")
+            else:
+                # empty bytes crashes codecs.escape_encode (#1087)
+                return ""
+
+    def ascii_escaped(val):
+        """If val is pure ascii, returns it as a str().  Otherwise, escapes
+        bytes objects into a sequence of escaped bytes:
+
+        b'\xc3\xb4\xc5\xd6' -> u'\\xc3\\xb4\\xc5\\xd6'
+
+        and escapes unicode objects into a sequence of escaped unicode
+        ids, e.g.:
+
+        '4\\nV\\U00043efa\\x0eMXWB\\x1e\\u3028\\u15fd\\xcd\\U0007d944'
+
+        note:
+           the obvious "v.decode('unicode-escape')" will return
+           valid utf-8 unicode if it finds them in bytes, but we
+           want to return escaped bytes for any byte, even if they match
+           a utf-8 string.
+
+        """
+        if isinstance(val, bytes):
+            ret = _bytes_to_ascii(val)
+        else:
+            ret = val.encode("unicode_escape").decode("ascii")
+        return _translate_non_printable(ret)
+
+
+else:
+    STRING_TYPES = six.string_types
+    UNICODE_TYPES = six.text_type
+
+    def ascii_escaped(val):
+        """In py2 bytes and str are the same type, so return if it's a bytes
+        object, return it unchanged if it is a full ascii string,
+        otherwise escape it into its binary form.
+
+        If it's a unicode string, change the unicode characters into
+        unicode escapes.
+
+        """
+        if isinstance(val, bytes):
+            try:
+                ret = val.decode("ascii")
+            except UnicodeDecodeError:
+                ret = val.encode("string-escape").decode("ascii")
+        else:
+            ret = val.encode("unicode-escape").decode("ascii")
+        return _translate_non_printable(ret)
+
+
+class _PytestWrapper(object):
+    """Dummy wrapper around a function object for internal use only.
+
+    Used to correctly unwrap the underlying function object
+    when we are creating fixtures, because we wrap the function object ourselves with a decorator
+    to issue warnings when the fixture function is called directly.
+    """
+
+    def __init__(self, obj):
+        self.obj = obj
+
+
+def get_real_func(obj):
+    """ gets the real function object of the (possibly) wrapped object by
+    functools.wraps or functools.partial.
+    """
+    start_obj = obj
+    for i in range(100):
+        # __pytest_wrapped__ is set by @pytest.fixture when wrapping the fixture function
+        # to trigger a warning if it gets called directly instead of by pytest: we don't
+        # want to unwrap further than this otherwise we lose useful wrappings like @mock.patch (#3774)
+        new_obj = getattr(obj, "__pytest_wrapped__", None)
+        if isinstance(new_obj, _PytestWrapper):
+            obj = new_obj.obj
+            break
+        new_obj = getattr(obj, "__wrapped__", None)
+        if new_obj is None:
+            break
+        obj = new_obj
+    else:
+        raise ValueError(
+            ("could not find real function of {start}\nstopped at {current}").format(
+                start=saferepr(start_obj), current=saferepr(obj)
+            )
+        )
+    if isinstance(obj, functools.partial):
+        obj = obj.func
+    return obj
+
+
+def get_real_method(obj, holder):
+    """
+    Attempts to obtain the real function object that might be wrapping ``obj``, while at the same time
+    returning a bound method to ``holder`` if the original object was a bound method.
+    """
+    try:
+        is_method = hasattr(obj, "__func__")
+        obj = get_real_func(obj)
+    except Exception:
+        return obj
+    if is_method and hasattr(obj, "__get__") and callable(obj.__get__):
+        obj = obj.__get__(holder)
+    return obj
+
+
+def getfslineno(obj):
+    # xxx let decorators etc specify a sane ordering
+    obj = get_real_func(obj)
+    if hasattr(obj, "place_as"):
+        obj = obj.place_as
+    fslineno = _pytest._code.getfslineno(obj)
+    assert isinstance(fslineno[1], int), obj
+    return fslineno
+
+
+def getimfunc(func):
+    try:
+        return func.__func__
+    except AttributeError:
+        return func
+
+
+def safe_getattr(object, name, default):
+    """ Like getattr but return default upon any Exception or any OutcomeException.
+
+    Attribute access can potentially fail for 'evil' Python objects.
+    See issue #214.
+    It catches OutcomeException because of #2490 (issue #580), new outcomes are derived from BaseException
+    instead of Exception (for more details check #2707)
+    """
+    try:
+        return getattr(object, name, default)
+    except TEST_OUTCOME:
+        return default
+
+
+def safe_isclass(obj):
+    """Ignore any exception via isinstance on Python 3."""
+    try:
+        return isclass(obj)
+    except Exception:
+        return False
+
+
+def _is_unittest_unexpected_success_a_failure():
+    """Return if the test suite should fail if an @expectedFailure unittest test PASSES.
+
+    From https://docs.python.org/3/library/unittest.html?highlight=unittest#unittest.TestResult.wasSuccessful:
+        Changed in version 3.4: Returns False if there were any
+        unexpectedSuccesses from tests marked with the expectedFailure() decorator.
+    """
+    return sys.version_info >= (3, 4)
+
+
+if _PY3:
+
+    def safe_str(v):
+        """returns v as string"""
+        return str(v)
+
+
+else:
+
+    def safe_str(v):
+        """returns v as string, converting to utf-8 if necessary"""
+        try:
+            return str(v)
+        except UnicodeError:
+            if not isinstance(v, text_type):
+                v = text_type(v)
+            errors = "replace"
+            return v.encode("utf-8", errors)
+
+
+COLLECT_FAKEMODULE_ATTRIBUTES = (
+    "Collector",
+    "Module",
+    "Function",
+    "Instance",
+    "Session",
+    "Item",
+    "Class",
+    "File",
+    "_fillfuncargs",
+)
+
+
+def _setup_collect_fakemodule():
+    from types import ModuleType
+    import pytest
+
+    pytest.collect = ModuleType("pytest.collect")
+    pytest.collect.__all__ = []  # used for setns
+    for attr in COLLECT_FAKEMODULE_ATTRIBUTES:
+        setattr(pytest.collect, attr, getattr(pytest, attr))
+
+
+if _PY2:
+    # Without this the test_dupfile_on_textio will fail, otherwise CaptureIO could directly inherit from StringIO.
+    from py.io import TextIO
+
+    class CaptureIO(TextIO):
+        @property
+        def encoding(self):
+            return getattr(self, "_encoding", "UTF-8")
+
+
+else:
+    import io
+
+    class CaptureIO(io.TextIOWrapper):
+        def __init__(self):
+            super(CaptureIO, self).__init__(
+                io.BytesIO(), encoding="UTF-8", newline="", write_through=True
+            )
+
+        def getvalue(self):
+            return self.buffer.getvalue().decode("UTF-8")
+
+
+class FuncargnamesCompatAttr(object):
+    """ helper class so that Metafunc, Function and FixtureRequest
+    don't need to each define the "funcargnames" compatibility attribute.
+    """
+
+    @property
+    def funcargnames(self):
+        """ alias attribute for ``fixturenames`` for pre-2.3 compatibility"""
+        return self.fixturenames
+
+
+if six.PY2:
+
+    def lru_cache(*_, **__):
+        def dec(fn):
+            return fn
+
+        return dec
+
+
+else:
+    from functools import lru_cache  # noqa: F401

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/_pytest/debugging.py

@@ -0,0 +1,334 @@
+# -*- coding: utf-8 -*-
+""" interactive debugging with PDB, the Python Debugger. """
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import argparse
+import pdb
+import sys
+from doctest import UnexpectedException
+
+from _pytest import outcomes
+from _pytest.config import hookimpl
+from _pytest.config.exceptions import UsageError
+
+
+def _validate_usepdb_cls(value):
+    """Validate syntax of --pdbcls option."""
+    try:
+        modname, classname = value.split(":")
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            "{!r} is not in the format 'modname:classname'".format(value)
+        )
+    return (modname, classname)
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group._addoption(
+        "--pdb",
+        dest="usepdb",
+        action="store_true",
+        help="start the interactive Python debugger on errors or KeyboardInterrupt.",
+    )
+    group._addoption(
+        "--pdbcls",
+        dest="usepdb_cls",
+        metavar="modulename:classname",
+        type=_validate_usepdb_cls,
+        help="start a custom interactive Python debugger on errors. "
+        "For example: --pdbcls=IPython.terminal.debugger:TerminalPdb",
+    )
+    group._addoption(
+        "--trace",
+        dest="trace",
+        action="store_true",
+        help="Immediately break when running each test.",
+    )
+
+
+def pytest_configure(config):
+    if config.getvalue("trace"):
+        config.pluginmanager.register(PdbTrace(), "pdbtrace")
+    if config.getvalue("usepdb"):
+        config.pluginmanager.register(PdbInvoke(), "pdbinvoke")
+
+    pytestPDB._saved.append(
+        (pdb.set_trace, pytestPDB._pluginmanager, pytestPDB._config)
+    )
+    pdb.set_trace = pytestPDB.set_trace
+    pytestPDB._pluginmanager = config.pluginmanager
+    pytestPDB._config = config
+
+    # NOTE: not using pytest_unconfigure, since it might get called although
+    #       pytest_configure was not (if another plugin raises UsageError).
+    def fin():
+        (
+            pdb.set_trace,
+            pytestPDB._pluginmanager,
+            pytestPDB._config,
+        ) = pytestPDB._saved.pop()
+
+    config._cleanup.append(fin)
+
+
+class pytestPDB(object):
+    """ Pseudo PDB that defers to the real pdb. """
+
+    _pluginmanager = None
+    _config = None
+    _saved = []
+    _recursive_debug = 0
+    _wrapped_pdb_cls = None
+
+    @classmethod
+    def _is_capturing(cls, capman):
+        if capman:
+            return capman.is_capturing()
+        return False
+
+    @classmethod
+    def _import_pdb_cls(cls, capman):
+        if not cls._config:
+            # Happens when using pytest.set_trace outside of a test.
+            return pdb.Pdb
+
+        usepdb_cls = cls._config.getvalue("usepdb_cls")
+
+        if cls._wrapped_pdb_cls and cls._wrapped_pdb_cls[0] == usepdb_cls:
+            return cls._wrapped_pdb_cls[1]
+
+        if usepdb_cls:
+            modname, classname = usepdb_cls
+
+            try:
+                __import__(modname)
+                mod = sys.modules[modname]
+
+                # Handle --pdbcls=pdb:pdb.Pdb (useful e.g. with pdbpp).
+                parts = classname.split(".")
+                pdb_cls = getattr(mod, parts[0])
+                for part in parts[1:]:
+                    pdb_cls = getattr(pdb_cls, part)
+            except Exception as exc:
+                value = ":".join((modname, classname))
+                raise UsageError(
+                    "--pdbcls: could not import {!r}: {}".format(value, exc)
+                )
+        else:
+            pdb_cls = pdb.Pdb
+
+        wrapped_cls = cls._get_pdb_wrapper_class(pdb_cls, capman)
+        cls._wrapped_pdb_cls = (usepdb_cls, wrapped_cls)
+        return wrapped_cls
+
+    @classmethod
+    def _get_pdb_wrapper_class(cls, pdb_cls, capman):
+        import _pytest.config
+
+        class PytestPdbWrapper(pdb_cls, object):
+            _pytest_capman = capman
+            _continued = False
+
+            def do_debug(self, arg):
+                cls._recursive_debug += 1
+                ret = super(PytestPdbWrapper, self).do_debug(arg)
+                cls._recursive_debug -= 1
+                return ret
+
+            def do_continue(self, arg):
+                ret = super(PytestPdbWrapper, self).do_continue(arg)
+                if cls._recursive_debug == 0:
+                    tw = _pytest.config.create_terminal_writer(cls._config)
+                    tw.line()
+
+                    capman = self._pytest_capman
+                    capturing = pytestPDB._is_capturing(capman)
+                    if capturing:
+                        if capturing == "global":
+                            tw.sep(">", "PDB continue (IO-capturing resumed)")
+                        else:
+                            tw.sep(
+                                ">",
+                                "PDB continue (IO-capturing resumed for %s)"
+                                % capturing,
+                            )
+                        capman.resume()
+                    else:
+                        tw.sep(">", "PDB continue")
+                cls._pluginmanager.hook.pytest_leave_pdb(config=cls._config, pdb=self)
+                self._continued = True
+                return ret
+
+            do_c = do_cont = do_continue
+
+            def do_quit(self, arg):
+                """Raise Exit outcome when quit command is used in pdb.
+
+                This is a bit of a hack - it would be better if BdbQuit
+                could be handled, but this would require to wrap the
+                whole pytest run, and adjust the report etc.
+                """
+                ret = super(PytestPdbWrapper, self).do_quit(arg)
+
+                if cls._recursive_debug == 0:
+                    outcomes.exit("Quitting debugger")
+
+                return ret
+
+            do_q = do_quit
+            do_exit = do_quit
+
+            def setup(self, f, tb):
+                """Suspend on setup().
+
+                Needed after do_continue resumed, and entering another
+                breakpoint again.
+                """
+                ret = super(PytestPdbWrapper, self).setup(f, tb)
+                if not ret and self._continued:
+                    # pdb.setup() returns True if the command wants to exit
+                    # from the interaction: do not suspend capturing then.
+                    if self._pytest_capman:
+                        self._pytest_capman.suspend_global_capture(in_=True)
+                return ret
+
+            def get_stack(self, f, t):
+                stack, i = super(PytestPdbWrapper, self).get_stack(f, t)
+                if f is None:
+                    # Find last non-hidden frame.
+                    i = max(0, len(stack) - 1)
+                    while i and stack[i][0].f_locals.get("__tracebackhide__", False):
+                        i -= 1
+                return stack, i
+
+        return PytestPdbWrapper
+
+    @classmethod
+    def _init_pdb(cls, method, *args, **kwargs):
+        """ Initialize PDB debugging, dropping any IO capturing. """
+        import _pytest.config
+
+        if cls._pluginmanager is not None:
+            capman = cls._pluginmanager.getplugin("capturemanager")
+        else:
+            capman = None
+        if capman:
+            capman.suspend(in_=True)
+
+        if cls._config:
+            tw = _pytest.config.create_terminal_writer(cls._config)
+            tw.line()
+
+            if cls._recursive_debug == 0:
+                # Handle header similar to pdb.set_trace in py37+.
+                header = kwargs.pop("header", None)
+                if header is not None:
+                    tw.sep(">", header)
+                else:
+                    capturing = cls._is_capturing(capman)
+                    if capturing == "global":
+                        tw.sep(">", "PDB %s (IO-capturing turned off)" % (method,))
+                    elif capturing:
+                        tw.sep(
+                            ">",
+                            "PDB %s (IO-capturing turned off for %s)"
+                            % (method, capturing),
+                        )
+                    else:
+                        tw.sep(">", "PDB %s" % (method,))
+
+        _pdb = cls._import_pdb_cls(capman)(**kwargs)
+
+        if cls._pluginmanager:
+            cls._pluginmanager.hook.pytest_enter_pdb(config=cls._config, pdb=_pdb)
+        return _pdb
+
+    @classmethod
+    def set_trace(cls, *args, **kwargs):
+        """Invoke debugging via ``Pdb.set_trace``, dropping any IO capturing."""
+        frame = sys._getframe().f_back
+        _pdb = cls._init_pdb("set_trace", *args, **kwargs)
+        _pdb.set_trace(frame)
+
+
+class PdbInvoke(object):
+    def pytest_exception_interact(self, node, call, report):
+        capman = node.config.pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspend_global_capture(in_=True)
+            out, err = capman.read_global_capture()
+            sys.stdout.write(out)
+            sys.stdout.write(err)
+        _enter_pdb(node, call.excinfo, report)
+
+    def pytest_internalerror(self, excrepr, excinfo):
+        tb = _postmortem_traceback(excinfo)
+        post_mortem(tb)
+
+
+class PdbTrace(object):
+    @hookimpl(hookwrapper=True)
+    def pytest_pyfunc_call(self, pyfuncitem):
+        _test_pytest_function(pyfuncitem)
+        yield
+
+
+def _test_pytest_function(pyfuncitem):
+    _pdb = pytestPDB._init_pdb("runcall")
+    testfunction = pyfuncitem.obj
+    pyfuncitem.obj = _pdb.runcall
+    if "func" in pyfuncitem._fixtureinfo.argnames:  # pragma: no branch
+        raise ValueError("--trace can't be used with a fixture named func!")
+    pyfuncitem.funcargs["func"] = testfunction
+    new_list = list(pyfuncitem._fixtureinfo.argnames)
+    new_list.append("func")
+    pyfuncitem._fixtureinfo.argnames = tuple(new_list)
+
+
+def _enter_pdb(node, excinfo, rep):
+    # XXX we re-use the TerminalReporter's terminalwriter
+    # because this seems to avoid some encoding related troubles
+    # for not completely clear reasons.
+    tw = node.config.pluginmanager.getplugin("terminalreporter")._tw
+    tw.line()
+
+    showcapture = node.config.option.showcapture
+
+    for sectionname, content in (
+        ("stdout", rep.capstdout),
+        ("stderr", rep.capstderr),
+        ("log", rep.caplog),
+    ):
+        if showcapture in (sectionname, "all") and content:
+            tw.sep(">", "captured " + sectionname)
+            if content[-1:] == "\n":
+                content = content[:-1]
+            tw.line(content)
+
+    tw.sep(">", "traceback")
+    rep.toterminal(tw)
+    tw.sep(">", "entering PDB")
+    tb = _postmortem_traceback(excinfo)
+    rep._pdbshown = True
+    post_mortem(tb)
+    return rep
+
+
+def _postmortem_traceback(excinfo):
+    if isinstance(excinfo.value, UnexpectedException):
+        # A doctest.UnexpectedException is not useful for post_mortem.
+        # Use the underlying exception instead:
+        return excinfo.value.exc_info[2]
+    else:
+        return excinfo._excinfo[2]
+
+
+def post_mortem(t):
+    p = pytestPDB._init_pdb("post_mortem")
+    p.reset()
+    p.interaction(None, t)
+    if p.quitting:
+        outcomes.exit("Quitting debugger")

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/future-0.17.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: true
+Tag: cp27-none-any
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/future-0.17.1.dist-info/top_level.txt

@@ -0,0 +1,17 @@
+_dummy_thread
+_markupbase
+_thread
+builtins
+copyreg
+future
+html
+http
+libfuturize
+libpasteurize
+past
+queue
+reprlib
+socketserver
+tkinter
+winreg
+xmlrpc

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/html/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import absolute_import
+import sys
+
+if sys.version_info[0] < 3:
+    from future.moves.html import *
+else:
+    raise ImportError('This package should not be accessible on Python 3. '
+                      'Either you are trying to run from the python-future src folder '
+                      'or your installation of python-future is corrupted.')

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/html/entities.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import
+from future.utils import PY3
+
+if PY3:
+    from html.entities import *
+else:
+    from future.moves.html.entities import *

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/html/parser.py

@@ -0,0 +1,8 @@
+from __future__ import absolute_import
+import sys
+__future_module__ = True
+
+if sys.version_info[0] == 3:
+    raise ImportError('Cannot import module from python-future source folder')
+else:
+    from future.moves.html.parser import *

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/http/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import absolute_import
+import sys
+
+if sys.version_info[0] < 3:
+    pass
+else:
+    raise ImportError('This package should not be accessible on Python 3. '
+                      'Either you are trying to run from the python-future src folder '
+                      'or your installation of python-future is corrupted.')

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/http/client.py

@@ -0,0 +1,91 @@
+from __future__ import absolute_import
+import sys
+
+assert sys.version_info[0] < 3
+
+from httplib import *
+from httplib import HTTPMessage
+
+# These constants aren't included in __all__ in httplib.py:
+
+from httplib import (HTTP_PORT,
+                     HTTPS_PORT,
+
+                     _CS_IDLE,
+                     _CS_REQ_STARTED,
+                     _CS_REQ_SENT,
+
+                     CONTINUE,
+                     SWITCHING_PROTOCOLS,
+                     PROCESSING,
+
+                     OK,
+                     CREATED,
+                     ACCEPTED,
+                     NON_AUTHORITATIVE_INFORMATION,
+                     NO_CONTENT,
+                     RESET_CONTENT,
+                     PARTIAL_CONTENT,
+                     MULTI_STATUS,
+                     IM_USED,
+
+                     MULTIPLE_CHOICES,
+                     MOVED_PERMANENTLY,
+                     FOUND,
+                     SEE_OTHER,
+                     NOT_MODIFIED,
+                     USE_PROXY,
+                     TEMPORARY_REDIRECT,
+
+                     BAD_REQUEST,
+                     UNAUTHORIZED,
+                     PAYMENT_REQUIRED,
+                     FORBIDDEN,
+                     NOT_FOUND,
+                     METHOD_NOT_ALLOWED,
+                     NOT_ACCEPTABLE,
+                     PROXY_AUTHENTICATION_REQUIRED,
+                     REQUEST_TIMEOUT,
+                     CONFLICT,
+                     GONE,
+                     LENGTH_REQUIRED,
+                     PRECONDITION_FAILED,
+                     REQUEST_ENTITY_TOO_LARGE,
+                     REQUEST_URI_TOO_LONG,
+                     UNSUPPORTED_MEDIA_TYPE,
+                     REQUESTED_RANGE_NOT_SATISFIABLE,
+                     EXPECTATION_FAILED,
+                     UNPROCESSABLE_ENTITY,
+                     LOCKED,
+                     FAILED_DEPENDENCY,
+                     UPGRADE_REQUIRED,
+
+                     INTERNAL_SERVER_ERROR,
+                     NOT_IMPLEMENTED,
+                     BAD_GATEWAY,
+                     SERVICE_UNAVAILABLE,
+                     GATEWAY_TIMEOUT,
+                     HTTP_VERSION_NOT_SUPPORTED,
+                     INSUFFICIENT_STORAGE,
+                     NOT_EXTENDED,
+
+                     MAXAMOUNT,
+                    )
+
+# These are not available on Python 2.6.x:
+try:
+    from httplib import LineTooLong, LineAndFileWrapper
+except ImportError:
+    pass
+
+# These may not be available on all versions of Python 2.6.x or 2.7.x
+try:
+    from httplib import (
+                         _MAXLINE,
+                         _MAXHEADERS,
+                         _is_legal_header_name,
+                         _is_illegal_header_value,
+                         _METHODS_EXPECTING_BODY
+                        )
+except ImportError:
+    pass

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/http/cookiejar.py

@@ -0,0 +1,6 @@
+from __future__ import absolute_import
+import sys
+
+assert sys.version_info[0] < 3
+
+from cookielib import *

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/http/cookies.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import
+import sys
+
+assert sys.version_info[0] < 3
+
+from Cookie import *
+from Cookie import Morsel    # left out of __all__ on Py2.7!

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/http/server.py

@@ -0,0 +1,18 @@
+from __future__ import absolute_import
+import sys
+
+assert sys.version_info[0] < 3
+
+from BaseHTTPServer import *
+from CGIHTTPServer import *
+from SimpleHTTPServer import *
+try:
+    from CGIHTTPServer import _url_collapse_path     # needed for a test
+except ImportError:
+    try:
+        # Python 2.7.0 to 2.7.3
+        from CGIHTTPServer import (
+            _url_collapse_path_split as _url_collapse_path)
+    except ImportError:
+        # Doesn't exist on Python 2.6.x. Ignore it.
+        pass

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna/codec.py

@@ -0,0 +1,118 @@
+from .core import encode, decode, alabel, ulabel, IDNAError
+import codecs
+import re
+
+_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]')
+
+class Codec(codecs.Codec):
+
+    def encode(self, data, errors='strict'):
+
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return "", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data, errors='strict'):
+
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return u"", 0
+
+        return decode(data), len(data)
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data, errors, final):
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return ("", 0)
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = u''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result = ".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result, size)
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data, errors, final):
+        if errors != 'strict':
+            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+
+        if not data:
+            return (u"", 0)
+
+        # IDNA allows decoding to operate on Unicode strings, too.
+        if isinstance(data, unicode):
+            labels = _unicode_dots_re.split(data)
+        else:
+            # Must be ASCII string
+            data = str(data)
+            unicode(data, "ascii")
+            labels = data.split(".")
+
+        trailing_dot = u''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = u'.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = u'.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result = u".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+def getregentry():
+    return codecs.CodecInfo(
+        name='idna',
+        encode=Codec().encode,
+        decode=Codec().decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna/compat.py

@@ -0,0 +1,12 @@
+from .core import *
+from .codec import *
+
+def ToASCII(label):
+    return encode(label)
+
+def ToUnicode(label):
+    return decode(label)
+
+def nameprep(s):
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")
+

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/api.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.api
+~~~~~~~~~~~~
+
+This module implements the Requests API.
+
+:copyright: (c) 2012 by Kenneth Reitz.
+:license: Apache2, see LICENSE for more details.
+"""
+
+from . import sessions
+
+
+def request(method, url, **kwargs):
+    """Constructs and sends a :class:`Request <Request>`.
+
+    :param method: method for the new :class:`Request` object.
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
+    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
+    :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
+    :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
+        ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
+        or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
+        defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
+        to add for the file.
+    :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
+    :param timeout: (optional) How many seconds to wait for the server to send data
+        before giving up, as a float, or a :ref:`(connect timeout, read
+        timeout) <timeouts>` tuple.
+    :type timeout: float or tuple
+    :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
+    :type allow_redirects: bool
+    :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
+    :param verify: (optional) Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use. Defaults to ``True``.
+    :param stream: (optional) if ``False``, the response content will be immediately downloaded.
+    :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.request('GET', 'https://httpbin.org/get')
+      <Response [200]>
+    """
+
+    # By using the 'with' statement we are sure the session is closed, thus we
+    # avoid leaving sockets open which can trigger a ResourceWarning in some
+    # cases, and look like a memory leak in others.
+    with sessions.Session() as session:
+        return session.request(method=method, url=url, **kwargs)
+
+
+def get(url, params=None, **kwargs):
+    r"""Sends a GET request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', True)
+    return request('get', url, params=params, **kwargs)
+
+
+def options(url, **kwargs):
+    r"""Sends an OPTIONS request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', True)
+    return request('options', url, **kwargs)
+
+
+def head(url, **kwargs):
+    r"""Sends a HEAD request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    kwargs.setdefault('allow_redirects', False)
+    return request('head', url, **kwargs)
+
+
+def post(url, data=None, json=None, **kwargs):
+    r"""Sends a POST request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('post', url, data=data, json=json, **kwargs)
+
+
+def put(url, data=None, **kwargs):
+    r"""Sends a PUT request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('put', url, data=data, **kwargs)
+
+
+def patch(url, data=None, **kwargs):
+    r"""Sends a PATCH request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('patch', url, data=data, **kwargs)
+
+
+def delete(url, **kwargs):
+    r"""Sends a DELETE request.
+
+    :param url: URL for the new :class:`Request` object.
+    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :return: :class:`Response <Response>` object
+    :rtype: requests.Response
+    """
+
+    return request('delete', url, **kwargs)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/auth.py

@@ -0,0 +1,305 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.auth
+~~~~~~~~~~~~~
+
+This module contains the authentication handlers for Requests.
+"""
+
+import os
+import re
+import time
+import hashlib
+import threading
+import warnings
+
+from base64 import b64encode
+
+from .compat import urlparse, str, basestring
+from .cookies import extract_cookies_to_jar
+from ._internal_utils import to_native_string
+from .utils import parse_dict_header
+
+CONTENT_TYPE_FORM_URLENCODED = 'application/x-www-form-urlencoded'
+CONTENT_TYPE_MULTI_PART = 'multipart/form-data'
+
+
+def _basic_auth_str(username, password):
+    """Returns a Basic Auth string."""
+
+    # "I want us to put a big-ol' comment on top of it that
+    # says that this behaviour is dumb but we need to preserve
+    # it because people are relying on it."
+    #    - Lukasa
+    #
+    # These are here solely to maintain backwards compatibility
+    # for things like ints. This will be removed in 3.0.0.
+    if not isinstance(username, basestring):
+        warnings.warn(
+            "Non-string usernames will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(username),
+            category=DeprecationWarning,
+        )
+        username = str(username)
+
+    if not isinstance(password, basestring):
+        warnings.warn(
+            "Non-string passwords will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(password),
+            category=DeprecationWarning,
+        )
+        password = str(password)
+    # -- End Removal --
+
+    if isinstance(username, str):
+        username = username.encode('latin1')
+
+    if isinstance(password, str):
+        password = password.encode('latin1')
+
+    authstr = 'Basic ' + to_native_string(
+        b64encode(b':'.join((username, password))).strip()
+    )
+
+    return authstr
+
+
+class AuthBase(object):
+    """Base class that all auth implementations derive from"""
+
+    def __call__(self, r):
+        raise NotImplementedError('Auth hooks must be callable.')
+
+
+class HTTPBasicAuth(AuthBase):
+    """Attaches HTTP Basic Authentication to the given Request object."""
+
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+
+    def __eq__(self, other):
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __call__(self, r):
+        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
+        return r
+
+
+class HTTPProxyAuth(HTTPBasicAuth):
+    """Attaches HTTP Proxy Authentication to a given Request object."""
+
+    def __call__(self, r):
+        r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
+        return r
+
+
+class HTTPDigestAuth(AuthBase):
+    """Attaches HTTP Digest Authentication to the given Request object."""
+
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+        # Keep state in per-thread local storage
+        self._thread_local = threading.local()
+
+    def init_per_thread_state(self):
+        # Ensure state is initialized just once per-thread
+        if not hasattr(self._thread_local, 'init'):
+            self._thread_local.init = True
+            self._thread_local.last_nonce = ''
+            self._thread_local.nonce_count = 0
+            self._thread_local.chal = {}
+            self._thread_local.pos = None
+            self._thread_local.num_401_calls = None
+
+    def build_digest_header(self, method, url):
+        """
+        :rtype: str
+        """
+
+        realm = self._thread_local.chal['realm']
+        nonce = self._thread_local.chal['nonce']
+        qop = self._thread_local.chal.get('qop')
+        algorithm = self._thread_local.chal.get('algorithm')
+        opaque = self._thread_local.chal.get('opaque')
+        hash_utf8 = None
+
+        if algorithm is None:
+            _algorithm = 'MD5'
+        else:
+            _algorithm = algorithm.upper()
+        # lambdas assume digest modules are imported at the top level
+        if _algorithm == 'MD5' or _algorithm == 'MD5-SESS':
+            def md5_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.md5(x).hexdigest()
+            hash_utf8 = md5_utf8
+        elif _algorithm == 'SHA':
+            def sha_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha1(x).hexdigest()
+            hash_utf8 = sha_utf8
+        elif _algorithm == 'SHA-256':
+            def sha256_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha256(x).hexdigest()
+            hash_utf8 = sha256_utf8
+        elif _algorithm == 'SHA-512':
+            def sha512_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha512(x).hexdigest()
+            hash_utf8 = sha512_utf8
+
+        KD = lambda s, d: hash_utf8("%s:%s" % (s, d))
+
+        if hash_utf8 is None:
+            return None
+
+        # XXX not implemented yet
+        entdig = None
+        p_parsed = urlparse(url)
+        #: path is request-uri defined in RFC 2616 which should not be empty
+        path = p_parsed.path or "/"
+        if p_parsed.query:
+            path += '?' + p_parsed.query
+
+        A1 = '%s:%s:%s' % (self.username, realm, self.password)
+        A2 = '%s:%s' % (method, path)
+
+        HA1 = hash_utf8(A1)
+        HA2 = hash_utf8(A2)
+
+        if nonce == self._thread_local.last_nonce:
+            self._thread_local.nonce_count += 1
+        else:
+            self._thread_local.nonce_count = 1
+        ncvalue = '%08x' % self._thread_local.nonce_count
+        s = str(self._thread_local.nonce_count).encode('utf-8')
+        s += nonce.encode('utf-8')
+        s += time.ctime().encode('utf-8')
+        s += os.urandom(8)
+
+        cnonce = (hashlib.sha1(s).hexdigest()[:16])
+        if _algorithm == 'MD5-SESS':
+            HA1 = hash_utf8('%s:%s:%s' % (HA1, nonce, cnonce))
+
+        if not qop:
+            respdig = KD(HA1, "%s:%s" % (nonce, HA2))
+        elif qop == 'auth' or 'auth' in qop.split(','):
+            noncebit = "%s:%s:%s:%s:%s" % (
+                nonce, ncvalue, cnonce, 'auth', HA2
+            )
+            respdig = KD(HA1, noncebit)
+        else:
+            # XXX handle auth-int.
+            return None
+
+        self._thread_local.last_nonce = nonce
+
+        # XXX should the partial digests be encoded too?
+        base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
+               'response="%s"' % (self.username, realm, nonce, path, respdig)
+        if opaque:
+            base += ', opaque="%s"' % opaque
+        if algorithm:
+            base += ', algorithm="%s"' % algorithm
+        if entdig:
+            base += ', digest="%s"' % entdig
+        if qop:
+            base += ', qop="auth", nc=%s, cnonce="%s"' % (ncvalue, cnonce)
+
+        return 'Digest %s' % (base)
+
+    def handle_redirect(self, r, **kwargs):
+        """Reset num_401_calls counter on redirects."""
+        if r.is_redirect:
+            self._thread_local.num_401_calls = 1
+
+    def handle_401(self, r, **kwargs):
+        """
+        Takes the given response and tries digest-auth, if needed.
+
+        :rtype: requests.Response
+        """
+
+        # If response is not 4xx, do not auth
+        # See https://github.com/requests/requests/issues/3772
+        if not 400 <= r.status_code < 500:
+            self._thread_local.num_401_calls = 1
+            return r
+
+        if self._thread_local.pos is not None:
+            # Rewind the file position indicator of the body to where
+            # it was to resend the request.
+            r.request.body.seek(self._thread_local.pos)
+        s_auth = r.headers.get('www-authenticate', '')
+
+        if 'digest' in s_auth.lower() and self._thread_local.num_401_calls < 2:
+
+            self._thread_local.num_401_calls += 1
+            pat = re.compile(r'digest ', flags=re.IGNORECASE)
+            self._thread_local.chal = parse_dict_header(pat.sub('', s_auth, count=1))
+
+            # Consume content and release the original connection
+            # to allow our new request to reuse the same one.
+            r.content
+            r.close()
+            prep = r.request.copy()
+            extract_cookies_to_jar(prep._cookies, r.request, r.raw)
+            prep.prepare_cookies(prep._cookies)
+
+            prep.headers['Authorization'] = self.build_digest_header(
+                prep.method, prep.url)
+            _r = r.connection.send(prep, **kwargs)
+            _r.history.append(r)
+            _r.request = prep
+
+            return _r
+
+        self._thread_local.num_401_calls = 1
+        return r
+
+    def __call__(self, r):
+        # Initialize per-thread state, if needed
+        self.init_per_thread_state()
+        # If we have a saved nonce, skip the 401
+        if self._thread_local.last_nonce:
+            r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
+        try:
+            self._thread_local.pos = r.body.tell()
+        except AttributeError:
+            # In the case of HTTPDigestAuth being reused and the body of
+            # the previous request was a file-like object, pos has the
+            # file position of the previous body. Ensure it's set to
+            # None.
+            self._thread_local.pos = None
+        r.register_hook('response', self.handle_401)
+        r.register_hook('response', self.handle_redirect)
+        self._thread_local.num_401_calls = 1
+
+        return r
+
+    def __eq__(self, other):
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
+
+    def __ne__(self, other):
+        return not self == other

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/certs.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+requests.certs
+~~~~~~~~~~~~~~
+
+This module returns the preferred default CA certificate bundle. There is
+only one — the one from the certifi package.
+
+If you are packaging Requests, e.g., for a Linux distribution or a managed
+environment, you can change the definition of where() to return a separately
+packaged CA bundle.
+"""
+from certifi import where
+
+if __name__ == '__main__':
+    print(where())

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/compat.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.compat
+~~~~~~~~~~~~~~~
+
+This module handles import compatibility issues between Python 2 and
+Python 3.
+"""
+
+import chardet
+
+import sys
+
+# -------
+# Pythons
+# -------
+
+# Syntax sugar.
+_ver = sys.version_info
+
+#: Python 2.x?
+is_py2 = (_ver[0] == 2)
+
+#: Python 3.x?
+is_py3 = (_ver[0] == 3)
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+# ---------
+# Specifics
+# ---------
+
+if is_py2:
+    from urllib import (
+        quote, unquote, quote_plus, unquote_plus, urlencode, getproxies,
+        proxy_bypass, proxy_bypass_environment, getproxies_environment)
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
+    from urllib2 import parse_http_list
+    import cookielib
+    from Cookie import Morsel
+    from StringIO import StringIO
+    from collections import Callable, Mapping, MutableMapping, OrderedDict
+
+
+    builtin_str = str
+    bytes = str
+    str = unicode
+    basestring = basestring
+    numeric_types = (int, long, float)
+    integer_types = (int, long)
+
+elif is_py3:
+    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
+    from urllib.request import parse_http_list, getproxies, proxy_bypass, proxy_bypass_environment, getproxies_environment
+    from http import cookiejar as cookielib
+    from http.cookies import Morsel
+    from io import StringIO
+    from collections import OrderedDict
+    from collections.abc import Callable, Mapping, MutableMapping
+
+    builtin_str = str
+    str = str
+    bytes = bytes
+    basestring = (str, bytes)
+    numeric_types = (int, float)
+    integer_types = (int,)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/cookies.py

@@ -0,0 +1,549 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.cookies
+~~~~~~~~~~~~~~~~
+
+Compatibility code to be able to use `cookielib.CookieJar` with requests.
+
+requests.utils imports from here, so be careful with imports.
+"""
+
+import copy
+import time
+import calendar
+
+from ._internal_utils import to_native_string
+from .compat import cookielib, urlparse, urlunparse, Morsel, MutableMapping
+
+try:
+    import threading
+except ImportError:
+    import dummy_threading as threading
+
+
+class MockRequest(object):
+    """Wraps a `requests.Request` to mimic a `urllib2.Request`.
+
+    The code in `cookielib.CookieJar` expects this interface in order to correctly
+    manage cookie policies, i.e., determine whether a cookie can be set, given the
+    domains of the request and the cookie.
+
+    The original request object is read-only. The client is responsible for collecting
+    the new headers via `get_new_headers()` and interpreting them appropriately. You
+    probably want `get_cookie_header`, defined below.
+    """
+
+    def __init__(self, request):
+        self._r = request
+        self._new_headers = {}
+        self.type = urlparse(self._r.url).scheme
+
+    def get_type(self):
+        return self.type
+
+    def get_host(self):
+        return urlparse(self._r.url).netloc
+
+    def get_origin_req_host(self):
+        return self.get_host()
+
+    def get_full_url(self):
+        # Only return the response's URL if the user hadn't set the Host
+        # header
+        if not self._r.headers.get('Host'):
+            return self._r.url
+        # If they did set it, retrieve it and reconstruct the expected domain
+        host = to_native_string(self._r.headers['Host'], encoding='utf-8')
+        parsed = urlparse(self._r.url)
+        # Reconstruct the URL as we expect it
+        return urlunparse([
+            parsed.scheme, host, parsed.path, parsed.params, parsed.query,
+            parsed.fragment
+        ])
+
+    def is_unverifiable(self):
+        return True
+
+    def has_header(self, name):
+        return name in self._r.headers or name in self._new_headers
+
+    def get_header(self, name, default=None):
+        return self._r.headers.get(name, self._new_headers.get(name, default))
+
+    def add_header(self, key, val):
+        """cookielib has no legitimate use for this method; add it back if you find one."""
+        raise NotImplementedError("Cookie headers should be added with add_unredirected_header()")
+
+    def add_unredirected_header(self, name, value):
+        self._new_headers[name] = value
+
+    def get_new_headers(self):
+        return self._new_headers
+
+    @property
+    def unverifiable(self):
+        return self.is_unverifiable()
+
+    @property
+    def origin_req_host(self):
+        return self.get_origin_req_host()
+
+    @property
+    def host(self):
+        return self.get_host()
+
+
+class MockResponse(object):
+    """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
+
+    ...what? Basically, expose the parsed HTTP headers from the server response
+    the way `cookielib` expects to see them.
+    """
+
+    def __init__(self, headers):
+        """Make a MockResponse for `cookielib` to read.
+
+        :param headers: a httplib.HTTPMessage or analogous carrying the headers
+        """
+        self._headers = headers
+
+    def info(self):
+        return self._headers
+
+    def getheaders(self, name):
+        self._headers.getheaders(name)
+
+
+def extract_cookies_to_jar(jar, request, response):
+    """Extract the cookies from the response into a CookieJar.
+
+    :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
+    :param request: our own requests.Request object
+    :param response: urllib3.HTTPResponse object
+    """
+    if not (hasattr(response, '_original_response') and
+            response._original_response):
+        return
+    # the _original_response field is the wrapped httplib.HTTPResponse object,
+    req = MockRequest(request)
+    # pull out the HTTPMessage with the headers and put it in the mock:
+    res = MockResponse(response._original_response.msg)
+    jar.extract_cookies(res, req)
+
+
+def get_cookie_header(jar, request):
+    """
+    Produce an appropriate Cookie header string to be sent with `request`, or None.
+
+    :rtype: str
+    """
+    r = MockRequest(request)
+    jar.add_cookie_header(r)
+    return r.get_new_headers().get('Cookie')
+
+
+def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
+    """Unsets a cookie by name, by default over all domains and paths.
+
+    Wraps CookieJar.clear(), is O(n).
+    """
+    clearables = []
+    for cookie in cookiejar:
+        if cookie.name != name:
+            continue
+        if domain is not None and domain != cookie.domain:
+            continue
+        if path is not None and path != cookie.path:
+            continue
+        clearables.append((cookie.domain, cookie.path, cookie.name))
+
+    for domain, path, name in clearables:
+        cookiejar.clear(domain, path, name)
+
+
+class CookieConflictError(RuntimeError):
+    """There are two cookies that meet the criteria specified in the cookie jar.
+    Use .get and .set and include domain and path args in order to be more specific.
+    """
+
+
+class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
+    """Compatibility class; is a cookielib.CookieJar, but exposes a dict
+    interface.
+
+    This is the CookieJar we create by default for requests and sessions that
+    don't specify one, since some clients may expect response.cookies and
+    session.cookies to support dict operations.
+
+    Requests does not use the dict interface internally; it's just for
+    compatibility with external client code. All requests code should work
+    out of the box with externally provided instances of ``CookieJar``, e.g.
+    ``LWPCookieJar`` and ``FileCookieJar``.
+
+    Unlike a regular CookieJar, this class is pickleable.
+
+    .. warning:: dictionary operations that are normally O(1) may be O(n).
+    """
+
+    def get(self, name, default=None, domain=None, path=None):
+        """Dict-like get() that also supports optional domain and path args in
+        order to resolve naming collisions from using one cookie jar over
+        multiple domains.
+
+        .. warning:: operation is O(n), not O(1).
+        """
+        try:
+            return self._find_no_duplicates(name, domain, path)
+        except KeyError:
+            return default
+
+    def set(self, name, value, **kwargs):
+        """Dict-like set() that also supports optional domain and path args in
+        order to resolve naming collisions from using one cookie jar over
+        multiple domains.
+        """
+        # support client code that unsets cookies by assignment of a None value:
+        if value is None:
+            remove_cookie_by_name(self, name, domain=kwargs.get('domain'), path=kwargs.get('path'))
+            return
+
+        if isinstance(value, Morsel):
+            c = morsel_to_cookie(value)
+        else:
+            c = create_cookie(name, value, **kwargs)
+        self.set_cookie(c)
+        return c
+
+    def iterkeys(self):
+        """Dict-like iterkeys() that returns an iterator of names of cookies
+        from the jar.
+
+        .. seealso:: itervalues() and iteritems().
+        """
+        for cookie in iter(self):
+            yield cookie.name
+
+    def keys(self):
+        """Dict-like keys() that returns a list of names of cookies from the
+        jar.
+
+        .. seealso:: values() and items().
+        """
+        return list(self.iterkeys())
+
+    def itervalues(self):
+        """Dict-like itervalues() that returns an iterator of values of cookies
+        from the jar.
+
+        .. seealso:: iterkeys() and iteritems().
+        """
+        for cookie in iter(self):
+            yield cookie.value
+
+    def values(self):
+        """Dict-like values() that returns a list of values of cookies from the
+        jar.
+
+        .. seealso:: keys() and items().
+        """
+        return list(self.itervalues())
+
+    def iteritems(self):
+        """Dict-like iteritems() that returns an iterator of name-value tuples
+        from the jar.
+
+        .. seealso:: iterkeys() and itervalues().
+        """
+        for cookie in iter(self):
+            yield cookie.name, cookie.value
+
+    def items(self):
+        """Dict-like items() that returns a list of name-value tuples from the
+        jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
+        vanilla python dict of key value pairs.
+
+        .. seealso:: keys() and values().
+        """
+        return list(self.iteritems())
+
+    def list_domains(self):
+        """Utility method to list all the domains in the jar."""
+        domains = []
+        for cookie in iter(self):
+            if cookie.domain not in domains:
+                domains.append(cookie.domain)
+        return domains
+
+    def list_paths(self):
+        """Utility method to list all the paths in the jar."""
+        paths = []
+        for cookie in iter(self):
+            if cookie.path not in paths:
+                paths.append(cookie.path)
+        return paths
+
+    def multiple_domains(self):
+        """Returns True if there are multiple domains in the jar.
+        Returns False otherwise.
+
+        :rtype: bool
+        """
+        domains = []
+        for cookie in iter(self):
+            if cookie.domain is not None and cookie.domain in domains:
+                return True
+            domains.append(cookie.domain)
+        return False  # there is only one domain in jar
+
+    def get_dict(self, domain=None, path=None):
+        """Takes as an argument an optional domain and path and returns a plain
+        old Python dict of name-value pairs of cookies that meet the
+        requirements.
+
+        :rtype: dict
+        """
+        dictionary = {}
+        for cookie in iter(self):
+            if (
+                (domain is None or cookie.domain == domain) and
+                (path is None or cookie.path == path)
+            ):
+                dictionary[cookie.name] = cookie.value
+        return dictionary
+
+    def __contains__(self, name):
+        try:
+            return super(RequestsCookieJar, self).__contains__(name)
+        except CookieConflictError:
+            return True
+
+    def __getitem__(self, name):
+        """Dict-like __getitem__() for compatibility with client code. Throws
+        exception if there are more than one cookie with name. In that case,
+        use the more explicit get() method instead.
+
+        .. warning:: operation is O(n), not O(1).
+        """
+        return self._find_no_duplicates(name)
+
+    def __setitem__(self, name, value):
+        """Dict-like __setitem__ for compatibility with client code. Throws
+        exception if there is already a cookie of that name in the jar. In that
+        case, use the more explicit set() method instead.
+        """
+        self.set(name, value)
+
+    def __delitem__(self, name):
+        """Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
+        ``remove_cookie_by_name()``.
+        """
+        remove_cookie_by_name(self, name)
+
+    def set_cookie(self, cookie, *args, **kwargs):
+        if hasattr(cookie.value, 'startswith') and cookie.value.startswith('"') and cookie.value.endswith('"'):
+            cookie.value = cookie.value.replace('\\"', '')
+        return super(RequestsCookieJar, self).set_cookie(cookie, *args, **kwargs)
+
+    def update(self, other):
+        """Updates this jar with cookies from another CookieJar or dict-like"""
+        if isinstance(other, cookielib.CookieJar):
+            for cookie in other:
+                self.set_cookie(copy.copy(cookie))
+        else:
+            super(RequestsCookieJar, self).update(other)
+
+    def _find(self, name, domain=None, path=None):
+        """Requests uses this method internally to get cookie values.
+
+        If there are conflicting cookies, _find arbitrarily chooses one.
+        See _find_no_duplicates if you want an exception thrown if there are
+        conflicting cookies.
+
+        :param name: a string containing name of cookie
+        :param domain: (optional) string containing domain of cookie
+        :param path: (optional) string containing path of cookie
+        :return: cookie.value
+        """
+        for cookie in iter(self):
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        return cookie.value
+
+        raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
+
+    def _find_no_duplicates(self, name, domain=None, path=None):
+        """Both ``__get_item__`` and ``get`` call this function: it's never
+        used elsewhere in Requests.
+
+        :param name: a string containing name of cookie
+        :param domain: (optional) string containing domain of cookie
+        :param path: (optional) string containing path of cookie
+        :raises KeyError: if cookie is not found
+        :raises CookieConflictError: if there are multiple cookies
+            that match name and optionally domain and path
+        :return: cookie.value
+        """
+        toReturn = None
+        for cookie in iter(self):
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        if toReturn is not None:  # if there are multiple cookies that meet passed in criteria
+                            raise CookieConflictError('There are multiple cookies with name, %r' % (name))
+                        toReturn = cookie.value  # we will eventually return this as long as no cookie conflict
+
+        if toReturn:
+            return toReturn
+        raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
+
+    def __getstate__(self):
+        """Unlike a normal CookieJar, this class is pickleable."""
+        state = self.__dict__.copy()
+        # remove the unpickleable RLock object
+        state.pop('_cookies_lock')
+        return state
+
+    def __setstate__(self, state):
+        """Unlike a normal CookieJar, this class is pickleable."""
+        self.__dict__.update(state)
+        if '_cookies_lock' not in self.__dict__:
+            self._cookies_lock = threading.RLock()
+
+    def copy(self):
+        """Return a copy of this RequestsCookieJar."""
+        new_cj = RequestsCookieJar()
+        new_cj.set_policy(self.get_policy())
+        new_cj.update(self)
+        return new_cj
+
+    def get_policy(self):
+        """Return the CookiePolicy instance used."""
+        return self._policy
+
+
+def _copy_cookie_jar(jar):
+    if jar is None:
+        return None
+
+    if hasattr(jar, 'copy'):
+        # We're dealing with an instance of RequestsCookieJar
+        return jar.copy()
+    # We're dealing with a generic CookieJar instance
+    new_jar = copy.copy(jar)
+    new_jar.clear()
+    for cookie in jar:
+        new_jar.set_cookie(copy.copy(cookie))
+    return new_jar
+
+
+def create_cookie(name, value, **kwargs):
+    """Make a cookie from underspecified parameters.
+
+    By default, the pair of `name` and `value` will be set for the domain ''
+    and sent on every request (this is sometimes called a "supercookie").
+    """
+    result = {
+        'version': 0,
+        'name': name,
+        'value': value,
+        'port': None,
+        'domain': '',
+        'path': '/',
+        'secure': False,
+        'expires': None,
+        'discard': True,
+        'comment': None,
+        'comment_url': None,
+        'rest': {'HttpOnly': None},
+        'rfc2109': False,
+    }
+
+    badargs = set(kwargs) - set(result)
+    if badargs:
+        err = 'create_cookie() got unexpected keyword arguments: %s'
+        raise TypeError(err % list(badargs))
+
+    result.update(kwargs)
+    result['port_specified'] = bool(result['port'])
+    result['domain_specified'] = bool(result['domain'])
+    result['domain_initial_dot'] = result['domain'].startswith('.')
+    result['path_specified'] = bool(result['path'])
+
+    return cookielib.Cookie(**result)
+
+
+def morsel_to_cookie(morsel):
+    """Convert a Morsel object into a Cookie containing the one k/v pair."""
+
+    expires = None
+    if morsel['max-age']:
+        try:
+            expires = int(time.time() + int(morsel['max-age']))
+        except ValueError:
+            raise TypeError('max-age: %s must be integer' % morsel['max-age'])
+    elif morsel['expires']:
+        time_template = '%a, %d-%b-%Y %H:%M:%S GMT'
+        expires = calendar.timegm(
+            time.strptime(morsel['expires'], time_template)
+        )
+    return create_cookie(
+        comment=morsel['comment'],
+        comment_url=bool(morsel['comment']),
+        discard=False,
+        domain=morsel['domain'],
+        expires=expires,
+        name=morsel.key,
+        path=morsel['path'],
+        port=None,
+        rest={'HttpOnly': morsel['httponly']},
+        rfc2109=False,
+        secure=bool(morsel['secure']),
+        value=morsel.value,
+        version=morsel['version'] or 0,
+    )
+
+
+def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    :param cookiejar: (optional) A cookiejar to add the cookies to.
+    :param overwrite: (optional) If False, will not replace cookies
+        already in the jar with new ones.
+    :rtype: CookieJar
+    """
+    if cookiejar is None:
+        cookiejar = RequestsCookieJar()
+
+    if cookie_dict is not None:
+        names_from_jar = [cookie.name for cookie in cookiejar]
+        for name in cookie_dict:
+            if overwrite or (name not in names_from_jar):
+                cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
+
+    return cookiejar
+
+
+def merge_cookies(cookiejar, cookies):
+    """Add cookies to cookiejar and returns a merged CookieJar.
+
+    :param cookiejar: CookieJar object to add the cookies to.
+    :param cookies: Dictionary or CookieJar object to be added.
+    :rtype: CookieJar
+    """
+    if not isinstance(cookiejar, cookielib.CookieJar):
+        raise ValueError('You can only merge into CookieJar')
+
+    if isinstance(cookies, dict):
+        cookiejar = cookiejar_from_dict(
+            cookies, cookiejar=cookiejar, overwrite=False)
+    elif isinstance(cookies, cookielib.CookieJar):
+        try:
+            cookiejar.update(cookies)
+        except AttributeError:
+            for cookie_in_jar in cookies:
+                cookiejar.set_cookie(cookie_in_jar)
+
+    return cookiejar

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/exceptions.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.exceptions
+~~~~~~~~~~~~~~~~~~~
+
+This module contains the set of Requests' exceptions.
+"""
+from urllib3.exceptions import HTTPError as BaseHTTPError
+
+
+class RequestException(IOError):
+    """There was an ambiguous exception that occurred while handling your
+    request.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize RequestException with `request` and `response` objects."""
+        response = kwargs.pop('response', None)
+        self.response = response
+        self.request = kwargs.pop('request', None)
+        if (response is not None and not self.request and
+                hasattr(response, 'request')):
+            self.request = self.response.request
+        super(RequestException, self).__init__(*args, **kwargs)
+
+
+class HTTPError(RequestException):
+    """An HTTP error occurred."""
+
+
+class ConnectionError(RequestException):
+    """A Connection error occurred."""
+
+
+class ProxyError(ConnectionError):
+    """A proxy error occurred."""
+
+
+class SSLError(ConnectionError):
+    """An SSL error occurred."""
+
+
+class Timeout(RequestException):
+    """The request timed out.
+
+    Catching this error will catch both
+    :exc:`~requests.exceptions.ConnectTimeout` and
+    :exc:`~requests.exceptions.ReadTimeout` errors.
+    """
+
+
+class ConnectTimeout(ConnectionError, Timeout):
+    """The request timed out while trying to connect to the remote server.
+
+    Requests that produced this error are safe to retry.
+    """
+
+
+class ReadTimeout(Timeout):
+    """The server did not send any data in the allotted amount of time."""
+
+
+class URLRequired(RequestException):
+    """A valid URL is required to make a request."""
+
+
+class TooManyRedirects(RequestException):
+    """Too many redirects."""
+
+
+class MissingSchema(RequestException, ValueError):
+    """The URL schema (e.g. http or https) is missing."""
+
+
+class InvalidSchema(RequestException, ValueError):
+    """See defaults.py for valid schemas."""
+
+
+class InvalidURL(RequestException, ValueError):
+    """The URL provided was somehow invalid."""
+
+
+class InvalidHeader(RequestException, ValueError):
+    """The header value provided was somehow invalid."""
+
+
+class InvalidProxyURL(InvalidURL):
+    """The proxy URL provided is invalid."""
+
+
+class ChunkedEncodingError(RequestException):
+    """The server declared chunked encoding but sent an invalid chunk."""
+
+
+class ContentDecodingError(RequestException, BaseHTTPError):
+    """Failed to decode response content"""
+
+
+class StreamConsumedError(RequestException, TypeError):
+    """The content for this response was already consumed"""
+
+
+class RetryError(RequestException):
+    """Custom retries logic failed"""
+
+
+class UnrewindableBodyError(RequestException):
+    """Requests encountered an error when trying to rewind a body"""
+
+# Warnings
+
+
+class RequestsWarning(Warning):
+    """Base warning for Requests."""
+    pass
+
+
+class FileModeWarning(RequestsWarning, DeprecationWarning):
+    """A file was opened in text mode, but Requests determined its binary length."""
+    pass
+
+
+class RequestsDependencyWarning(RequestsWarning):
+    """An imported dependency doesn't match the expected version range."""
+    pass

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/help.py

@@ -0,0 +1,119 @@
+"""Module containing bug report helper(s)."""
+from __future__ import print_function
+
+import json
+import platform
+import sys
+import ssl
+
+import idna
+import urllib3
+import chardet
+
+from . import __version__ as requests_version
+
+try:
+    from urllib3.contrib import pyopenssl
+except ImportError:
+    pyopenssl = None
+    OpenSSL = None
+    cryptography = None
+else:
+    import OpenSSL
+    import cryptography
+
+
+def _implementation():
+    """Return a dict with the Python implementation and version.
+
+    Provide both the name and the version of the Python implementation
+    currently running. For example, on CPython 2.7.5 it will return
+    {'name': 'CPython', 'version': '2.7.5'}.
+
+    This function works best on CPython and PyPy: in particular, it probably
+    doesn't work for Jython or IronPython. Future investigation should be done
+    to work out the correct shape of the code for those platforms.
+    """
+    implementation = platform.python_implementation()
+
+    if implementation == 'CPython':
+        implementation_version = platform.python_version()
+    elif implementation == 'PyPy':
+        implementation_version = '%s.%s.%s' % (sys.pypy_version_info.major,
+                                               sys.pypy_version_info.minor,
+                                               sys.pypy_version_info.micro)
+        if sys.pypy_version_info.releaselevel != 'final':
+            implementation_version = ''.join([
+                implementation_version, sys.pypy_version_info.releaselevel
+            ])
+    elif implementation == 'Jython':
+        implementation_version = platform.python_version()  # Complete Guess
+    elif implementation == 'IronPython':
+        implementation_version = platform.python_version()  # Complete Guess
+    else:
+        implementation_version = 'Unknown'
+
+    return {'name': implementation, 'version': implementation_version}
+
+
+def info():
+    """Generate information for a bug report."""
+    try:
+        platform_info = {
+            'system': platform.system(),
+            'release': platform.release(),
+        }
+    except IOError:
+        platform_info = {
+            'system': 'Unknown',
+            'release': 'Unknown',
+        }
+
+    implementation_info = _implementation()
+    urllib3_info = {'version': urllib3.__version__}
+    chardet_info = {'version': chardet.__version__}
+
+    pyopenssl_info = {
+        'version': None,
+        'openssl_version': '',
+    }
+    if OpenSSL:
+        pyopenssl_info = {
+            'version': OpenSSL.__version__,
+            'openssl_version': '%x' % OpenSSL.SSL.OPENSSL_VERSION_NUMBER,
+        }
+    cryptography_info = {
+        'version': getattr(cryptography, '__version__', ''),
+    }
+    idna_info = {
+        'version': getattr(idna, '__version__', ''),
+    }
+
+    system_ssl = ssl.OPENSSL_VERSION_NUMBER
+    system_ssl_info = {
+        'version': '%x' % system_ssl if system_ssl is not None else ''
+    }
+
+    return {
+        'platform': platform_info,
+        'implementation': implementation_info,
+        'system_ssl': system_ssl_info,
+        'using_pyopenssl': pyopenssl is not None,
+        'pyOpenSSL': pyopenssl_info,
+        'urllib3': urllib3_info,
+        'chardet': chardet_info,
+        'cryptography': cryptography_info,
+        'idna': idna_info,
+        'requests': {
+            'version': requests_version,
+        },
+    }
+
+
+def main():
+    """Pretty-print the bug information as JSON."""
+    print(json.dumps(info(), sort_keys=True, indent=2))
+
+
+if __name__ == '__main__':
+    main()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/hooks.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.hooks
+~~~~~~~~~~~~~~
+
+This module provides the capabilities for the Requests hooks system.
+
+Available hooks:
+
+``response``:
+    The response generated from a Request.
+"""
+HOOKS = ['response']
+
+
+def default_hooks():
+    return {event: [] for event in HOOKS}
+
+# TODO: response is the only one
+
+
+def dispatch_hook(key, hooks, hook_data, **kwargs):
+    """Dispatches a hook dictionary on a given piece of data."""
+    hooks = hooks or {}
+    hooks = hooks.get(key)
+    if hooks:
+        if hasattr(hooks, '__call__'):
+            hooks = [hooks]
+        for hook in hooks:
+            _hook_data = hook(hook_data, **kwargs)
+            if _hook_data is not None:
+                hook_data = _hook_data
+    return hook_data

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/requests/models.py

@@ -0,0 +1,953 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.models
+~~~~~~~~~~~~~~~
+
+This module contains the primary objects that power Requests.
+"""
+
+import datetime
+import sys
+
+# Import encoding now, to avoid implicit import later.
+# Implicit import within threads may cause LookupError when standard library is in a ZIP,
+# such as in Embedded Python. See https://github.com/requests/requests/issues/3578.
+import encodings.idna
+
+from urllib3.fields import RequestField
+from urllib3.filepost import encode_multipart_formdata
+from urllib3.util import parse_url
+from urllib3.exceptions import (
+    DecodeError, ReadTimeoutError, ProtocolError, LocationParseError)
+
+from io import UnsupportedOperation
+from .hooks import default_hooks
+from .structures import CaseInsensitiveDict
+
+from .auth import HTTPBasicAuth
+from .cookies import cookiejar_from_dict, get_cookie_header, _copy_cookie_jar
+from .exceptions import (
+    HTTPError, MissingSchema, InvalidURL, ChunkedEncodingError,
+    ContentDecodingError, ConnectionError, StreamConsumedError)
+from ._internal_utils import to_native_string, unicode_is_ascii
+from .utils import (
+    guess_filename, get_auth_from_url, requote_uri,
+    stream_decode_response_unicode, to_key_val_list, parse_header_links,
+    iter_slices, guess_json_utf, super_len, check_header_validity)
+from .compat import (
+    Callable, Mapping,
+    cookielib, urlunparse, urlsplit, urlencode, str, bytes,
+    is_py2, chardet, builtin_str, basestring)
+from .compat import json as complexjson
+from .status_codes import codes
+
+#: The set of HTTP status codes that indicate an automatically
+#: processable redirect.
+REDIRECT_STATI = (
+    codes.moved,               # 301
+    codes.found,               # 302
+    codes.other,               # 303
+    codes.temporary_redirect,  # 307
+    codes.permanent_redirect,  # 308
+)
+
+DEFAULT_REDIRECT_LIMIT = 30
+CONTENT_CHUNK_SIZE = 10 * 1024
+ITER_CHUNK_SIZE = 512
+
+
+class RequestEncodingMixin(object):
+    @property
+    def path_url(self):
+        """Build the path URL to use."""
+
+        url = []
+
+        p = urlsplit(self.url)
+
+        path = p.path
+        if not path:
+            path = '/'
+
+        url.append(path)
+
+        query = p.query
+        if query:
+            url.append('?')
+            url.append(query)
+
+        return ''.join(url)
+
+    @staticmethod
+    def _encode_params(data):
+        """Encode parameters in a piece of data.
+
+        Will successfully encode parameters when passed as a dict or a list of
+        2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
+        if parameters are supplied as a dict.
+        """
+
+        if isinstance(data, (str, bytes)):
+            return data
+        elif hasattr(data, 'read'):
+            return data
+        elif hasattr(data, '__iter__'):
+            result = []
+            for k, vs in to_key_val_list(data):
+                if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
+                    vs = [vs]
+                for v in vs:
+                    if v is not None:
+                        result.append(
+                            (k.encode('utf-8') if isinstance(k, str) else k,
+                             v.encode('utf-8') if isinstance(v, str) else v))
+            return urlencode(result, doseq=True)
+        else:
+            return data
+
+    @staticmethod
+    def _encode_files(files, data):
+        """Build the body for a multipart/form-data request.
+
+        Will successfully encode files when passed as a dict or a list of
+        tuples. Order is retained if data is a list of tuples but arbitrary
+        if parameters are supplied as a dict.
+        The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
+        or 4-tuples (filename, fileobj, contentype, custom_headers).
+        """
+        if (not files):
+            raise ValueError("Files must be provided.")
+        elif isinstance(data, basestring):
+            raise ValueError("Data must not be a string.")
+
+        new_fields = []
+        fields = to_key_val_list(data or {})
+        files = to_key_val_list(files or {})
+
+        for field, val in fields:
+            if isinstance(val, basestring) or not hasattr(val, '__iter__'):
+                val = [val]
+            for v in val:
+                if v is not None:
+                    # Don't call str() on bytestrings: in Py3 it all goes wrong.
+                    if not isinstance(v, bytes):
+                        v = str(v)
+
+                    new_fields.append(
+                        (field.decode('utf-8') if isinstance(field, bytes) else field,
+                         v.encode('utf-8') if isinstance(v, str) else v))
+
+        for (k, v) in files:
+            # support for explicit filename
+            ft = None
+            fh = None
+            if isinstance(v, (tuple, list)):
+                if len(v) == 2:
+                    fn, fp = v
+                elif len(v) == 3:
+                    fn, fp, ft = v
+                else:
+                    fn, fp, ft, fh = v
+            else:
+                fn = guess_filename(v) or k
+                fp = v
+
+            if isinstance(fp, (str, bytes, bytearray)):
+                fdata = fp
+            elif hasattr(fp, 'read'):
+                fdata = fp.read()
+            elif fp is None:
+                continue
+            else:
+                fdata = fp
+
+            rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
+            rf.make_multipart(content_type=ft)
+            new_fields.append(rf)
+
+        body, content_type = encode_multipart_formdata(new_fields)
+
+        return body, content_type
+
+
+class RequestHooksMixin(object):
+    def register_hook(self, event, hook):
+        """Properly register a hook."""
+
+        if event not in self.hooks:
+            raise ValueError('Unsupported event specified, with event name "%s"' % (event))
+
+        if isinstance(hook, Callable):
+            self.hooks[event].append(hook)
+        elif hasattr(hook, '__iter__'):
+            self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
+
+    def deregister_hook(self, event, hook):
+        """Deregister a previously registered hook.
+        Returns True if the hook existed, False if not.
+        """
+
+        try:
+            self.hooks[event].remove(hook)
+            return True
+        except ValueError:
+            return False
+
+
+class Request(RequestHooksMixin):
+    """A user-created :class:`Request <Request>` object.
+
+    Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
+
+    :param method: HTTP method to use.
+    :param url: URL to send.
+    :param headers: dictionary of headers to send.
+    :param files: dictionary of {filename: fileobject} files to multipart upload.
+    :param data: the body to attach to the request. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
+    :param json: json for the body to attach to the request (if files or data is not specified).
+    :param params: URL parameters to append to the URL. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
+    :param auth: Auth handler or (user, pass) tuple.
+    :param cookies: dictionary or CookieJar of cookies to attach to this request.
+    :param hooks: dictionary of callback hooks, for internal usage.
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
+      >>> req.prepare()
+      <PreparedRequest [GET]>
+    """
+
+    def __init__(self,
+            method=None, url=None, headers=None, files=None, data=None,
+            params=None, auth=None, cookies=None, hooks=None, json=None):
+
+        # Default empty dicts for dict params.
+        data = [] if data is None else data
+        files = [] if files is None else files
+        headers = {} if headers is None else headers
+        params = {} if params is None else params
+        hooks = {} if hooks is None else hooks
+
+        self.hooks = default_hooks()
+        for (k, v) in list(hooks.items()):
+            self.register_hook(event=k, hook=v)
+
+        self.method = method
+        self.url = url
+        self.headers = headers
+        self.files = files
+        self.data = data
+        self.json = json
+        self.params = params
+        self.auth = auth
+        self.cookies = cookies
+
+    def __repr__(self):
+        return '<Request [%s]>' % (self.method)
+
+    def prepare(self):
+        """Constructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it."""
+        p = PreparedRequest()
+        p.prepare(
+            method=self.method,
+            url=self.url,
+            headers=self.headers,
+            files=self.files,
+            data=self.data,
+            json=self.json,
+            params=self.params,
+            auth=self.auth,
+            cookies=self.cookies,
+            hooks=self.hooks,
+        )
+        return p
+
+
+class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
+    """The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
+    containing the exact bytes that will be sent to the server.
+
+    Generated from either a :class:`Request <Request>` object or manually.
+
+    Usage::
+
+      >>> import requests
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
+      >>> r = req.prepare()
+      <PreparedRequest [GET]>
+
+      >>> s = requests.Session()
+      >>> s.send(r)
+      <Response [200]>
+    """
+
+    def __init__(self):
+        #: HTTP verb to send to the server.
+        self.method = None
+        #: HTTP URL to send the request to.
+        self.url = None
+        #: dictionary of HTTP headers.
+        self.headers = None
+        # The `CookieJar` used to create the Cookie header will be stored here
+        # after prepare_cookies is called
+        self._cookies = None
+        #: request body to send to the server.
+        self.body = None
+        #: dictionary of callback hooks, for internal usage.
+        self.hooks = default_hooks()
+        #: integer denoting starting position of a readable file-like body.
+        self._body_position = None
+
+    def prepare(self,
+            method=None, url=None, headers=None, files=None, data=None,
+            params=None, auth=None, cookies=None, hooks=None, json=None):
+        """Prepares the entire request with the given parameters."""
+
+        self.prepare_method(method)
+        self.prepare_url(url, params)
+        self.prepare_headers(headers)
+        self.prepare_cookies(cookies)
+        self.prepare_body(data, files, json)
+        self.prepare_auth(auth, url)
+
+        # Note that prepare_auth must be last to enable authentication schemes
+        # such as OAuth to work on a fully prepared request.
+
+        # This MUST go after prepare_auth. Authenticators could add a hook
+        self.prepare_hooks(hooks)
+
+    def __repr__(self):
+        return '<PreparedRequest [%s]>' % (self.method)
+
+    def copy(self):
+        p = PreparedRequest()
+        p.method = self.method
+        p.url = self.url
+        p.headers = self.headers.copy() if self.headers is not None else None
+        p._cookies = _copy_cookie_jar(self._cookies)
+        p.body = self.body
+        p.hooks = self.hooks
+        p._body_position = self._body_position
+        return p
+
+    def prepare_method(self, method):
+        """Prepares the given HTTP method."""
+        self.method = method
+        if self.method is not None:
+            self.method = to_native_string(self.method.upper())
+
+    @staticmethod
+    def _get_idna_encoded_host(host):
+        import idna
+
+        try:
+            host = idna.encode(host, uts46=True).decode('utf-8')
+        except idna.IDNAError:
+            raise UnicodeError
+        return host
+
+    def prepare_url(self, url, params):
+        """Prepares the given HTTP URL."""
+        #: Accept objects that have string representations.
+        #: We're unable to blindly call unicode/str functions
+        #: as this will include the bytestring indicator (b'')
+        #: on python 3.x.
+        #: https://github.com/requests/requests/pull/2238
+        if isinstance(url, bytes):
+            url = url.decode('utf8')
+        else:
+            url = unicode(url) if is_py2 else str(url)
+
+        # Remove leading whitespaces from url
+        url = url.lstrip()
+
+        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
+        # `data` etc to work around exceptions from `url_parse`, which
+        # handles RFC 3986 only.
+        if ':' in url and not url.lower().startswith('http'):
+            self.url = url
+            return
+
+        # Support for unicode domain names and paths.
+        try:
+            scheme, auth, host, port, path, query, fragment = parse_url(url)
+        except LocationParseError as e:
+            raise InvalidURL(*e.args)
+
+        if not scheme:
+            error = ("Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?")
+            error = error.format(to_native_string(url, 'utf8'))
+
+            raise MissingSchema(error)
+
+        if not host:
+            raise InvalidURL("Invalid URL %r: No host supplied" % url)
+
+        # In general, we want to try IDNA encoding the hostname if the string contains
+        # non-ASCII characters. This allows users to automatically get the correct IDNA
+        # behaviour. For strings containing only ASCII characters, we need to also verify
+        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
+        if not unicode_is_ascii(host):
+            try:
+                host = self._get_idna_encoded_host(host)
+            except UnicodeError:
+                raise InvalidURL('URL has an invalid label.')
+        elif host.startswith(u'*'):
+            raise InvalidURL('URL has an invalid label.')
+
+        # Carefully reconstruct the network location
+        netloc = auth or ''
+        if netloc:
+            netloc += '@'
+        netloc += host
+        if port:
+            netloc += ':' + str(port)
+
+        # Bare domains aren't valid URLs.
+        if not path:
+            path = '/'
+
+        if is_py2:
+            if isinstance(scheme, str):
+                scheme = scheme.encode('utf-8')
+            if isinstance(netloc, str):
+                netloc = netloc.encode('utf-8')
+            if isinstance(path, str):
+                path = path.encode('utf-8')
+            if isinstance(query, str):
+                query = query.encode('utf-8')
+            if isinstance(fragment, str):
+                fragment = fragment.encode('utf-8')
+
+        if isinstance(params, (str, bytes)):
+            params = to_native_string(params)
+
+        enc_params = self._encode_params(params)
+        if enc_params:
+            if query:
+                query = '%s&%s' % (query, enc_params)
+            else:
+                query = enc_params
+
+        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
+        self.url = url
+
+    def prepare_headers(self, headers):
+        """Prepares the given HTTP headers."""
+
+        self.headers = CaseInsensitiveDict()
+        if headers:
+            for header in headers.items():
+                # Raise exception on invalid header value.
+                check_header_validity(header)
+                name, value = header
+                self.headers[to_native_string(name)] = value
+
+    def prepare_body(self, data, files, json=None):
+        """Prepares the given HTTP body data."""
+
+        # Check if file, fo, generator, iterator.
+        # If not, run through normal process.
+
+        # Nottin' on you.
+        body = None
+        content_type = None
+
+        if not data and json is not None:
+            # urllib3 requires a bytes-like body. Python 2's json.dumps
+            # provides this natively, but Python 3 gives a Unicode string.
+            content_type = 'application/json'
+            body = complexjson.dumps(json)
+            if not isinstance(body, bytes):
+                body = body.encode('utf-8')
+
+        is_stream = all([
+            hasattr(data, '__iter__'),
+            not isinstance(data, (basestring, list, tuple, Mapping))
+        ])
+
+        try:
+            length = super_len(data)
+        except (TypeError, AttributeError, UnsupportedOperation):
+            length = None
+
+        if is_stream:
+            body = data
+
+            if getattr(body, 'tell', None) is not None:
+                # Record the current file position before reading.
+                # This will allow us to rewind a file in the event
+                # of a redirect.
+                try:
+                    self._body_position = body.tell()
+                except (IOError, OSError):
+                    # This differentiates from None, allowing us to catch
+                    # a failed `tell()` later when trying to rewind the body
+                    self._body_position = object()
+
+            if files:
+                raise NotImplementedError('Streamed bodies and files are mutually exclusive.')
+
+            if length:
+                self.headers['Content-Length'] = builtin_str(length)
+            else:
+                self.headers['Transfer-Encoding'] = 'chunked'
+        else:
+            # Multi-part file uploads.
+            if files:
+                (body, content_type) = self._encode_files(files, data)
+            else:
+                if data:
+                    body = self._encode_params(data)
+                    if isinstance(data, basestring) or hasattr(data, 'read'):
+                        content_type = None
+                    else:
+                        content_type = 'application/x-www-form-urlencoded'
+
+            self.prepare_content_length(body)
+
+            # Add content-type if it wasn't explicitly provided.
+            if content_type and ('content-type' not in self.headers):
+                self.headers['Content-Type'] = content_type
+
+        self.body = body
+
+    def prepare_content_length(self, body):
+        """Prepare Content-Length header based on request method and body"""
+        if body is not None:
+            length = super_len(body)
+            if length:
+                # If length exists, set it. Otherwise, we fallback
+                # to Transfer-Encoding: chunked.
+                self.headers['Content-Length'] = builtin_str(length)
+        elif self.method not in ('GET', 'HEAD') and self.headers.get('Content-Length') is None:
+            # Set Content-Length to 0 for methods that can have a body
+            # but don't provide one. (i.e. not GET or HEAD)
+            self.headers['Content-Length'] = '0'
+
+    def prepare_auth(self, auth, url=''):
+        """Prepares the given HTTP auth data."""
+
+        # If no Auth is explicitly provided, extract it from the URL first.
+        if auth is None:
+            url_auth = get_auth_from_url(self.url)
+            auth = url_auth if any(url_auth) else None
+
+        if auth:
+            if isinstance(auth, tuple) and len(auth) == 2:
+                # special-case basic HTTP auth
+                auth = HTTPBasicAuth(*auth)
+
+            # Allow auth to make its changes.
+            r = auth(self)
+
+            # Update self to reflect the auth changes.
+            self.__dict__.update(r.__dict__)
+
+            # Recompute Content-Length
+            self.prepare_content_length(self.body)
+
+    def prepare_cookies(self, cookies):
+        """Prepares the given HTTP cookie data.
+
+        This function eventually generates a ``Cookie`` header from the
+        given cookies using cookielib. Due to cookielib's design, the header
+        will not be regenerated if it already exists, meaning this function
+        can only be called once for the life of the
+        :class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
+        to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
+        header is removed beforehand.
+        """
+        if isinstance(cookies, cookielib.CookieJar):
+            self._cookies = cookies
+        else:
+            self._cookies = cookiejar_from_dict(cookies)
+
+        cookie_header = get_cookie_header(self._cookies, self)
+        if cookie_header is not None:
+            self.headers['Cookie'] = cookie_header
+
+    def prepare_hooks(self, hooks):
+        """Prepares the given hooks."""
+        # hooks can be passed as None to the prepare method and to this
+        # method. To prevent iterating over None, simply use an empty list
+        # if hooks is False-y
+        hooks = hooks or []
+        for event in hooks:
+            self.register_hook(event, hooks[event])
+
+
+class Response(object):
+    """The :class:`Response <Response>` object, which contains a
+    server's response to an HTTP request.
+    """
+
+    __attrs__ = [
+        '_content', 'status_code', 'headers', 'url', 'history',
+        'encoding', 'reason', 'cookies', 'elapsed', 'request'
+    ]
+
+    def __init__(self):
+        self._content = False
+        self._content_consumed = False
+        self._next = None
+
+        #: Integer Code of responded HTTP Status, e.g. 404 or 200.
+        self.status_code = None
+
+        #: Case-insensitive Dictionary of Response Headers.
+        #: For example, ``headers['content-encoding']`` will return the
+        #: value of a ``'Content-Encoding'`` response header.
+        self.headers = CaseInsensitiveDict()
+
+        #: File-like object representation of response (for advanced usage).
+        #: Use of ``raw`` requires that ``stream=True`` be set on the request.
+        # This requirement does not apply for use internally to Requests.
+        self.raw = None
+
+        #: Final URL location of Response.
+        self.url = None
+
+        #: Encoding to decode with when accessing r.text.
+        self.encoding = None
+
+        #: A list of :class:`Response <Response>` objects from
+        #: the history of the Request. Any redirect responses will end
+        #: up here. The list is sorted from the oldest to the most recent request.
+        self.history = []
+
+        #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
+        self.reason = None
+
+        #: A CookieJar of Cookies the server sent back.
+        self.cookies = cookiejar_from_dict({})
+
+        #: The amount of time elapsed between sending the request
+        #: and the arrival of the response (as a timedelta).
+        #: This property specifically measures the time taken between sending
+        #: the first byte of the request and finishing parsing the headers. It
+        #: is therefore unaffected by consuming the response content or the
+        #: value of the ``stream`` keyword argument.
+        self.elapsed = datetime.timedelta(0)
+
+        #: The :class:`PreparedRequest <PreparedRequest>` object to which this
+        #: is a response.
+        self.request = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __getstate__(self):
+        # Consume everything; accessing the content attribute makes
+        # sure the content has been fully read.
+        if not self._content_consumed:
+            self.content
+
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+        # pickled objects do not have .raw
+        setattr(self, '_content_consumed', True)
+        setattr(self, 'raw', None)
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+    def __bool__(self):
+        """Returns True if :attr:`status_code` is less than 400.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code, is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        return self.ok
+
+    def __nonzero__(self):
+        """Returns True if :attr:`status_code` is less than 400.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code, is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        return self.ok
+
+    def __iter__(self):
+        """Allows you to use a response as an iterator."""
+        return self.iter_content(128)
+
+    @property
+    def ok(self):
+        """Returns True if :attr:`status_code` is less than 400, False if not.
+
+        This attribute checks if the status code of the response is between
+        400 and 600 to see if there was a client error or a server error. If
+        the status code is between 200 and 400, this will return True. This
+        is **not** a check to see if the response code is ``200 OK``.
+        """
+        try:
+            self.raise_for_status()
+        except HTTPError:
+            return False
+        return True
+
+    @property
+    def is_redirect(self):
+        """True if this Response is a well-formed HTTP redirect that could have
+        been processed automatically (by :meth:`Session.resolve_redirects`).
+        """
+        return ('location' in self.headers and self.status_code in REDIRECT_STATI)
+
+    @property
+    def is_permanent_redirect(self):
+        """True if this Response one of the permanent versions of redirect."""
+        return ('location' in self.headers and self.status_code in (codes.moved_permanently, codes.permanent_redirect))
+
+    @property
+    def next(self):
+        """Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
+        return self._next
+
+    @property
+    def apparent_encoding(self):
+        """The apparent encoding, provided by the chardet library."""
+        return chardet.detect(self.content)['encoding']
+
+    def iter_content(self, chunk_size=1, decode_unicode=False):
+        """Iterates over the response data.  When stream=True is set on the
+        request, this avoids reading the content at once into memory for
+        large responses.  The chunk size is the number of bytes it should
+        read into memory.  This is not necessarily the length of each item
+        returned as decoding can take place.
+
+        chunk_size must be of type int or None. A value of None will
+        function differently depending on the value of `stream`.
+        stream=True will read data as it arrives in whatever size the
+        chunks are received. If stream=False, data is returned as
+        a single chunk.
+
+        If decode_unicode is True, content will be decoded using the best
+        available encoding based on the response.
+        """
+
+        def generate():
+            # Special case for urllib3.
+            if hasattr(self.raw, 'stream'):
+                try:
+                    for chunk in self.raw.stream(chunk_size, decode_content=True):
+                        yield chunk
+                except ProtocolError as e:
+                    raise ChunkedEncodingError(e)
+                except DecodeError as e:
+                    raise ContentDecodingError(e)
+                except ReadTimeoutError as e:
+                    raise ConnectionError(e)
+            else:
+                # Standard file-like object.
+                while True:
+                    chunk = self.raw.read(chunk_size)
+                    if not chunk:
+                        break
+                    yield chunk
+
+            self._content_consumed = True
+
+        if self._content_consumed and isinstance(self._content, bool):
+            raise StreamConsumedError()
+        elif chunk_size is not None and not isinstance(chunk_size, int):
+            raise TypeError("chunk_size must be an int, it is instead a %s." % type(chunk_size))
+        # simulate reading small chunks of the content
+        reused_chunks = iter_slices(self._content, chunk_size)
+
+        stream_chunks = generate()
+
+        chunks = reused_chunks if self._content_consumed else stream_chunks
+
+        if decode_unicode:
+            chunks = stream_decode_response_unicode(chunks, self)
+
+        return chunks
+
+    def iter_lines(self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None):
+        """Iterates over the response data, one line at a time.  When
+        stream=True is set on the request, this avoids reading the
+        content at once into memory for large responses.
+
+        .. note:: This method is not reentrant safe.
+        """
+
+        pending = None
+
+        for chunk in self.iter_content(chunk_size=chunk_size, decode_unicode=decode_unicode):
+
+            if pending is not None:
+                chunk = pending + chunk
+
+            if delimiter:
+                lines = chunk.split(delimiter)
+            else:
+                lines = chunk.splitlines()
+
+            if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
+                pending = lines.pop()
+            else:
+                pending = None
+
+            for line in lines:
+                yield line
+
+        if pending is not None:
+            yield pending
+
+    @property
+    def content(self):
+        """Content of the response, in bytes."""
+
+        if self._content is False:
+            # Read the contents.
+            if self._content_consumed:
+                raise RuntimeError(
+                    'The content for this response was already consumed')
+
+            if self.status_code == 0 or self.raw is None:
+                self._content = None
+            else:
+                self._content = b''.join(self.iter_content(CONTENT_CHUNK_SIZE)) or b''
+
+        self._content_consumed = True
+        # don't need to release the connection; that's been handled by urllib3
+        # since we exhausted the data.
+        return self._content
+
+    @property
+    def text(self):
+        """Content of the response, in unicode.
+
+        If Response.encoding is None, encoding will be guessed using
+        ``chardet``.
+
+        The encoding of the response content is determined based solely on HTTP
+        headers, following RFC 2616 to the letter. If you can take advantage of
+        non-HTTP knowledge to make a better guess at the encoding, you should
+        set ``r.encoding`` appropriately before accessing this property.
+        """
+
+        # Try charset from content-type
+        content = None
+        encoding = self.encoding
+
+        if not self.content:
+            return str('')
+
+        # Fallback to auto-detected encoding.
+        if self.encoding is None:
+            encoding = self.apparent_encoding
+
+        # Decode unicode from given encoding.
+        try:
+            content = str(self.content, encoding, errors='replace')
+        except (LookupError, TypeError):
+            # A LookupError is raised if the encoding was not found which could
+            # indicate a misspelling or similar mistake.
+            #
+            # A TypeError can be raised if encoding is None
+            #
+            # So we try blindly encoding.
+            content = str(self.content, errors='replace')
+
+        return content
+
+    def json(self, **kwargs):
+        r"""Returns the json-encoded content of a response, if any.
+
+        :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
+        :raises ValueError: If the response body does not contain valid json.
+        """
+
+        if not self.encoding and self.content and len(self.content) > 3:
+            # No encoding set. JSON RFC 4627 section 3 states we should expect
+            # UTF-8, -16 or -32. Detect which one to use; If the detection or
+            # decoding fails, fall back to `self.text` (using chardet to make
+            # a best guess).
+            encoding = guess_json_utf(self.content)
+            if encoding is not None:
+                try:
+                    return complexjson.loads(
+                        self.content.decode(encoding), **kwargs
+                    )
+                except UnicodeDecodeError:
+                    # Wrong UTF codec detected; usually because it's not UTF-8
+                    # but some other 8-bit codec.  This is an RFC violation,
+                    # and the server didn't bother to tell us what codec *was*
+                    # used.
+                    pass
+        return complexjson.loads(self.text, **kwargs)
+
+    @property
+    def links(self):
+        """Returns the parsed header links of the response, if any."""
+
+        header = self.headers.get('link')
+
+        # l = MultiDict()
+        l = {}
+
+        if header:
+            links = parse_header_links(header)
+
+            for link in links:
+                key = link.get('rel') or link.get('url')
+                l[key] = link
+
+        return l
+
+    def raise_for_status(self):
+        """Raises stored :class:`HTTPError`, if one occurred."""
+
+        http_error_msg = ''
+        if isinstance(self.reason, bytes):
+            # We attempt to decode utf-8 first because some servers
+            # choose to localize their reason strings. If the string
+            # isn't utf-8, we fall back to iso-8859-1 for all other
+            # encodings. (See PR #3538)
+            try:
+                reason = self.reason.decode('utf-8')
+            except UnicodeDecodeError:
+                reason = self.reason.decode('iso-8859-1')
+        else:
+            reason = self.reason
+
+        if 400 <= self.status_code < 500:
+            http_error_msg = u'%s Client Error: %s for url: %s' % (self.status_code, reason, self.url)
+
+        elif 500 <= self.status_code < 600:
+            http_error_msg = u'%s Server Error: %s for url: %s' % (self.status_code, reason, self.url)
+
+        if http_error_msg:
+            raise HTTPError(http_error_msg, response=self)
+
+    def close(self):
+        """Releases the connection back to the pool. Once this method has been
+        called the underlying ``raw`` object must not be accessed again.
+
+        *Note: Should not normally need to be called explicitly.*
+        """
+        if not self._content_consumed:
+            self.raw.close()
+
+        release_conn = getattr(self.raw, 'release_conn', None)
+        if release_conn is not None:
+            release_conn()

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/script (dev).tmpl

@@ -0,0 +1,6 @@
+# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
+__requires__ = %(spec)r
+__import__('pkg_resources').require(%(spec)r)
+__file__ = %(dev_path)r
+with open(__file__) as f:
+    exec(compile(f.read(), __file__, 'exec'))

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/script.tmpl

@@ -0,0 +1,3 @@
+# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
+__requires__ = %(spec)r
+__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/site-patch.py

@@ -0,0 +1,74 @@
+def __boot():
+    import sys
+    import os
+    PYTHONPATH = os.environ.get('PYTHONPATH')
+    if PYTHONPATH is None or (sys.platform == 'win32' and not PYTHONPATH):
+        PYTHONPATH = []
+    else:
+        PYTHONPATH = PYTHONPATH.split(os.pathsep)
+
+    pic = getattr(sys, 'path_importer_cache', {})
+    stdpath = sys.path[len(PYTHONPATH):]
+    mydir = os.path.dirname(__file__)
+
+    for item in stdpath:
+        if item == mydir or not item:
+            continue  # skip if current dir. on Windows, or my own directory
+        importer = pic.get(item)
+        if importer is not None:
+            loader = importer.find_module('site')
+            if loader is not None:
+                # This should actually reload the current module
+                loader.load_module('site')
+                break
+        else:
+            try:
+                import imp  # Avoid import loop in Python 3
+                stream, path, descr = imp.find_module('site', [item])
+            except ImportError:
+                continue
+            if stream is None:
+                continue
+            try:
+                # This should actually reload the current module
+                imp.load_module('site', stream, path, descr)
+            finally:
+                stream.close()
+            break
+    else:
+        raise ImportError("Couldn't find the real 'site' module")
+
+    known_paths = dict([(makepath(item)[1], 1) for item in sys.path])  # 2.2 comp
+
+    oldpos = getattr(sys, '__egginsert', 0)  # save old insertion position
+    sys.__egginsert = 0  # and reset the current one
+
+    for item in PYTHONPATH:
+        addsitedir(item)
+
+    sys.__egginsert += oldpos  # restore effective old position
+
+    d, nd = makepath(stdpath[0])
+    insert_at = None
+    new_path = []
+
+    for item in sys.path:
+        p, np = makepath(item)
+
+        if np == nd and insert_at is None:
+            # We've hit the first 'system' path entry, so added entries go here
+            insert_at = len(new_path)
+
+        if np in known_paths or insert_at is None:
+            new_path.append(item)
+        else:
+            # new path after the insert point, back-insert it
+            new_path.insert(insert_at, item)
+            insert_at += 1
+
+    sys.path[:] = new_path
+
+
+if __name__ == 'site':
+    __boot()
+    del __boot

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/ssl_support.py

@@ -0,0 +1,260 @@
+import os
+import socket
+import atexit
+import re
+import functools
+
+from setuptools.extern.six.moves import urllib, http_client, map, filter
+
+from pkg_resources import ResolutionError, ExtractionError
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+__all__ = [
+    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths',
+    'opener_for'
+]
+
+cert_paths = """
+/etc/pki/tls/certs/ca-bundle.crt
+/etc/ssl/certs/ca-certificates.crt
+/usr/share/ssl/certs/ca-bundle.crt
+/usr/local/share/certs/ca-root.crt
+/etc/ssl/cert.pem
+/System/Library/OpenSSL/certs/cert.pem
+/usr/local/share/certs/ca-root-nss.crt
+/etc/ssl/ca-bundle.pem
+""".strip().split()
+
+try:
+    HTTPSHandler = urllib.request.HTTPSHandler
+    HTTPSConnection = http_client.HTTPSConnection
+except AttributeError:
+    HTTPSHandler = HTTPSConnection = object
+
+is_available = ssl is not None and object not in (HTTPSHandler, HTTPSConnection)
+
+
+try:
+    from ssl import CertificateError, match_hostname
+except ImportError:
+    try:
+        from backports.ssl_match_hostname import CertificateError
+        from backports.ssl_match_hostname import match_hostname
+    except ImportError:
+        CertificateError = None
+        match_hostname = None
+
+if not CertificateError:
+
+    class CertificateError(ValueError):
+        pass
+
+
+if not match_hostname:
+
+    def _dnsname_match(dn, hostname, max_wildcards=1):
+        """Matching according to RFC 6125, section 6.4.3
+
+        https://tools.ietf.org/html/rfc6125#section-6.4.3
+        """
+        pats = []
+        if not dn:
+            return False
+
+        # Ported from python3-syntax:
+        # leftmost, *remainder = dn.split(r'.')
+        parts = dn.split(r'.')
+        leftmost = parts[0]
+        remainder = parts[1:]
+
+        wildcards = leftmost.count('*')
+        if wildcards > max_wildcards:
+            # Issue #17980: avoid denials of service by refusing more
+            # than one wildcard per fragment.  A survey of established
+            # policy among SSL implementations showed it to be a
+            # reasonable choice.
+            raise CertificateError(
+                "too many wildcards in certificate DNS name: " + repr(dn))
+
+        # speed up common case w/o wildcards
+        if not wildcards:
+            return dn.lower() == hostname.lower()
+
+        # RFC 6125, section 6.4.3, subitem 1.
+        # The client SHOULD NOT attempt to match a presented identifier in which
+        # the wildcard character comprises a label other than the left-most label.
+        if leftmost == '*':
+            # When '*' is a fragment by itself, it matches a non-empty dotless
+            # fragment.
+            pats.append('[^.]+')
+        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
+            # RFC 6125, section 6.4.3, subitem 3.
+            # The client SHOULD NOT attempt to match a presented identifier
+            # where the wildcard character is embedded within an A-label or
+            # U-label of an internationalized domain name.
+            pats.append(re.escape(leftmost))
+        else:
+            # Otherwise, '*' matches any dotless string, e.g. www*
+            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
+
+        # add the remaining fragments, ignore any wildcards
+        for frag in remainder:
+            pats.append(re.escape(frag))
+
+        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
+        return pat.match(hostname)
+
+    def match_hostname(cert, hostname):
+        """Verify that *cert* (in decoded format as returned by
+        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+        rules are followed, but IP addresses are not accepted for *hostname*.
+
+        CertificateError is raised on failure. On success, the function
+        returns nothing.
+        """
+        if not cert:
+            raise ValueError("empty or no certificate")
+        dnsnames = []
+        san = cert.get('subjectAltName', ())
+        for key, value in san:
+            if key == 'DNS':
+                if _dnsname_match(value, hostname):
+                    return
+                dnsnames.append(value)
+        if not dnsnames:
+            # The subject is only checked when there is no dNSName entry
+            # in subjectAltName
+            for sub in cert.get('subject', ()):
+                for key, value in sub:
+                    # XXX according to RFC 2818, the most specific Common Name
+                    # must be used.
+                    if key == 'commonName':
+                        if _dnsname_match(value, hostname):
+                            return
+                        dnsnames.append(value)
+        if len(dnsnames) > 1:
+            raise CertificateError("hostname %r "
+                "doesn't match either of %s"
+                % (hostname, ', '.join(map(repr, dnsnames))))
+        elif len(dnsnames) == 1:
+            raise CertificateError("hostname %r "
+                "doesn't match %r"
+                % (hostname, dnsnames[0]))
+        else:
+            raise CertificateError("no appropriate commonName or "
+                "subjectAltName fields were found")
+
+
+class VerifyingHTTPSHandler(HTTPSHandler):
+    """Simple verifying handler: no auth, subclasses, timeouts, etc."""
+
+    def __init__(self, ca_bundle):
+        self.ca_bundle = ca_bundle
+        HTTPSHandler.__init__(self)
+
+    def https_open(self, req):
+        return self.do_open(
+            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw), req
+        )
+
+
+class VerifyingHTTPSConn(HTTPSConnection):
+    """Simple verifying connection: no auth, subclasses, timeouts, etc."""
+
+    def __init__(self, host, ca_bundle, **kw):
+        HTTPSConnection.__init__(self, host, **kw)
+        self.ca_bundle = ca_bundle
+
+    def connect(self):
+        sock = socket.create_connection(
+            (self.host, self.port), getattr(self, 'source_address', None)
+        )
+
+        # Handle the socket if a (proxy) tunnel is present
+        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None):
+            self.sock = sock
+            self._tunnel()
+            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7
+            # change self.host to mean the proxy server host when tunneling is
+            # being used. Adapt, since we are interested in the destination
+            # host for the match_hostname() comparison.
+            actual_host = self._tunnel_host
+        else:
+            actual_host = self.host
+
+        if hasattr(ssl, 'create_default_context'):
+            ctx = ssl.create_default_context(cafile=self.ca_bundle)
+            self.sock = ctx.wrap_socket(sock, server_hostname=actual_host)
+        else:
+            # This is for python < 2.7.9 and < 3.4?
+            self.sock = ssl.wrap_socket(
+                sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle
+            )
+        try:
+            match_hostname(self.sock.getpeercert(), actual_host)
+        except CertificateError:
+            self.sock.shutdown(socket.SHUT_RDWR)
+            self.sock.close()
+            raise
+
+
+def opener_for(ca_bundle=None):
+    """Get a urlopen() replacement that uses ca_bundle for verification"""
+    return urllib.request.build_opener(
+        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle())
+    ).open
+
+
+# from jaraco.functools
+def once(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if not hasattr(func, 'always_returns'):
+            func.always_returns = func(*args, **kwargs)
+        return func.always_returns
+    return wrapper
+
+
+@once
+def get_win_certfile():
+    try:
+        import wincertstore
+    except ImportError:
+        return None
+
+    class CertFile(wincertstore.CertFile):
+        def __init__(self):
+            super(CertFile, self).__init__()
+            atexit.register(self.close)
+
+        def close(self):
+            try:
+                super(CertFile, self).close()
+            except OSError:
+                pass
+
+    _wincerts = CertFile()
+    _wincerts.addstore('CA')
+    _wincerts.addstore('ROOT')
+    return _wincerts.name
+
+
+def find_ca_bundle():
+    """Return an existing CA bundle path, or None"""
+    extant_cert_paths = filter(os.path.isfile, cert_paths)
+    return (
+        get_win_certfile()
+        or next(extant_cert_paths, None)
+        or _certifi_where()
+    )
+
+
+def _certifi_where():
+    try:
+        return __import__('certifi').where()
+    except (ImportError, ResolutionError, ExtractionError):
+        pass

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/unicode_utils.py

@@ -0,0 +1,44 @@
+import unicodedata
+import sys
+
+from setuptools.extern import six
+
+
+# HFS Plus uses decomposed UTF-8
+def decompose(path):
+    if isinstance(path, six.text_type):
+        return unicodedata.normalize('NFD', path)
+    try:
+        path = path.decode('utf-8')
+        path = unicodedata.normalize('NFD', path)
+        path = path.encode('utf-8')
+    except UnicodeError:
+        pass  # Not UTF-8
+    return path
+
+
+def filesys_decode(path):
+    """
+    Ensure that the given path is decoded,
+    NONE when no expected encoding works
+    """
+
+    if isinstance(path, six.text_type):
+        return path
+
+    fs_enc = sys.getfilesystemencoding() or 'utf-8'
+    candidates = fs_enc, 'utf-8'
+
+    for enc in candidates:
+        try:
+            return path.decode(enc)
+        except UnicodeDecodeError:
+            continue
+
+
+def try_encode(string, enc):
+    "turn unicode encoding into a functional routine"
+    try:
+        return string.encode(enc)
+    except UnicodeEncodeError:
+        return None

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/setuptools/version.py

@@ -0,0 +1,6 @@
+import pkg_resources
+
+try:
+    __version__ = pkg_resources.get_distribution('setuptools').version
+except Exception:
+    __version__ = 'unknown'

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/urllib3-1.25.3.dist-info/RECORD

@@ -0,0 +1,104 @@
+urllib3-1.25.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+urllib3-1.25.3.dist-info/LICENSE.txt,sha256=fA0TbuBYU4mt8tJWcbuZaHofdZKfRlt_Fu4_Ado3JV4,1115
+urllib3-1.25.3.dist-info/METADATA,sha256=-vMFvKG4xU5dyqUjifQsJska14qY3WzU696KyN-R-PQ,38346
+urllib3-1.25.3.dist-info/RECORD,,
+urllib3-1.25.3.dist-info/WHEEL,sha256=HX-v9-noUkyUoxyZ1PMSuS7auUxDAR4VBdoYLqD0xws,110
+urllib3-1.25.3.dist-info/top_level.txt,sha256=EMiXL2sKrTcmrMxIHTqdc3ET54pQI2Y072LexFEemvo,8
+urllib3/__init__.py,sha256=dW1kWCz7bYGr-1q7xbDvJ_0_GwfyJtWq4VaLIzMcviA,2721
+urllib3/__init__.pyc,,
+urllib3/_collections.py,sha256=-CAKsDE-WdubAjlBSZLx7b0e7WKenaNGwWvGLDEF1TM,10746
+urllib3/_collections.pyc,,
+urllib3/connection.py,sha256=hdUK2hwFNWlKxpm7JbY_YxGYJWbe6s0AYUSt9wguHk0,15001
+urllib3/connection.pyc,,
+urllib3/connectionpool.py,sha256=jkmLBXUD8wB0exYjDoEsg_cXVZUv-iDbhC3vAUUH82Q,35307
+urllib3/connectionpool.pyc,,
+urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3/contrib/__init__.pyc,,
+urllib3/contrib/_appengine_environ.py,sha256=lhYXvB5_oGKSeurX7za3XhcGyERvNjXRQ3eJp2GmQ3M,717
+urllib3/contrib/_appengine_environ.pyc,,
+urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3/contrib/_securetransport/__init__.pyc,,
+urllib3/contrib/_securetransport/bindings.py,sha256=6ZRejHBpquHtJaXPDm0cBsEwOBe2l9bTnDvVzd0HwJw,17576
+urllib3/contrib/_securetransport/bindings.pyc,,
+urllib3/contrib/_securetransport/low_level.py,sha256=Umy5u-3Z957GirdapnicXVOpHaM4xdOZABJuJxfaeJA,12162
+urllib3/contrib/_securetransport/low_level.pyc,,
+urllib3/contrib/appengine.py,sha256=lB2Fame05OAlaSJs1a86QYF84v7Oymbqjs0OIcexq_s,10914
+urllib3/contrib/appengine.pyc,,
+urllib3/contrib/ntlmpool.py,sha256=5ZpMF7N9B6NEjVU-r-xjDOV_-hkNvsDoNc84J2yqauI,4459
+urllib3/contrib/ntlmpool.pyc,,
+urllib3/contrib/pyopenssl.py,sha256=p8nTcDp8cFBx-GPcldZqUpTR3_5KlqfTBmF-QLixH1s,16451
+urllib3/contrib/pyopenssl.pyc,,
+urllib3/contrib/securetransport.py,sha256=IfPZ2wA3x3NXxHjKr--Q7Xz4A37ZSyWHn_1WvGxvTKQ,32826
+urllib3/contrib/securetransport.pyc,,
+urllib3/contrib/socks.py,sha256=ZJ7lEUlErvAgQkd4xo_xvfx-acym2tDtJqyE0It4VRI,7012
+urllib3/contrib/socks.pyc,,
+urllib3/exceptions.py,sha256=rFeIfBNKC8KJ61ux-MtJyJlEC9G9ggkmCeF751JwVR4,6604
+urllib3/exceptions.pyc,,
+urllib3/fields.py,sha256=0EYvHsgnUflhb-UhMMVjAwiRp1InCe-uy1McDD6nhPU,8575
+urllib3/fields.pyc,,
+urllib3/filepost.py,sha256=40CROlpRKVBpFUkD0R6wJf_PpvbcRQRFUu0OOQlFkKM,2436
+urllib3/filepost.pyc,,
+urllib3/packages/__init__.py,sha256=nlChrGzkjCkmhCX9HrF_qHPUgosfsPQkVIJxiiLhk9g,109
+urllib3/packages/__init__.pyc,,
+urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3/packages/backports/__init__.pyc,,
+urllib3/packages/backports/makefile.py,sha256=so2z9BiNM8kh38Ve5tomQP_mp2_ubEqzdlCpLZKzzCI,1456
+urllib3/packages/backports/makefile.pyc,,
+urllib3/packages/rfc3986/__init__.py,sha256=Y2dGb08ZJuqIrAqfmrGMpNi2zjzKVTxfeZ8iF-Db338,1562
+urllib3/packages/rfc3986/__init__.pyc,,
+urllib3/packages/rfc3986/_mixin.py,sha256=fnxYtuAQwo6RlGZzsawcICxUhLqQ_Tyob_Kamy-92QU,13214
+urllib3/packages/rfc3986/_mixin.pyc,,
+urllib3/packages/rfc3986/abnf_regexp.py,sha256=0cPq-UrpihByHkDsZd_7p6ruqYh2MuqCqIjc67PFHCs,9081
+urllib3/packages/rfc3986/abnf_regexp.pyc,,
+urllib3/packages/rfc3986/api.py,sha256=5wYJ3IvszICEY5cgeLTtLRWCyc9mJhgZ_4QZVtYoSKI,3887
+urllib3/packages/rfc3986/api.pyc,,
+urllib3/packages/rfc3986/builder.py,sha256=BFbuFFZUcAnGJzvtQ0n7ffHqgG-CBf-Xi_6aU68n-OA,9577
+urllib3/packages/rfc3986/builder.pyc,,
+urllib3/packages/rfc3986/compat.py,sha256=jnSGxU4M13w5vuLldgKmXmpxcZBxmUwg8dBzNQEWzYc,1513
+urllib3/packages/rfc3986/compat.pyc,,
+urllib3/packages/rfc3986/exceptions.py,sha256=dadexlPfwsYbcbFdbR1lp5WyuF8PMsSmx2gA3nrger4,3775
+urllib3/packages/rfc3986/exceptions.pyc,,
+urllib3/packages/rfc3986/iri.py,sha256=8WHJ7ujzatPHfbfxv0MXQT-zd9LLBYQIo1zbg4ZI74w,5466
+urllib3/packages/rfc3986/iri.pyc,,
+urllib3/packages/rfc3986/misc.py,sha256=MbL7MgqbTef5VddkaaPKkLpe0hPRNCEx0-kKhJfRyk8,4094
+urllib3/packages/rfc3986/misc.pyc,,
+urllib3/packages/rfc3986/normalizers.py,sha256=L6DOXDi7vZ_BDoXS8IUl9CW21E-siDJluK2mmImljtY,5259
+urllib3/packages/rfc3986/normalizers.pyc,,
+urllib3/packages/rfc3986/parseresult.py,sha256=cdmsiBExo5o2A2jWI-TtGFeXTPenyXQbGf5Nmv7nh6M,14654
+urllib3/packages/rfc3986/parseresult.pyc,,
+urllib3/packages/rfc3986/uri.py,sha256=r_KhSNmvWfoBGRPBf1dnlwWnCwuM-JHFtGa-6DH_jH4,5227
+urllib3/packages/rfc3986/uri.pyc,,
+urllib3/packages/rfc3986/validators.py,sha256=jbJGdqUcoeSD2E_gmuFbrujLsVtEpjhJg7oxpiFeyY4,13854
+urllib3/packages/rfc3986/validators.pyc,,
+urllib3/packages/six.py,sha256=A6hdJZVjI3t_geebZ9BzUvwRrIXo0lfwzQlM2LcKyas,30098
+urllib3/packages/six.pyc,,
+urllib3/packages/ssl_match_hostname/__init__.py,sha256=WBVbxQBojNAxfZwNavkox3BgJiMA9BJmm-_fwd0jD_o,688
+urllib3/packages/ssl_match_hostname/__init__.pyc,,
+urllib3/packages/ssl_match_hostname/_implementation.py,sha256=_foKOc3Los_n21TCW4IpjTTRHppsjw35vnu7dRBv-88,5683
+urllib3/packages/ssl_match_hostname/_implementation.pyc,,
+urllib3/poolmanager.py,sha256=GrUSFRcQbhxPMRlePxOUbXvmsOgGTiNrxQpICmXd30I,17050
+urllib3/poolmanager.pyc,,
+urllib3/request.py,sha256=OfelFYzPnxGlU3amEz9uBLjCBOriwgJh4QC_aW9SF3U,5991
+urllib3/request.pyc,,
+urllib3/response.py,sha256=GxiW6sI0NZgdlDL4hzPfKDZmH7OFTiGZosaXu2DMG7k,27171
+urllib3/response.pyc,,
+urllib3/util/__init__.py,sha256=P-VlwgBFaga7i1BTWPNHGK4TN-SES0VoexbeIPIKs_0,1082
+urllib3/util/__init__.pyc,,
+urllib3/util/connection.py,sha256=-AyqcRTuNUHuo5ndtsU0Og_nMyCGATC-kYqOUdBHwIQ,4639
+urllib3/util/connection.pyc,,
+urllib3/util/queue.py,sha256=myTX3JDHntglKQNBf3b6dasHH-uF-W59vzGSQiFdAfI,497
+urllib3/util/queue.pyc,,
+urllib3/util/request.py,sha256=_pmOHJWpOHk7w8BDz6WZkmMunNmplEPBmh2-5bl3Do4,3832
+urllib3/util/request.pyc,,
+urllib3/util/response.py,sha256=028PNXDZhwBtnm2uXvnAHi_l9_AAGrAMH2Igh2AbgWg,2586
+urllib3/util/response.pyc,,
+urllib3/util/retry.py,sha256=1m-XI9_LORj1FLbwOzgWC6pTt2deycyGl4BWRI9r4Zc,15150
+urllib3/util/retry.pyc,,
+urllib3/util/ssl_.py,sha256=PkKRHaKZkZ4wH9u7edPsG7mkaUSLLHQB52UOKlF_PBg,13786
+urllib3/util/ssl_.pyc,,
+urllib3/util/timeout.py,sha256=dTF-iEp8DZiPd-8g2X7CVucDoBWJBn221T8ghg-tjkQ,9768
+urllib3/util/timeout.pyc,,
+urllib3/util/url.py,sha256=itUnJsty1UZDeahrqH9WkH2ESTj4yHElQyCA8_P6rRM,9810
+urllib3/util/url.pyc,,
+urllib3/util/wait.py,sha256=p4BZo_Ukp5JF0Dn6jro7cUfqIjnU6WFtuoA6poaV5Jk,5403
+urllib3/util/wait.pyc,,

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/urllib3-1.25.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+