chore: appease clippy (redundant closure)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L3U6BKYCS73DVA83odAfYB

src/extractor/mod.rs

@@ -252,17 +252,47 @@ fn suppress_table_underlines(
     }
 
     let mut table_item_indices: HashSet<usize> = HashSet::new();
+    // A detected "table" that swallows nearly every text item on the page
+    // is a detection artifact (prose pages with boxed callouts or stacked
+    // underline rules read as one giant grid), not a real table — letting
+    // it through here erased every legitimate underline on the page
+    // (text_dense__underline: rect detection claimed 52/52 items). Real
+    // ruled tables share the page with headings, captions, and body text.
+    let plausible = |table: &crate::tables::Table| {
+        // Content sanity gate: prose pages with boxed callouts and stacked
+        // underline rules can detect as a structurally rich "table" that
+        // swallows every item on the page (text_dense__underline: a 4x8
+        // grid claiming 52/52 items, one "cell" holding 806 chars of body
+        // text) — suppressing there erased every legitimate underline on
+        // the page. Real data-table cells are short values; a cell with
+        // hundreds of characters means the grid captured flowing prose.
+        let lens: Vec<usize> = table
+            .cells
+            .iter()
+            .flatten()
+            .filter(|cell| !cell.trim().is_empty())
+            .map(|cell| cell.chars().count())
+            .collect();
+        if lens.is_empty() {
+            return false;
+        }
+        let long = lens.iter().filter(|&&n| n > 100).count();
+        (long as f32) < (lens.len() as f32) * 0.3
+    };
 
     if !rects.is_empty() {
         let (rect_tables, _) = crate::tables::detect_tables_from_rects(items, rects, page);
-        for table in rect_tables {
-            table_item_indices.extend(table.item_indices);
+        for table in rect_tables.iter().filter(|t| plausible(t)) {
+            table_item_indices.extend(table.item_indices.iter().copied());
         }
     }
 
     if !lines.is_empty() {
-        for table in crate::tables::detect_tables_from_lines(items, lines, page) {
-            table_item_indices.extend(table.item_indices);
+        for table in crate::tables::detect_tables_from_lines(items, lines, page)
+            .iter()
+            .filter(|t| plausible(t))
+        {
+            table_item_indices.extend(table.item_indices.iter().copied());
         }
     }
 
@@ -873,9 +903,17 @@ pub(crate) fn merge_subscript_items(items: Vec<TextItem>) -> Vec<TextItem> {
                         .chars()
                         .last()
                         .is_some_and(|c| c.is_alphabetic());
-                    let same_marks = parent.is_underline == item.is_underline
-                        && parent.is_strikeout == item.is_strikeout;
-                    if parent.font_size >= sub_threshold && ends_with_letter && same_marks {
+                    // Strikeout boundaries block the merge (a struck word
+                    // must not extend its strike over a live footnote digit,
+                    // and a struck digit must not lose its own mark). An
+                    // underlined parent with an unmarked digit DOES merge:
+                    // the drawn rule easily misses the tiny digit's overlap
+                    // window, and refusing costs the whole subscript token
+                    // ("b"+"2" staying split). Visually the rule spans both.
+                    let marks_ok = parent.is_strikeout == item.is_strikeout
+                        && (parent.is_underline == item.is_underline
+                            || (parent.is_underline && !item.is_underline));
+                    if parent.font_size >= sub_threshold && ends_with_letter && marks_ok {
                         let parent_right = parent.x + parent.width;
                         let gap = item.x - parent_right;
                         // Subscripts must be tightly adjacent (within ~1pt)

src/extractor/underline.rs

@@ -115,7 +115,13 @@ fn rules_from_graphics(rects: &[PdfRect], lines: &[UnderlineLine], page: u32) ->
     rules
 }
 
-fn discard_repeated_ruling_rules(rules: Vec<Rule>) -> Vec<Rule> {
+fn discard_repeated_ruling_rules(
+    rules: Vec<Rule>,
+    items: &[TextItem],
+    rects: &[PdfRect],
+    lines: &[UnderlineLine],
+    page: u32,
+) -> Vec<Rule> {
     if rules.len() < MIN_REPEATED_RULE_LEVELS {
         return rules;
     }
@@ -123,12 +129,142 @@ fn discard_repeated_ruling_rules(rules: Vec<Rule>) -> Vec<Rule> {
     rules
         .iter()
         .filter(|rule| {
-            !is_repeated_ruling_rule(rule, &rules) && !is_segmented_row_ruling_rule(rule, &rules)
+            // A rule snugly owned by one text line is an underline even when
+            // span-similar rules repeat down the page — documents that
+            // underline many full-width lines (dense CJK business docs) look
+            // exactly like table rulings to the repetition check, which used
+            // to discard every one of them. Table rulings fail snugness:
+            // row separators extend past their cells' text (or have no text
+            // on the baseline above), and multi-column matches are still
+            // culled by the tabular filter afterwards.
+            // Same-row segmented rules (column-header separators) are
+            // always rulings — each segment snugly owns its column label,
+            // so snugness must not override that check.
+            !is_segmented_row_ruling_rule(rule, &rules)
+                && ((has_snug_text_owner(rule, items)
+                    && !has_flanking_verticals(rule, rects, lines, page))
+                    || !is_repeated_ruling_rule(rule, &rules))
         })
         .cloned()
         .collect()
 }
 
+/// True when a single text item both matches the rule vertically (baseline
+/// window) and horizontally contains it: the rule may not extend past the
+/// item's span by more than ~0.75em on either side. Underlines are drawn to
+/// the width of the text they decorate; table/form rulings span cells or
+/// full table width and overshoot any single item.
+/// A rule flanked by vertical strokes at its ends is a table/box border
+/// row edge, not an underline — underlined text lines have no vertical
+/// rules rising from their ends. Checked against raw stroked lines: a
+/// near-vertical segment whose x sits at either end of the rule and whose
+/// y-range covers the rule's row.
+fn has_flanking_verticals(
+    rule: &Rule,
+    rects: &[PdfRect],
+    lines: &[UnderlineLine],
+    page: u32,
+) -> bool {
+    // A drawn rect that CONTAINS the rule vetoes rescue only with GRID
+    // EVIDENCE: another drawn rect abutting it vertically (cell rows tile).
+    // Height alone can't separate a table cell from a decorative callout
+    // panel — genuine underlines live inside isolated filled panels, and
+    // multiline table cells can be arbitrarily tall.
+    let norm = |r: &PdfRect| {
+        let (x_lo, x_hi) = if r.width >= 0.0 {
+            (r.x, r.x + r.width)
+        } else {
+            (r.x + r.width, r.x)
+        };
+        let (y_lo, y_hi) = if r.height >= 0.0 {
+            (r.y, r.y + r.height)
+        } else {
+            (r.y + r.height, r.y)
+        };
+        (x_lo, x_hi, y_lo, y_hi)
+    };
+    let page_rects: Vec<(f32, f32, f32, f32)> = rects
+        .iter()
+        .filter(|r| r.page == page && r.height.abs() > 6.0)
+        .map(norm)
+        .collect();
+    let rect_flank = page_rects.iter().any(|&(x_lo, x_hi, y_lo, y_hi)| {
+        let contains = x_lo <= rule.x1 + 2.0
+            && x_hi >= rule.x2 - 2.0
+            && y_lo <= rule.y + 2.0
+            && y_hi >= rule.y - 2.0;
+        if !contains {
+            return false;
+        }
+        // Grid evidence: a vertically abutting neighbor box with x-overlap.
+        page_rects.iter().any(|&(nx_lo, nx_hi, ny_lo, ny_hi)| {
+            let x_overlap = nx_hi.min(x_hi) - nx_lo.max(x_lo);
+            if x_overlap <= 10.0 {
+                return false;
+            }
+            (ny_lo - y_hi).abs() <= 3.0 || (y_lo - ny_hi).abs() <= 3.0
+        })
+    });
+    if rect_flank {
+        return true;
+    }
+    lines.iter().any(|l| {
+        if l.page != page || (l.x1 - l.x2).abs() > 2.0 {
+            return false;
+        }
+        let x = (l.x1 + l.x2) / 2.0;
+        let near_end = (x - rule.x1).abs() <= 6.0 || (x - rule.x2).abs() <= 6.0;
+        if !near_end {
+            return false;
+        }
+        let (y_lo, y_hi) = if l.y1 <= l.y2 {
+            (l.y1, l.y2)
+        } else {
+            (l.y2, l.y1)
+        };
+        y_lo <= rule.y + 2.0 && y_hi >= rule.y - 2.0
+    })
+}
+
+fn has_snug_text_owner(rule: &Rule, items: &[TextItem]) -> bool {
+    // Underlines are drawn to the width of the text they decorate, but the
+    // text may be split into several runs (CJK lines mix scripts and font
+    // switches) — so ownership is judged against the UNION of the runs on
+    // the rule's baseline row. Table/form rulings overshoot their row's
+    // text (row separators span cell padding and empty columns), so they
+    // fail either containment or coverage.
+    let matched: Vec<&TextItem> = items
+        .iter()
+        .filter(|item| is_underline_candidate(item) && rule_matches_item(rule, item))
+        .collect();
+    if matched.is_empty() {
+        return false;
+    }
+    let x1 = matched.iter().map(|i| i.x).fold(f32::INFINITY, f32::min);
+    let x2 = matched
+        .iter()
+        .map(|i| i.x + i.width)
+        .fold(f32::NEG_INFINITY, f32::max);
+    let max_fs = matched.iter().map(|i| i.font_size).fold(0.0, f32::max);
+    let pad = (max_fs * 0.75).max(4.0);
+    if rule.x1 < x1 - pad || rule.x2 > x2 + pad {
+        return false;
+    }
+    let covered: f32 = matched.iter().map(|i| i.width).sum();
+    if covered < rule.width() * 0.6 {
+        return false;
+    }
+    // A table row also unions to the rule's span — but its cells sit apart.
+    // An underlined text line is contiguous runs with word-sized gaps; any
+    // column-sized hole between matched runs means this is a row ruling.
+    let mut sorted = matched;
+    sorted.sort_by(|a, b| a.x.total_cmp(&b.x));
+    sorted.windows(2).all(|pair| {
+        let gap = pair[1].x - (pair[0].x + pair[0].width);
+        gap <= (max_fs * 2.0).max(12.0)
+    })
+}
+
 fn is_repeated_ruling_rule(rule: &Rule, rules: &[Rule]) -> bool {
     let mut y_levels: Vec<f32> = rules
         .iter()
@@ -215,9 +351,11 @@ fn is_underline_candidate(item: &TextItem) -> bool {
 
 fn rule_matches_item(rule: &Rule, item: &TextItem) -> bool {
     // Vertical window: underlines sit at or slightly below the baseline.
-    // Fonts draw them at roughly 5-15% of the em below; allow up to 35%
-    // (min 3pt) below and 1pt above for rounding.
-    let below = (item.font_size * 0.35).max(3.0);
+    // Latin fonts draw them at roughly 5-15% of the em below; CJK layouts
+    // put them under the full em box, measured up to ~0.67em below the
+    // baseline (text_dense__underline). Allow 0.72em (min 3pt) below and
+    // 1pt above for rounding.
+    let below = (item.font_size * 0.72).max(3.0);
     let y_min = item.y - below;
     let y_max = item.y + 1.0;
     if rule.y < y_min || rule.y > y_max {
@@ -260,12 +398,48 @@ pub(crate) fn mark_underlined_items(
     lines: &[UnderlineLine],
     page: u32,
 ) {
-    let rules = discard_repeated_ruling_rules(rules_from_graphics(rects, lines, page));
+    let rules = discard_repeated_ruling_rules(
+        rules_from_graphics(rects, lines, page),
+        items,
+        rects,
+        lines,
+        page,
+    );
     if rules.is_empty() {
         return;
     }
     let tabular_rules = tabular_row_separator_rule_indices(&rules, items);
 
+    // Math fraction bars are short horizontal lines with the numerator just
+    // above AND the denominator just below — underline geometry from above,
+    // but no underline has text hanging directly beneath it at fraction
+    // distance. Only narrow rules qualify: real underlines under short
+    // labels have their next text line a full line-pitch away.
+    let fraction_rules: HashSet<usize> = rules
+        .iter()
+        .enumerate()
+        .filter(|(_, rule)| {
+            rule.width() <= 60.0
+                && items.iter().any(|item| {
+                    if !is_underline_candidate(item) {
+                        return false;
+                    }
+                    // A denominator HUGS the bar (fraction typesetting
+                    // leaves ~0.1-0.2em) and is bar-sized. Both bounds
+                    // matter: a short last-line of a paragraph at normal
+                    // leading sits further below, and a full next text
+                    // line is far wider than the rule.
+                    let dy = rule.y - (item.y + item.height);
+                    let overlap = rule.x2.min(item.x + item.width) - rule.x1.max(item.x);
+                    dy > 0.0
+                        && dy <= item.font_size * 0.3
+                        && overlap > rule.width() * 0.5
+                        && item.width <= rule.width() * 1.5
+                })
+        })
+        .map(|(i, _)| i)
+        .collect();
+
     for item in items.iter_mut() {
         if !is_underline_candidate(item) {
             continue;
@@ -275,7 +449,10 @@ pub(crate) fn mark_underlined_items(
             if tabular_rules.contains(&rule_idx) {
                 continue;
             }
-            if rule_matches_item(rule, item) {
+            // The fraction guard only gates UNDERLINE marking — a rule that
+            // reads as a fraction bar from below can still legitimately
+            // strike through a line above it.
+            if !fraction_rules.contains(&rule_idx) && rule_matches_item(rule, item) {
                 item.is_underline = true;
             }
             if rule_strikes_item(rule, item) {
@@ -323,6 +500,16 @@ mod tests {
         }
     }
 
+    fn cell_rect(x: f32, y: f32, width: f32, height: f32) -> PdfRect {
+        PdfRect {
+            x,
+            y,
+            width,
+            height,
+            page: 1,
+        }
+    }
+
     fn thin_rect(x: f32, y: f32, width: f32) -> PdfRect {
         PdfRect {
             x,
@@ -543,6 +730,100 @@ mod tests {
         assert!(items.iter().all(|item| !item.is_underline));
     }
 
+    #[test]
+    fn repeated_snug_underlines_survive_ruling_filter() {
+        // Dense docs underline many full-width lines: span-similar rules at
+        // 3+ y-levels used to be discarded wholesale as table rulings.
+        // Each rule here snugly matches one text line, so all must mark.
+        let mut items = vec![
+            item("first underlined line of text", 50.0, 700.0, 300.0, 11.0),
+            item("second underlined line here", 50.0, 650.0, 300.0, 11.0),
+            item("third underlined line as well", 50.0, 600.0, 300.0, 11.0),
+        ];
+        let lines = vec![
+            hline(50.0, 350.0, 697.0),
+            hline(50.0, 350.0, 647.0),
+            hline(50.0, 350.0, 597.0),
+        ];
+
+        mark_underlined_items(&mut items, &[], &lines, 1);
+
+        assert!(items.iter().all(|item| item.is_underline));
+    }
+
+    #[test]
+    fn snug_rescue_spans_split_runs_on_one_line() {
+        // A single underlined line is often split into several runs (script
+        // or font switches). The union of touching runs owns the rule.
+        let mut items = vec![
+            item("run one", 50.0, 700.0, 100.0, 11.0),
+            item("run two", 150.5, 700.0, 100.0, 11.0),
+            item("run three", 251.0, 700.0, 99.0, 11.0),
+            item("other a", 50.0, 650.0, 300.0, 11.0),
+            item("other b", 50.0, 600.0, 300.0, 11.0),
+        ];
+        let lines = vec![
+            hline(50.0, 350.0, 697.0),
+            hline(50.0, 350.0, 647.0),
+            hline(50.0, 350.0, 597.0),
+        ];
+
+        mark_underlined_items(&mut items, &[], &lines, 1);
+
+        assert!(items[0].is_underline && items[1].is_underline && items[2].is_underline);
+    }
+
+    #[test]
+    fn snug_rescue_denied_for_row_with_cell_gaps() {
+        // A full-width rule whose baseline row is several items separated by
+        // column-sized gaps is a table row separator, not an underline —
+        // even when span-similar rules repeat down the page.
+        let mut items = vec![
+            item("cell a", 50.0, 700.0, 60.0, 11.0),
+            item("cell b", 190.0, 700.0, 60.0, 11.0),
+            item("cell c", 330.0, 700.0, 70.0, 11.0),
+            item("cell d", 50.0, 650.0, 60.0, 11.0),
+            item("cell e", 190.0, 650.0, 60.0, 11.0),
+            item("cell f", 330.0, 650.0, 70.0, 11.0),
+        ];
+        let lines = vec![
+            hline(50.0, 400.0, 697.0),
+            hline(50.0, 400.0, 647.0),
+            hline(50.0, 400.0, 597.0),
+        ];
+
+        mark_underlined_items(&mut items, &[], &lines, 1);
+
+        assert!(items.iter().all(|item| !item.is_underline));
+    }
+
+    #[test]
+    fn snug_rescue_denied_inside_cell_box() {
+        // A rule snugly under one text line but enclosed by a drawn cell
+        // box that TILES with vertical neighbors (grid evidence) is a row
+        // ruling of a rect-grid table. Isolated boxes (callout panels) do
+        // not veto — see repeated_snug_underlines_survive_ruling_filter.
+        let mut items = vec![
+            item("one wide cell row", 50.0, 700.0, 300.0, 11.0),
+            item("second wide cell", 50.0, 650.0, 300.0, 11.0),
+            item("third wide cell", 50.0, 600.0, 300.0, 11.0),
+        ];
+        let lines = vec![
+            hline(50.0, 350.0, 697.0),
+            hline(50.0, 350.0, 647.0),
+            hline(50.0, 350.0, 597.0),
+        ];
+        let boxes = vec![
+            cell_rect(45.0, 690.0, 320.0, 50.0),
+            cell_rect(45.0, 640.0, 320.0, 50.0),
+            cell_rect(45.0, 590.0, 320.0, 50.0),
+        ];
+
+        mark_underlined_items(&mut items, &boxes, &lines, 1);
+
+        assert!(items.iter().all(|item| !item.is_underline));
+    }
+
     #[test]
     fn same_row_spaced_rule_segments_do_not_mark_column_labels() {
         let mut items = vec![

src/tables/detect_rects.rs

@@ -2367,7 +2367,29 @@ fn detect_merged_cluster_table(
 /// suitable for rect-backed tables where we already know tabular structure exists
 /// (no need for anti-paragraph safeguards).
 fn cluster_x_positions(items: &[(usize, &TextItem)], min_threshold: f32) -> Vec<f32> {
-    let mut x_positions: Vec<f32> = items.iter().map(|(_, i)| i.x).collect();
+    // Column edges come from where text STARTS. An item whose left edge hugs
+    // the previous item's right edge on the same line is a continuation run
+    // (style boundary, script change, underline split) — feeding its x-start
+    // in here fabricates a phantom column mid-cell.
+    let mut sorted: Vec<&TextItem> = items.iter().map(|&(_, i)| i).collect();
+    sorted.sort_by(|a, b| a.y.total_cmp(&b.y).then(a.x.total_cmp(&b.x)));
+    let mut x_positions: Vec<f32> = Vec::with_capacity(sorted.len());
+    for (idx, item) in sorted.iter().enumerate() {
+        let is_continuation = idx > 0 && {
+            let prev = sorted[idx - 1];
+            // Style/underline splits leave runs that TOUCH (gap ~0); real
+            // cell boundaries in even the tightest tables keep a visible
+            // gap. 2pt separates the two without eating dense-table columns.
+            // The negative side is bounded too: text overhanging from an
+            // adjacent cell overlaps by far more than italic kerning ever
+            // does, and must still start its own column.
+            let gap = item.x - (prev.x + prev.width);
+            (prev.y - item.y).abs() <= 2.0 && gap < 2.0 && gap > -4.0 && item.x >= prev.x
+        };
+        if !is_continuation {
+            x_positions.push(item.x);
+        }
+    }
     x_positions.sort_by(|a, b| a.total_cmp(b));
 
     if x_positions.is_empty() {

tests/snapshots/p1244-1996.md

@@ -72,10 +72,11 @@ Month or shorter period in which tips were received **4** Net tips (lines **1 +
 
 forms simpler, we would be happy to hear from you. You can write to the Tax Forms Committee, Western Area Distribution Center, Rancho Cordova, CA 95743-0001. **Purpose.—**Use this form to report tips you receive to your employer. This includes cash tips, tips you receive from other employees, and credit card tips. You must report tips every month regardless of your total wages and tips for the year. However, you do not have to report tips to your employer for any month you received less than $20 in tips while working for that employer. Report tips by the 10th day of the month following the month that you receive them. If the 10th day is a Saturday, Sunday, or legal holiday, report tips by the next day that is not a Saturday, Sunday, or legal holiday. See **Pub. 531**, Reporting Tip Income, for more information. You can get additional copies of **Pub. 1244**, Employee’s Daily Record of Tips and Report to Employer, which contains both Forms 4070A and 4070, by calling 1-800-TAX-FORM (1-800-829-3676).
 
-**Instructions** *(continued)*
+<u>Instructions (continued)</u>
 
 **Unreported Tips.—**If you received tips of $20 or more for any month while working for one employer but did not report them to your employer, you must figure and pay social security and Medicare taxes on the unreported tips when you file your tax return. If you have unreported tips, you **must** use Form 1040 and **Form 4137,** Social Security and Medicare Tax on Unreported Tip Income, to report them. You may **not** use Form 1040A or 1040EZ. Employees subject to the Railroad Retirement Tax Act **cannot** use Form 4137 to pay railroad retirement tax on unreported tips. To get railroad retirement credit, you must report tips to your employer. If you do not report tips to your employer as required, you may be charged a penalty of 50% of the social security and Medicare taxes (or railroad retirement tax) due on the unreported tips unless there was reasonable cause for not reporting them. **Additional Information.—**Get **Pub. 531,** Reporting Tip Income, and Form 4137 for more information on tips. If you are an employee of certain large food or beverage establishments, see Pub. 531 for tip allocation rules. **Recordkeeping.—**If you do not keep a daily record of tips, you must keep other reliable proof of the tip income you received. This proof includes copies of restaurant bills and credit card charges that show amounts customers added as tips. Keep your tip income records for as long as the information on them may be needed in the administration of any Internal Revenue law.
 
 ### Instructions (continued)
 
 Use this space to total your tips for the year
+

tests/snapshots/td9264.md

@@ -1,17 +1,8 @@
-(e) [Reserved]. For further guidance, see §1.1563-3T(e)(1). Par. 50. Section 1.1563-3T is added to read as follows:
-<u>§1.1563-3T Rules for determining stock ownership (temporary)</u>.
-
-(a) through (d)(2)(iii) [Reserved]. For further guidance, see §1.1563-3(a)
-through (d)(2)(iii). (iv) <u>Statement</u>. If the application of paragraph (d)(2)(ii) or (iii) of §1.1563-3 does not result in a corporation being treated as a component member of only one controlled group of corporations on a December 31, then such corporation will be treated as a component member of only one such group on such date. Such corporation may elect the group in which it is to be included by including on or with its income tax return a statement entitled, “STATEMENT TO ELECT CONTROLLED GROUP PURSUANT TO §1.1563-3T(d)(2)(iv).” The statement must include--
-
-(A) A description of each of the controlled groups in which the corporation
-could be included. The description must include the name and employer identification number of each component member of each such group and the stock ownership of the component members of each such group; and
-
-(B) The following representation: [INSERT NAME AND EMPLOYER
-IDENTIFICATION NUMBER OF CORPORATION] ELECTS TO BE TREATED AS A COMPONENT MEMBER OF THE [INSERT DESIGNATION OF GROUP].
-
-(v) <u>Election</u>-- (A) <u>Election filed</u>. An election filed under paragraph (d)(2)(iv) of
-this section is irrevocable and effective until paragraph (d)(2)(ii) or (iii) of §1.1563-3 applies or until a change in the stock ownership of the corporation results in
+||||(e) [Reserved]. For further guidance, see §1.1563-3T(e)(1). Par. 50. Section 1.1563-3T is added to read as follows: §1.1563-3T Rules for determining stock ownership (temporary). (a) through (d)(2)(iii) [Reserved]. For further guidance, see §1.1563-3(a)|
+|---|---|---|---|
+||through (d)(2)(iii).|||
+||(iv)|Statement|. If the application of paragraph (d)(2)(ii) or (iii) of §1.1563-3 does not result in a corporation being treated as a component member of only one controlled group of corporations on a December 31, then such corporation will be treated as a component member of only one such group on such date. Such corporation may elect the group in which it is to be included by including on or with its income tax return a statement entitled, “STATEMENT TO ELECT CONTROLLED GROUP PURSUANT TO §1.1563-3T(d)(2)(iv).” The statement must include-- (A) A description of each of the controlled groups in which the corporation could be included. The description must include the name and employer identification number of each component member of each such group and the stock ownership of the component members of each such group; and (B) The following representation: [INSERT NAME AND EMPLOYER IDENTIFICATION NUMBER OF CORPORATION] ELECTS TO BE TREATED AS A COMPONENT MEMBER OF THE [INSERT DESIGNATION OF GROUP].|
+||(v)|Election|-- (A) Election filed. An election filed under paragraph (d)(2)(iv) of this section is irrevocable and effective until paragraph (d)(2)(ii) or (iii) of §1.1563-3 applies or until a change in the stock ownership of the corporation results in|
 
 |termination of membership in the controlled group in which such corporation has||
 |---|---|
@@ -29,7 +20,7 @@ this section is irrevocable and effective until paragraph (d)(2)(ii) or (iii) of
 Federal income tax return (including any amended return filed on or before the due date (including extensions) of such original return) timely filed on or after May 30,
 
 2006.
-(2) Expiration date. The applicability of this section will expire on May 26,
+(2) <u>Expiration date</u>. The applicability of this section will expire on May 26,
 2009. Par. 51. Section 1.6012-2 is amended by revising paragraph (c) and adding paragraph (k) to read as follows: <u>§1.6012-2 Corporations required to make returns of income</u>.
 * * * * *
 (c) [Reserved]. For further guidance, see §1.6012-2T(c).

tests/snapshots/thermo-freon12.md

@@ -43,9 +43,9 @@ l
 
 **Freon** **®** **12 Saturation Properties-Temperature Table**
 
-|Temp|Pressure||Volume|||Density||Enthalpy|||Entropy|Temp|
-|---|---|---|---|---|---|---|---|---|---|---|---|---|
-|°C|[kPa]|[m³ Liquid v f|/kg]|Vapour v g|Liquid d f|[kg/m³] Vapour d g|Liquid H f|[kJ/kg] Latent H fg|Vapour H g|Liquid S f|[kJ/K-kg] Vapour S g|°C|
+|Temp|Pressure||Volume||Density||Enthalpy|||Entropy|Temp|
+|---|---|---|---|---|---|---|---|---|---|---|---|
+|°C|[kPa]|[m³ Liquid v f|/kg] Vapour v g|[kg/m³ Liquid d f|] Vapour d g|Liquid H f|[kJ/kg] Latent H fg|Vapour H g|Liquid S f|[kJ/K-kg] Vapour S g|°C|
 
 |-100|1.2|0.0006|10.0000|1679.0|0.100|113.3|192.8|306.1|0.6077|1.7210|-100|
 |---|---|---|---|---|---|---|---|---|---|---|---|