memchr 2.8.3

Source: https://github.com/BurntSushi/memchr
Tag scanned: 2.8.3
Compared with: 2.8.2 (0 signals introduced since)
Files: 108 scanned, 51 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 174 info
Scan time: 12.7 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 16 of 16 warn and critical signals; 16 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 20:16

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:82:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_iterator(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| s.chars().count());
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:89:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_iterator_for(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| {
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:112:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_iterator_rev(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| s.chars().rev().count());
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:119:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_iterator_rev_for(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";

    b.iter(|| {
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:130:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_indicesator(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let len = s.chars().count();
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:138:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn char_indicesator_rev(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let len = s.chars().count();
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:146:14

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn split_unicode_ascii(b: &mut Bencher) {
    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";

    b.iter(|| assert_eq!(s.split('V').count(), 3));

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:146:54

identifier `Namประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)

fn split_unicode_ascii(b: &mut Bencher) {
    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";

    b.iter(|| assert_eq!(s.split('V').count(), 3));

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:189:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn bench_join(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    let sep = "→";
    let v = vec![s, s, s, s, s, s, s, s, s, s];

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:299:18

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

            make_test_inner!($s, $code, short_mixed,
                "ศไทย中华Việt Nam; Mary had a little lamb, Little lam!", $iters);
            make_test_inner!($s, $code, short_pile_of_poo,
                "💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩!", $iters);

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:387:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn bench_push_str(b: &mut Bencher) {
    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
    b.iter(|| {
        let mut r = String::new();

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:442:14

identifier `𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)

fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
    assert_eq!(100, s.len());
    b.iter(|| {

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:442:53

identifier `الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)

fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
    assert_eq!(100, s.len());
    b.iter(|| {

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3512:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    assert!("hello".find(|c: char| c == 'x').is_none());
    assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3513:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
}
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3522:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    assert!("hello".rfind(|c: char| c == 'x').is_none());
    assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3523:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
    assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3531:17

identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(empty, s);
    let data = "ประเทศไทย中";
    let s: String = data.chars().collect();
    assert_eq!(data, s);
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3554:19

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let string = "ประเทศไทย中华Việt Nam";
    let mut data = String::from(string);
    data.push_str(string);
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3557:24

identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    data.push_str(string);
    assert!(data.find("ไท华").is_none());
    assert_eq!(data[0..43].find(""), Some(0));
    assert_eq!(data[6..43].find(""), Some(6 - 6));

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3563:34

identifier `ย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data[0..43].find("ทศไ"), Some(12));
    assert_eq!(data[0..43].find("ย中"), Some(24));
    assert_eq!(data[0..43].find("iệt"), Some(34));
    assert_eq!(data[0..43].find("Nam"), Some(40));

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3569:35

identifier `ย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data[43..86].find("ทศไ"), Some(55 - 43));
    assert_eq!(data[43..86].find("ย中"), Some(67 - 43));
    assert_eq!(data[43..86].find("iệt"), Some(77 - 43));
    assert_eq!(data[43..86].find("Nam"), Some(83 - 43));

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3769:17

identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
fn test_replace_2a() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3773:24

identifier `الكويتทศไทย中华` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    let a = "ประเ";
    let a2 = "دولة الكويتทศไทย中华";
    assert_eq!(data.replace(a, repl), a2);
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3779:17

identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
fn test_replace_2b() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3783:15

identifier `ปรدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)
```
    let b = "ะเ";
    let b2 = "ปรدولة الكويتทศไทย中华";
    assert_eq!(data.replace(b, repl), b2);
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3783:30

identifier `الكويتทศไทย中华` mixes scripts: Arabic + Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    let b = "ะเ";
    let b2 = "ปรدولة الكويتทศไทย中华";
    assert_eq!(data.replace(b, repl), b2);
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3789:17

identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
fn test_replace_2c() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3793:15

identifier `ประเทศไทยدولة` mixes scripts: Other + Arabic (in string/comment) (raw pass, confidence 0.40)
```
    let c = "中华";
    let c2 = "ประเทศไทยدولة الكويت";
    assert_eq!(data.replace(c, repl), c2);
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3799:17

identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
fn test_replace_2d() {
    let data = "ประเทศไทย中华";
    let repl = "دولة الكويت";
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3802:14

identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    let d = "ไท华";
    assert_eq!(data.replace(d, repl), data);
}
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3808:17

identifier `abcdαβγδabcdαβγδ` contains homoglyph candidates: α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

fn test_replace_pattern() {
    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3808:17

identifier `abcdαβγδabcdαβγδ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

fn test_replace_pattern() {
    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3809:30

identifier `dαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3809:30

identifier `dαβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3809:71

identifier `γδabc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    let data = "abcdαβγδabcdαβγδ";
    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3810:53

identifier `abcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3810:53

identifier `abcdαβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3810:73

identifier `δabcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3810:73

identifier `δabcdαβ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3811:81

identifier `bcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3811:81

identifier `bcdαβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3811:114

identifier `bcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3811:114

identifier `bcdαβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3812:62

identifier `abcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3812:62

identifier `abcdαβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:3812:82

identifier `δabcdαβ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3812:82

identifier `δabcdαβ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
}

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:3972:21

identifier `ประเทศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
        let data = "ประเทศไทย中华";
        assert_range_eq!(data, 0..3, "ป");
        assert_range_eq!(data, 3..6, "ร");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4134:29

identifier `abcαβγ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    mod boundary {
        const DATA: &str = "abcαβγ";

        const BAD_START: usize = 4;
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4134:29

identifier `abcαβγ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
    mod boundary {
        const DATA: &str = "abcαβγ";

        const BAD_START: usize = 4;
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4151:73

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

                message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4165:73

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

                message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4179:73

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

                message:
                    "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of";
            }

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4222:14

identifier `abcαβγ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
fn test_str_slice_rangetoinclusive_ok() {
    let s = "abcαβγ";
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4222:14

identifier `abcαβγ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
fn test_str_slice_rangetoinclusive_ok() {
    let s = "abcαβγ";
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4224:27

identifier `abcα` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4224:27

identifier `abcα` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(&s[..=2], "abc");
    assert_eq!(&s[..=4], "abcα");
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4230:14

identifier `abcαβγ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
fn test_str_slice_rangetoinclusive_notok() {
    let s = "abcαβγ";
    &s[..=3];
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4230:14

identifier `abcαβγ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
fn test_str_slice_rangetoinclusive_notok() {
    let s = "abcαβγ";
    &s[..=3];
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4236:18

identifier `abcαβγ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
fn test_str_slicemut_rangetoinclusive_ok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    assert_eq!(&mut s[..=2], "abc");
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4236:18

identifier `abcαβγ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

fn test_str_slicemut_rangetoinclusive_ok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    assert_eq!(&mut s[..=2], "abc");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4239:31

identifier `abcα` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!(&mut s[..=2], "abc");
    assert_eq!(&mut s[..=4], "abcα");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4239:31

identifier `abcα` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(&mut s[..=2], "abc");
    assert_eq!(&mut s[..=4], "abcα");
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:4245:18

identifier `abcαβγ` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
fn test_str_slicemut_rangetoinclusive_notok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    &mut s[..=3];
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4245:18

identifier `abcαβγ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
fn test_str_slicemut_rangetoinclusive_notok() {
    let mut s = "abcαβγ".to_owned();
    let s: &mut str = &mut s;
    &mut s[..=3];
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4252:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_is_char_boundary() {
    let s = "ศไทย中华Việt Nam β-release 🐱123";
    assert!(s.is_char_boundary(0));
    assert!(s.is_char_boundary(s.len()));
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4431:17

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!("abc".as_bytes(), b"abc");
    assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4484:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let data = "ประเทศไทย中华Việt Nam";
    assert!(data.contains("ประเ"));
    assert!(data.contains("ะเ"));
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4488:29

identifier `ไท华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    assert!(data.contains("中华"));
    assert!(!data.contains("ไท华"));
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4501:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_split_at() {
    let s = "ศไทย中华Việt Nam";
    for (index, _) in s.char_indices() {
        let (a, b) = s.split_at(index);
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4526:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_split_at_boundscheck() {
    let s = "ศไทย中华Việt Nam";
    s.split_at(1);
}
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4592:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_iterator() {
    let s = "ศไทย中华Việt Nam";
    let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'];

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4608:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_rev_iterator() {
    let s = "ศไทย中华Việt Nam";
    let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ'];

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4647:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_iterator_clone() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.chars();
    it.next();
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4655:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_iterator_last() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.chars();
    it.next();
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4663:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_chars_debug() {
    let s = "ศไทย中华Việt Nam";
    let c = s.chars();
    assert_eq!(
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4673:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_bytesator() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4688:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_bytes_revator() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4703:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_bytesator_nth() {
    let s = "ศไทย中华Việt Nam";
    let v = [
        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142,

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4717:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_bytesator_count() {
    let s = "ศไทย中华Việt Nam";

    let b = s.bytes();
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4725:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_bytesator_last() {
    let s = "ศไทย中华Việt Nam";

    let b = s.bytes();
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4733:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_char_indicesator() {
    let s = "ศไทย中华Việt Nam";
    let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
    let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'];

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4750:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_char_indices_revator() {
    let s = "ศไทย中华Việt Nam";
    let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
    let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ'];

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4767:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_char_indices_last() {
    let s = "ศไทย中华Việt Nam";
    let mut it = s.char_indices();
    it.next();
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4926:8

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    t("::hello::there::", "::", &["", "hello", "there", ""]);
    t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
    t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
    t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4968:15

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let xs = "ศไทย中华Việt Nam".as_bytes();
    assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:4969:35

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let xs = "ศไทย中华Việt Nam".as_bytes();
    assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));

    let xs = b"hello\xFF";
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5155:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ".to_lowercase(), "ας");
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5155:41

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ".to_lowercase(), "ας");
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5156:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5156:42

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
    assert_eq!("Α''Σ".to_lowercase(), "α''ς");

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5158:22

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)


    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5158:48

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)


    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:23

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:44

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5159:50

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:24

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:45

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5160:52

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5162:23

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5162:50

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5163:24

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5163:52

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:24

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:45

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5165:52

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:26

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:47

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5166:56

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");

    assert_eq!("Α Σ".to_lowercase(), "α σ");

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5168:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5168:41

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5169:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5169:42

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α Σ".to_lowercase(), "α σ");
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5170:17

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");

    assert_eq!("Σ".to_lowercase(), "σ");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5170:43

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");

    assert_eq!("Σ".to_lowercase(), "σ");
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5177:22

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣΑ".to_lowercase(), "ασα");
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5177:48

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    assert_eq!("ΑΣΑ".to_lowercase(), "ασα");
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5178:23

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5178:50

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5184:17

identifier `aéǅßﬁᾀ` mixes scripts: Latin + Other + Greek (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!("".to_uppercase(), "");
    assert_eq!("aéǅßﬁᾀ".to_uppercase(), "AÉǄSSFIἈΙ");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5184:49

identifier `AÉǄSSFIἈΙ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!("".to_uppercase(), "");
    assert_eq!("aéǅßﬁᾀ".to_uppercase(), "AÉǄSSFIἈΙ");
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5217:17

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("abc".repeat(0), "");
    assert_eq!("α".repeat(3), "ααα");
}
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:5217:33

identifier `ααα` contains homoglyph candidates: α (03B1)→a, α (03B1)→a, α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    assert_eq!("abc".repeat(0), "");
    assert_eq!("α".repeat(3), "ααα");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5666:15

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
    assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam"));
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5667:62

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
    assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam"));

    let xs = b"hello\xFF".to_vec();

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5684:15

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)


    let xs = "ศไทย中华Việt Nam".as_bytes();
    let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow();
    assert_eq!(String::from_utf8_lossy(xs), ys);

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5685:29

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    let xs = "ศไทย中华Việt Nam".as_bytes();
    let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow();
    assert_eq!(String::from_utf8_lossy(xs), ys);

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5837:17

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(&s[0..], "abc");
    s.push_str("ประเทศไทย中华Việt Nam");
    assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5838:26

identifier `abcประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    s.push_str("ประเทศไทย中华Việt Nam");
    assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5848:11

identifier `ประเทศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(s.as_str(), "abc");
    s += "ประเทศไทย中华Việt Nam";
    assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5849:29

identifier `abcประเทศไทย中华Việt` mixes scripts: Latin + Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    s += "ประเทศไทย中华Việt Nam";
    assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5854:34

identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
fn test_push() {
    let mut data = String::from("ประเทศไทย中");
    data.push('华');
    data.push('b'); // 1 byte
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5860:23

identifier `ประเทศไทย中华b` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    data.push('𤭢'); // 4 byte
    assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
}
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5865:34

identifier `ประเทศไทย中华b` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

fn test_pop() {
    let mut data = String::from("ประเทศไทย中华b¢€𤭢");
    assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
    assert_eq!(data.pop().unwrap(), '€'); // 3 bytes

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5871:23

identifier `ประเทศไทย中` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(data.pop().unwrap(), '华');
    assert_eq!(data, "ประเทศไทย中");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5968:18

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn remove() {
    let mut s = "ศไทย中华Việt Nam; foobar".to_string();
    assert_eq!(s.remove(0), 'ศ');
    assert_eq!(s.len(), 33);
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5971:20

identifier `ไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    assert_eq!(s.len(), 33);
    assert_eq!(s, "ไทย中华Việt Nam; foobar");
    assert_eq!(s.remove(17), 'ệ');
    assert_eq!(s, "ไทย中华Vit Nam; foobar");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5973:20

identifier `ไทย中华Vit` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    assert_eq!(s.remove(17), 'ệ');
    assert_eq!(s, "ไทย中华Vit Nam; foobar");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5996:18

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    let mut s = "ศไทย中华Việt Nam; foobarศ".to_string();
    s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");
```

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5996:48

identifier `foobarศ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)


    let mut s = "ศไทย中华Việt Nam; foobarศ".to_string();
    s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");

info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:5998:20

identifier `ไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
    s.remove_matches('ศ');
    assert_eq!(s, "ไทย中华Việt Nam; foobar");

    let mut s = "".to_string();
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:6022:24

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    s.retain(|c| c == 'α');
    assert_eq!(s, "α");
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:6023:20

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    s.retain(|c| c == 'α');
    assert_eq!(s, "α");

    s.retain(|_| false);
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6049:20

identifier `ệfooยbar` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
    s.insert(6, 'ย');
    assert_eq!(s, "ệfooยbar");
}
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6094:14

identifier `ศไทย中华Việt` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)
```
fn test_from_iterator() {
    let s = "ศไทย中华Việt Nam".to_string();
    let t = "ศไทย中华";
    let u = "Việt Nam";
```
info unicode-mixed-script benchmarks/haystacks/code/rust-library.rs:6095:14

identifier `ศไทย中华` mixes scripts: Other + Han (in string/comment) (raw pass, confidence 0.40)
```
    let s = "ศไทย中华Việt Nam".to_string();
    let t = "ศไทย中华";
    let u = "Việt Nam";
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17725:35

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    /// ```
    /// let mut s = String::from("α is alpha, β is beta");
    /// let beta_offset = s.find('β').unwrap_or(s.len());
    ///
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17730:24

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    /// let t: String = s.drain(..beta_offset).collect();
    /// assert_eq!(t, "α is alpha, ");
    /// assert_eq!(s, "β is beta");
    ///
```
info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17775:35

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    /// ```
    /// let mut s = String::from("α is alpha, β is beta");
    /// let beta_offset = s.find('β').unwrap_or(s.len());
    ///
```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17779:41

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    /// // Replace the range up until the β from the string
    /// s.replace_range(..beta_offset, "Α is capital alpha; ");
    /// assert_eq!(s, "Α is capital alpha; β is beta");
    /// ```

info unicode-homoglyph benchmarks/haystacks/code/rust-library.rs:17780:24

identifier `Α` contains homoglyph candidates: Α (0391)→A (in string/comment) (raw pass, confidence 0.35)

    /// s.replace_range(..beta_offset, "Α is capital alpha; ");
    /// assert_eq!(s, "Α is capital alpha; β is beta");
    /// ```
    #[stable(feature = "splice", since = "1.27.0")]

info ~~warn~~ → info by review unicode-homoglyph benchmarks/haystacks/opensubtitles/ru-huge.txt:5057:4

identifier `Боr` contains homoglyph candidates: о (043E)→o (raw pass, confidence 0.70)
```
— Не думаешь стал быть — Стал-быть так.
А Боr?
Ты гляди...
не чужого вскармливаешь
```
likely benign LLM, confidence 0.90 A Russian dialogue word containing a Latin 'o' and 'r' inside a subtitle text file.
Reasoning
Latin 'r' in a Russian subtitle word 'Боr' is a typo or transcription artifact in dialogue text, not a code identifier; the file is a natural-language haystack corpus.
info ~~warn~~ → info by review unicode-mixed-script benchmarks/haystacks/opensubtitles/ru-huge.txt:5057:4

identifier `Боr` mixes scripts: Cyrillic + Latin (raw pass, confidence 0.80)
```
— Не думаешь стал быть — Стал-быть так.
А Боr?
Ты гляди...
не чужого вскармливаешь
```
likely benign LLM, confidence 0.90 Mixed-script token in Russian subtitle prose.
Reasoning
Mixed Cyrillic and Latin letters appear in prose subtitle text, not an identifier used by code; this is a raw-pass false positive on a corpus file.
info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/opensubtitles/ru-medium.txt:1:1

file uses only 6 distinct printable characters ("!,-.:?") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
-Две недели не даешь мне прохода.
Вот и действуй, чем ты рискуешь?
Я думал, что сделаю тебя счастливой.
```
likely benign LLM, confidence 0.93 Plain Russian subtitle text flagged for limited character set.
Reasoning
The snippet is ordinary Russian dialogue with normal punctuation; the narrow charset flag is an artifact of the sampled excerpt or benchmark corpus, not obfuscation.
info ~~warn~~ → info by review long-line benchmarks/haystacks/pathological/defeat-simple-vector-freq.txt:1:1

line length 720056 characters (raw pass, confidence 0.65)
```
qjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjaz
```
likely benign LLM, confidence 0.93 Synthetic benchmark file with a very long repetitive line.
Reasoning
A benchmark haystack deliberately constructed to defeat frequency-based detectors; the long repetitive line is intentional test data, not shipped code.
info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector-freq.txt:1:1

file uses only 4 distinct printable characters ("ajqz") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
qjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjazqjaz
```
likely benign LLM, confidence 0.93 Synthetic repeated 'qjaz' pattern in a benchmark file.
Reasoning
This is a synthetic pathological benchmark input made of repeated characters; the narrow charset is by design for testing the scanner.
info ~~warn~~ → info by review long-line benchmarks/haystacks/pathological/defeat-simple-vector-repeated.txt:1:1

line length 720056 characters (raw pass, confidence 0.65)
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
```
likely benign LLM, confidence 0.93 Synthetic benchmark file of repeated 'z' characters.
Reasoning
Intentional synthetic benchmark haystack consisting of a single repeated character; it is test data for the scanner, not an attack payload.
info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector-repeated.txt:1:1

file uses only 2 distinct printable characters ("az") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
```
likely benign LLM, confidence 0.93 Synthetic 'az' repetition in a benchmark test file.
Reasoning
Two-character repetition in a benchmark haystack designed to stress detectors; no executable content is present.
info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/pathological/defeat-simple-vector.txt:1:1

file uses only 4 distinct printable characters ("abqz") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
qazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqazqaz
```
likely benign LLM, confidence 0.93 Synthetic repeated-pattern benchmark file.
Reasoning
A synthetic repeated 'qaz' pattern in a pathological benchmark directory; it is test input for the scanner and has no executable or obfuscated payload.
info ~~warn~~ → info by review long-line benchmarks/haystacks/pathological/repeated-rare-huge.txt:1:1

line length 500100 characters (raw pass, confidence 0.65)
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
```
likely benign LLM, confidence 0.93 Synthetic huge repeated-character benchmark file.
Reasoning
A 500 KB single-character line in a pathological benchmark haystack; it is deliberately constructed test data for detector performance, not malicious code.
info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/pathological/repeated-rare-huge.txt:1:1

file uses only 1 distinct printable characters ("z") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
```
likely benign LLM, confidence 0.97 Synthetic benchmark haystack consisting of repeated 'z' characters.
Reasoning
The file is a benchmark haystack of repeated 'z' characters used to test a search library's performance on pathological input. It is test data, not code, and the charset signal is an artifact of its synthetic construction.

info long-line benchmarks/haystacks/pathological/repeated-rare-small.txt:1:1

line length 1000 characters (raw pass, confidence 0.50)

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

info ~~warn~~ → info by review narrow-file-charset benchmarks/haystacks/pathological/repeated-rare-small.txt:1:1

file uses only 1 distinct printable characters ("z") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
```
likely benign LLM, confidence 0.97 Synthetic small benchmark haystack of repeated 'z' characters.
Reasoning
Same as the huge variant: a small pathological benchmark input of repeated 'z' characters, clearly generated test data with no executable content.
info ~~warn~~ → info by review encoding-base64 benchmarks/haystacks/sliceslice/haystack.txt:1:1

base64-like blob (1000 bytes, compression ratio 0.78) (raw pass, confidence 0.60)
```
I4BCeTWkpm1G1StV1WP8HKMX1IaRTslq88MOEg4nx7kWLaWYDRDYZrdTtsg26mz9S8DhYcd1ty35aPLyRZSeimOmPAroaqi861z44o35qP9GdrofuuHwdhSEeOg7E0L1KrTYgWZZrzyk7o0DVxw7vvmo6rVJ5T4lLMkesL1U6ObckS9oorPI5ZDm4Nk1ryh3AC8juZwJLcyWKveenfaVGaB42iYrOvrZGIMQG0OmA0k73ydw2mJawUzWE8O61MQpDm19JFaTgSJMkPs3yjY149knHg03uOBvb6d0hCmUbiHkRgFwH17cL7UJUlkggx55
```
likely benign LLM, confidence 0.95 Random base64-like filler text in a search benchmark haystack.
Reasoning
A raw base64-like random string in a benchmark haystack file used for substring search testing. The high compression ratio and random content are typical of generated benchmark data. Raw pass has a higher false-positive rate and nothing indicates it is decoded or executed.

info long-line benchmarks/haystacks/sliceslice/haystack.txt:1:1

line length 1000 characters (raw pass, confidence 0.50)

I4BCeTWkpm1G1StV1WP8HKMX1IaRTslq88MOEg4nx7kWLaWYDRDYZrdTtsg26mz9S8DhYcd1ty35aPLyRZSeimOmPAroaqi861z44o35qP9GdrofuuHwdhSEeOg7E0L1KrTYgWZZrzyk7o0DVxw7vvmo6rVJ5T4lLMkesL1U6ObckS9oorPI5ZDm4Nk1ryh3AC8juZwJLcyWKveenfaVGaB42iYrOvrZGIMQG0OmA0k73ydw2mJawUzWE8O61MQpDm19JFaTgSJMkPs3yjY149knHg03uOBvb6d0hCmUbiHkRgFwH17cL7UJUlkggx55

info ~~warn~~ → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7496:23

identifier `ĺͻ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
                                             INTERNAL REGISTER 
           Ķ         ĺͻ 
                                                             
           Ķ         ĺͼ 
```
dismissed LLM, confidence 0.95 Special Latin/Greek glyphs in an i386 reference text file's table layout.
Reasoning
The file is an i386 architecture reference document (text, not source code) containing Unicode box/drawing or table glyphs. The 'identifier' is just a decorative or special character in prose text, not a program identifier, so the mixed-script signal is a false positive from raw-pass character analysis.
info ~~warn~~ → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7498:23

identifier `ĺͼ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
                                                             
           Ķ         ĺͼ 
                                            ͼ
                          
```
dismissed LLM, confidence 0.95 Mixed Latin/Greek glyphs in an i386 reference text table.
Reasoning
Same document and pattern as the other i386 finding; the glyphs appear in a text reference table, not in executable code, so there is no identifier obfuscation.
info ~~warn~~ → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7506:23

identifier `ĺͻ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
                                             INTERNAL REGISTER 
           Ķ         ĺͻ 
                                                             
           Ķ         ĺͼ 
```
dismissed LLM, confidence 0.95 Repeated Latin/Greek glyphs in an i386 reference text table.
Reasoning
Repeats the same glyph sequence from line 7496 in the same non-code reference document; benign text content flagged by a raw character heuristic.
info ~~warn~~ → info by review unicode-mixed-script benchmarks/haystacks/sliceslice/i386.txt:7508:23

identifier `ĺͼ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
                                                             
           Ķ         ĺͼ 
                                            ͼ
           ͼ
```
dismissed LLM, confidence 0.95 Mixed Latin/Greek glyphs in an i386 reference text table.
Reasoning
Same as the other i386 findings: decorative glyphs in a plain text reference file, not a code identifier, so the mixed-script flag is a false positive.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/BurntSushi/memchr memchr && cd memchr
git checkout 2.8.3
disclude scan --severity info --diff 2.8.2 .