PyPI / grpcio / 1.84.1

grpcio 1.84.1

Source
https://github.com/grpc/grpc
Artifact scanned
grpcio-1.84.1.tar.gz (sdist · 12.8 MB · SHA-256 446e7876b9b9…)
Compared with
grpcio-1.84.0.tar.gz (0 signals introduced since)
Files
5027 scanned, 422 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 401 warn · 162 info
Scan time
119.4 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): the 120 most severe of 521 warn and critical signals (120 with a verdict); 120 demoted to info. The rest are unreviewed.
Disclude version
4.3.0
Scanned (UTC)
2026-10-23 11:29

Signals

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

  1. 7 rows of escape runs, lines 9290-9290 (first: 7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte)) (raw pass, confidence 0.65)

    _pyx_k_M_1_6_6_b_1_1_y_s_a_6_1[] = "\200\001\340\t\021\220\037\240\001\340\010\t\330\014\024\220M\240\021\240)\2501\330\014\023\2206\230\037\250\001\330\014\023\2206\230\021\230\"\320\034>\270b\300\001\300\021\330\014\023\2201\330\017\020\360\006\000\r\024\2201\330\017\020\360\n\000\r\020\320\017 \240\002\240!\330\020\
  2. string literal contains an embedded NUL followed by 198 more bytes of source (token pass, confidence 0.85)

    har __pyx_k_M_1_6_6_b_1_1_y_s_a_6_1[] = "\200\001\340\t\021\220\037\240\001\340\010\t\330\014\024\220M\240\021\240)\2501\330\014\023\2206\230\037\250\001\330\014\023\2206\230\021\230\"\320\034>\270b\300\001\300\021\330\014\023\2201\330\017\020\360\006\000\r\024\2201\330\017\020\360\n\000\r\020\320\017 \240\002\240!\330
  3. string literal contains an embedded NUL followed by 243 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_a_q_t_a_wa_4G1A_Q_2_q_Q[] = "\320\000\036\230a\330\004\007\200q\330\r\030\230\001\330\014\017\210t\220;\230a\330\020\021\330\014\017\320\017'\240w\250a\330\020\033\320\0334\260G\2701\270A\330\014\027\320\027+\250:\260Q\330\014\027\320\0272\260%\260q\330\014\027\320\027+\250:\260Q";
  4. 7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_a_q_t_a_wa_4G1A_Q_2_q_Q[] = "\320\000\036\230a\330\004\007\200q\330\r\030\230\001\330\014\017\210t\220;\230a\330\020\021\330\014\017\320\017'\240w\250a\330\020\033\320\0334\260G\2701\270A\330\014\027\320\027+\250:\260Q\330\014\027\320\0272\260%\260q\330\014\027\320\027+\250:\260Q";
  5. 8 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_a_q_t_a_wa_4G1A_Q_2_q_Q[] = "\320\000\036\230a\330\004\007\200q\330\r\030\230\001\330\014\017\210t\220;\230a\330\020\021\330\014\017\320\017'\240w\250a\330\020\033\320\0334\260G\2701\270A\330\014\027\320\027+\250:\260Q\330\014\027\320\0272\260%\260q\330\014\027\320\027+\250:\260Q";
  6. 8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_hk_A_1_kkmmn_4xq_7_awnA_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\2204\220x\230q\240\001\330\004\007\200|\2207\230!\330\010&\240a\240w\250n\270A\330\004\013\2101";
  7. string literal contains an embedded NUL followed by 203 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_hk_A_1_kkmmn_4xq_7_awnA_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\2204\220x\230q\240\001\330\004\007\200|\2207\230!\330\010&\240a\240w\250n\270A\330\004\013\2101";
  8. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_hk_A_1_kkmmn_4xq_7_awnA_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\2204\220x\230q\240\001\330\004\007\200|\2207\230!\330\010&\240a\240w\250n\270A\330\004\013\2101";
  9. 4 rows of escape runs, lines 9378-9380 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_uA_Jaq_T_Jaq_Q_wd_Jaq_awa[] = "\200!\330\004\007\200u\210A\330\006\014\210J\220a\220q\330\t\r\210T\220\021\330\006\014\210J\220a\220q\330\t\r\210Q\330\006\007\330\t\017\210w\220d\230!\330\006\014\210J\220a\220q\340\006\n\210,\220a\220w\230a";
  10. string literal contains an embedded NUL followed by 252 more bytes of source (token pass, confidence 0.85)

     __pyx_k_A_G1F_a_vWA_q_q_q_T_G1_T_A[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\017%\240T\250\021\250'\260\033\270G\3001\340\010\017\320\017%\240T\250\021\250'\260\033\270A";
  11. string literal contains an embedded NUL followed by 316 more bytes of source (token pass, confidence 0.85)

     __pyx_k_A_Q_L_Q_a_AQ_L_q_HA_A_a_vS[] = "\200A\360\014\000\t\r\320\014%\240Q\360\014\000\t\r\210L\230\001\230\034\240Q\330\014\026\220a\330\014\r\330\014\r\330\014\r\360\006\000\t\031\230\014\240A\240Q\330\010\014\210L\230\007\230q\240\001\330\010\024\220H\230A\340\010\020\320\020,\250A\330\014\020\220\001\330\014\026\
  12. string literal contains an embedded NUL followed by 131 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_q_1_9G1G3DAEVV_9G1G3DAYeST[] = "\320\004\037\230q\330\010\013\2101\330\014\r\360\n\000\r\021\220\013\2309\240G\2501\250G\3203D\300A\320EV\320V[\320[\\\340\014\020\220\013\2309\240G\2501\250G\3203D\300A\300Y\310e\320ST";
  13. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_1_9G1G3DAEVV_9G1G3DAYeST[] = "\320\004\037\230q\330\010\013\2101\330\014\r\360\n\000\r\021\220\013\2309\240G\2501\250G\3203D\300A\320EV\320V[\320[\\\340\014\020\220\013\2309\240G\2501\250G\3203D\300A\300Y\310e\320ST";
  14. 6 rows of escape runs, lines 9423-9423 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    _a_q_1[] = "\200!\330:;\330\004\016\210l\230!\2301\330\004\010\210\013\2207\230!\2301\340\004\"\240!\330\004\007\320\007\032\230'\240\021\330\006\n\210+\220W\230A\230Q\330\013\014\330\010\021\320\021+\2501\330\014\020\220\013\320\033-\320-?\270q\340\013\014\330\010\020\320\0207\260q\330\010\021\320\021+\2501\250D\260\0
  15. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_t4_3d_Jaq_G4q_Jaq_O1A_4_A_1[] = "\200!\360\006\000\005\010\200t\2104\210|\2303\230d\240!\330\006\014\210J\220a\220q\330\004\007\200}\220G\2304\230q\330\006\014\210J\220a\220q\330\004,\250O\2701\270A\330\004\013\2104\320\017,\250A\320-?\270|\3101";
  16. string literal contains an embedded NUL followed by 195 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_t4_3d_Jaq_G4q_Jaq_O1A_4_A_1[] = "\200!\360\006\000\005\010\200t\2104\210|\2303\230d\240!\330\006\014\210J\220a\220q\330\004\007\200}\220G\2304\230q\330\006\014\210J\220a\220q\330\004,\250O\2701\270A\330\004\013\2104\320\017,\250A\320-?\270|\3101";
  17. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    st char __pyx_k_A_G1F_a_vWA_q_q_q_34q_QR_34q[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\0173\2604\260q\270\007\270{\310'\320QR\340\010\017\320\0173\2604\260q\270\007\270{\310!";
  18. string literal contains an embedded NUL followed by 247 more bytes of source (token pass, confidence 0.85)

    _pyx_k_A_G1F_a_vWA_q_q_q_34q_QR_34q[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\0173\2604\260q\270\007\270{\310'\320QR\340\010\017\320\0173\2604\260q\270\007\270{\310!";
  19. 8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    30\010\022\220*\230D\240\013\2501\330\010\024\220L\240\001\240\021\330\010\022\220*\230A\330\010\013\2101\330\014\022\220!\330\014\020\220\007\220q\330\020\023\2201\220C\220w\230a\230{\250)\2601\260A\330\014\023\2201\340\014\023\2201";
  20. 5 rows of escape runs, lines 9452-9459 (first: 8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_hk_A_1_kkmmn_XQa_7_4A5J_XY_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\320\023%\240X\250Q\250a\330\004\007\200|\2207\230!\330\0104\260A\3205J\310.\320XY\330\004\013\2101";
  21. string literal contains an embedded NUL followed by 206 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_hk_A_1_kkmmn_XQa_7_4A5J_XY_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\320\023%\240X\250Q\250a\330\004\007\200|\2207\230!\330\0104\260A\3205J\310.\320XY\330\004\013\2101";
  22. string literal contains an embedded NUL followed by 207 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_hk_A_1_kkmmn_XQa_7_A_ZZhhi_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\320\023-\250X\260Q\260a\330\004\007\200|\2207\230!\330\010<\270A\320=Z\320Zh\320hi\330\004\013\2101";
  23. string literal contains an embedded NUL followed by 267 more bytes of source (token pass, confidence 0.85)

    _pyx_k_q_t1_Jaq_q_q_AT_a_q_A_q_Qit5[] = "\320\002\037\230q\360\020\000\005\010\200t\2101\330\006\014\210J\220a\220q\330\004\007\200q\330\006\n\320\n#\240?\260!\260<\270q\330\006\n\320\n$\240A\240T\250\021\330\004\010\210\016\220a\330\t\n\330\006\027\220q\230\004\230A\330\004\007\200q\340\006\n\320\n \240\005\240Q\240i\
  24. string literal contains an embedded NUL followed by 235 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_t4_3d_Jaq_G4q_Jaq_O1A_q_4_WX[] = "\200!\360\n\000\005\010\200t\2104\210|\2303\230d\240!\330\006\014\210J\220a\220q\330\004\007\200}\220G\2304\230q\330\006\014\210J\220a\220q\330\004,\250O\2701\270A\330\004\023\220<\230q\240\001\330\004\013\2104\320\017*\250!\320+=\270\\\310\036\320WX";
  25. 8 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    t char __pyx_k_T_1_Q_1_T_1A_8_A_A_8_MQ_1_MQa[] = "\200\001\360\006\000\003\006\200T\210\032\2201\320\024)\250\024\250Q\330\004\n\210)\2201\330\010\t\330\002\005\200T\210\030\220\021\220!\330\004\n\210)\2201\220A\330\002'\320'8\270\001\330\002\r\320\r$\240A\330\002\r\320\r$\240A\330\0028\270\001\330\002\016\320\016M\310
  26. string literal contains an embedded NUL followed by 373 more bytes of source (token pass, confidence 0.85)

    pyx_k_T_1_Q_1_T_1A_8_A_A_8_MQ_1_MQa[] = "\200\001\360\006\000\003\006\200T\210\032\2201\320\024)\250\024\250Q\330\004\n\210)\2201\330\010\t\330\002\005\200T\210\030\220\021\220!\330\004\n\210)\2201\220A\330\002'\320'8\270\001\330\002\r\320\r$\240A\330\002\r\320\r$\240A\330\0028\270\001\330\002\016\320\016M\310Q\330\004
  27. 7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    0\002\r\320\r$\240A\330\002\r\320\r$\240A\330\0028\270\001\330\002\016\320\016M\310Q\330\004\005\330\007\010\330\004\005\330\004\005\330\004\013\2101\340\002\r\320\r\036\320\036M\310Q\310a\330\002\t\210\021";
  28. string literal contains an embedded NUL followed by 361 more bytes of source (token pass, confidence 0.85)

    pyx_k_q_A_Q_1_aq_q_q_y_1_xwc_q_1A_q[] = "\200\001\360\n\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\017\320\017.\250a\250q\330\002\017\210q\330\002\003\330\004\017\320\017/\250q\260\001\260\021\330\004\007\200y\220\003\2201\330\006\007\330\004\007\200x\210w\220c\230\021\33
  29. 6 rows of escape runs, lines 9476-9477 (first: 8 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte)) (raw pass, confidence 0.65)

    01\330\002\017\320\017.\250a\250q\330\002\017\210q\330\002\003\330\004\017\320\017/\250q\260\001\260\021\330\004\007\200y\220\003\2201\330\006\007\330\004\007\200x\210w\220c\230\021\330\006\020\220\007\220q\230\010\240\010\250\001\330\002\033\2301\230A\330\002\t\210\036\320\027'\240q";
  30. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

     char __pyx_k_A_G1F_a_vWA_q_q_q_d_7_WA_d_7_Q[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\017.\250d\260!\2607\270+\300W\310A\340\010\017\320\017.\250d\260!\2607\270+\300Q";
  31. string literal contains an embedded NUL followed by 240 more bytes of source (token pass, confidence 0.85)

    yx_k_A_G1F_a_vWA_q_q_q_d_7_WA_d_7_Q[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\017.\250d\260!\2607\270+\300W\310A\340\010\017\320\017.\250d\260!\2607\270+\300Q";
  32. 5 rows of escape runs, lines 9520-9520 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

     char __pyx_k_q_t1A_8_q_q_AQ_s_1_I_1_1_k_q_8[] = "\200\001\340\002\023\220<\230q\240\001\330\002\027\220t\2301\230A\330\002'\320'8\270\001\330\002\r\210[\230\007\230q\240\001\330\002\r\210[\230\007\230q\240\001\330\002'\320'<\270A\270Q\330\002\r\320\r/\250s\260!\2601\330\002\r\320\r)\320)I\310\021\310!\330\002;\2701\33
  33. 7 rows of escape runs, lines 9524-9525 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    Rt5_S_1[] = "\200A\330\010\023\2204\220u\230C\230r\240\021\330\010\024\220A\330\r\021\220\021\330\014\r\330\020\023\2204\320\027,\250B\250a\330\024\030\230\013\2405\250\001\250\021\330\020\023\2204\320\027,\250C\250q\330\024\033\2301\360\010\000\021\035\230I\240R\240t\2505\260\001\330\020\023\220:\230S\240\001\330\024\
  34. string literal contains an embedded NUL followed by 83 more bytes of source (token pass, confidence 0.85)

    x_k_A_4uCr_A_4_Ba_5_4_Cq_1_IRt5_S_1[] = "\200A\330\010\023\2204\220u\230C\230r\240\021\330\010\024\220A\330\r\021\220\021\330\014\r\330\020\023\2204\320\027,\250B\250a\330\024\030\230\013\2405\250\001\250\021\330\020\023\2204\320\027,\250C\250q\330\024\033\2301\360\010\000\021\035\230I\240R\240t\2505\260\001\330\020\02
  35. string literal contains an embedded NUL followed by 249 more bytes of source (token pass, confidence 0.85)

    x_k_A_G1F_a_vWA_q_q_q_4q_RYYZ_4q_RS[] = "\200\001\360\010\000\005\r\210A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220A\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\017;\2704\270q\300\007\300{\320RY\320YZ\340\010\017\320\017;\2704\270q\300\007\300{\320RS";
  36. 8 consecutive `\NNN` octal escapes (entropy 3.0 bits/byte) (raw pass, confidence 0.65)

    char __pyx_k_T_D_D_PPTT__cckko_p_N_N_R_R_p_p[] = "\200\001\360\010\000\005\016\210T\320\021$\240D\320(<\270D\320@P\320PT\320T_\320_c\320ck\320ko\360\000\000p\001N\002\360\000\000N\002R\002\360\000\000R\002\\\002\360\000\000\\\002`\002\360\000\000`\002p\002\360\000\000p\002t\002\360\000\000t\002Q\003\360\000\000Q\003U\0
  37. string literal contains an embedded NUL followed by 1732 more bytes of source (token pass, confidence 0.85)

    x_k_T_D_D_PPTT__cckko_p_N_N_R_R_p_p[] = "\200\001\360\010\000\005\016\210T\320\021$\240D\320(<\270D\320@P\320PT\320T_\320_c\320ck\320ko\360\000\000p\001N\002\360\000\000N\002R\002\360\000\000R\002\\\002\360\000\000\\\002`\002\360\000\000`\002p\002\360\000\000p\002t\002\360\000\000t\002Q\003\360\000\000Q\003U\003\360\00
  38. 9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    \007\200q\330\010\017\320\017*\250$\250a\250w\260k\300\027\310\001\340\010\017\320\017*\250$\250a\250w\260k\300\021";
  39. 4 rows of escape runs, lines 9609-9609 (first: 8 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte)) (raw pass, confidence 0.65)

    \004\007\200t\2104\210q\330\006\014\210J\220a\220q\330\004\010\210\010\220\003\2206\230\024\230[\250\003\2501\330\006\014\210J\220a\220q\360\006\000\005\034\2301\330\004\007\200{\220#\220Q\330\006\n\210+\220W\230A\230Q\330\006\022\220!\330\013\014\330\010\021\320\021-\250Q\330\014\020\220\t\230\034\240[\260\001\330\006
  40. string literal contains an embedded NUL followed by 250 more bytes of source (token pass, confidence 0.85)

    x_k_l_1_t4q_Jaq_6_1_Jaq_1_Q_WAQ_Q_Q[] = "\200!\330()\330\016\017\330\004\016\210l\230!\2301\330\004\007\200t\2104\210q\330\006\014\210J\220a\220q\330\004\010\210\010\220\003\2206\230\024\230[\250\003\2501\330\006\014\210J\220a\220q\360\006\000\005\034\2301\330\004\007\200{\220#\220Q\330\006\n\210+\220W\230A\230Q\330\00
  41. string literal contains an embedded NUL followed by 442 more bytes of source (token pass, confidence 0.85)

    x_k_q_4t5_q_Ja_4xuCs_A_Ja_9_he1_HHA[] = "\320\004\027\220q\360\010\000\t\016\210\\\230\021\340\010\013\2104\210t\2205\230\001\330\014\023\220=\240\007\240q\250\004\250J\260a\340\010\013\2104\210x\220u\230C\230s\240*\250A\330\014\023\320\023*\250'\260\021\330\020\024\220J\230a\330\020\027\320\0279\270\021\270$\270h\300e
  42. 8 rows of escape runs, lines 9613-9615 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    HHA[] = "\320\004\027\220q\360\010\000\t\016\210\\\230\021\340\010\013\2104\210t\2205\230\001\330\014\023\220=\240\007\240q\250\004\250J\260a\340\010\013\2104\210x\220u\230C\230s\240*\250A\330\014\023\320\023*\250'\260\021\330\020\024\220J\230a\330\020\027\320\0279\270\021\270$\270h\300e\3101\330\020\024\220H\230H\240A
  43. string literal contains an embedded NUL followed by 494 more bytes of source (token pass, confidence 0.85)

    x_k_q_A_Q_1_2_1_A_q_y_1_xvS_T_1_HHA[] = "\200\001\360\n\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\017\320\0172\260!\2601\330\002\024\220A\330\002\003\330\004\017\320\017/\250q\260\001\260\021\330\004\007\200y\220\003\2201\330\006\007\330\004\007\200x\210v\220S\230\005\23
  44. string literal contains an embedded NUL followed by 340 more bytes of source (token pass, confidence 0.85)

    x_k_q_a_uG4vQ_B_CSSTTYY___wavWA_7xt[] = "\320\000?\270q\340\007\025\220[\240\006\240a\330\004\007\200u\210G\2204\220v\230Q\330\006\007\330\004\031\230\033\320$B\300!\320CS\320ST\320TY\320Y^\320^_\340\004\017\210w\220a\220v\230W\240A\320%7\260x\270t\3001\330\004\016\210g\220Q\220f\230G\2401\320$6\260g\270T\300\021\330\0
  45. 15 rows of escape runs, lines 9620-9623 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    7\200t\2107\220!\220:\230\\\250\023\250J\260a\260z\300\021\330\010\016\210i\220q\230\002\320\032G\320G_\320_`\330\004\010\210\010\220\001\330\010\013\2104\210z\230\021\230&\240\001\330\014\022\220)\2301\230B\320\036K\320Kc\320cd\330\010\013\2103\210a\210v\220S\230\001\330\014\022\220)\2301\230B\320\036K\320Kc\320cd\330
  46. string literal contains an embedded NUL followed by 224 more bytes of source (token pass, confidence 0.85)

    x_k_t_S_T_q_t1_4_c_Qa_l_4_7q_D_e1_d[] = "\200!\330\004\007\200t\210:\220S\230\001\330\006\t\210\024\210T\220\021\340\013\017\210q\340\013\017\210t\2201\330\010\013\2104\320\017&\240c\250\021\330\n\020\220\r\230Q\230a\360\006\000\013\017\210l\230!\2304\320\0377\260q\340\n\020\220\004\220D\230\001\330\014\020\320\020&\24
  47. string literal contains an embedded NUL followed by 497 more bytes of source (token pass, confidence 0.85)

    _k_A_1_t_Qa_U_t7_M_G6_G4q_M_a_87_uC[] = "\200A\340\010\013\2101\340\014\r\360\010\000\021\030\220t\230=\250\005\250Q\250a\330\023\024\360\n\000\t\n\330\014\020\220\r\230U\240!\330\014\017\210t\2207\230&\240\001\330\020\024\220M\240\027\250\001\330\020\021\340\020\030\230\004\230G\2406\250\021\330\020\024\220G\2304\230q
  48. string literal contains an embedded NUL followed by 254 more bytes of source (token pass, confidence 0.85)

    _k_A_4wa_AQ_7_t4q_j_Q_a_xq_j_0IIYYZ[] = "\200A\360\n\000./\360\014\000\t\014\2104\210w\220a\330\014\022\220*\230A\230Q\360\006\000\t\014\320\013#\2407\250!\330\014\017\210t\2204\220q\330\020\026\220j\240\001\240\021\340\014&\320&=\270Q\340\014&\240a\340\010\017\210x\220q\230\006\230j\250\010\3200I\320IY\320YZ";
  49. string literal contains an embedded NUL followed by 4 more bytes of source (token pass, confidence 0.85)

    TEST_F(DecodeRustPunycodeTest, RejectsEmbeddedNul) {
      punycode_ = std::string("foo\0bar_", 8);
    
      EXPECT_THAT(DecodeRustPunycode(WithAmpleSpace()), IsNull());
  50. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      EXPECT_EQ(value, "a\nb\nc");
      EXPECT_TRUE(absl::ParseFlag("asd\0fgh", &value, &err));
      EXPECT_EQ(value, "asd");
      EXPECT_TRUE(absl::ParseFlag("\\\\", &value, &err));
  51. base64-like blob (48 bytes, compression ratio 1.23) (raw pass, confidence 0.60)

      } cases[] = {
          {"VprUGNH+5NnNRaORxgH/ySrZFQFDL+4VAodhfBNinmn8cg==",
           uint64_t{0x531858a40bfa7ea1}},
          {"gc1xZaY+q0nPcUvOOnWnT3bqfmT/geth/f7Dm2e/DemMfk4=",
  52. base64-like blob (48 bytes, compression ratio 1.23) (raw pass, confidence 0.60)

           uint64_t{0x531858a40bfa7ea1}},
          {"gc1xZaY+q0nPcUvOOnWnT3bqfmT/geth/f7Dm2e/DemMfk4=",
           uint64_t{0x86689478a7a7e8fa}},
          {"Mr35fIxqx1ukPAL0su1yFuzzAU3wABCLZ8+ZUFsXn47UmAph",
  53. base64-like blob (52 bytes, compression ratio 1.21) (raw pass, confidence 0.60)

           uint64_t{0x4ec948b8e7f27288}},
          {"A9G8pw2+m7+rDtWYAdbl8tb2fT7FFo4hLi2vAsa5Y8mKH3CX3g==",
           uint64_t{0xce46c7213c10032}},
          {"DFaJGishGwEHDdj9ixbCoaTjz9KS0phLNWHVVdFsM93CvPft3hM=",
  54. base64-like blob (52 bytes, compression ratio 1.21) (raw pass, confidence 0.60)

           uint64_t{0xce46c7213c10032}},
          {"DFaJGishGwEHDdj9ixbCoaTjz9KS0phLNWHVVdFsM93CvPft3hM=",
           uint64_t{0xf63e96ee6f32a8b6}},
          {"7+Ugx+Kr3aRNgYgcUxru62YkTDt5Hqis+2po81hGBkcrJg4N0uuy",
  55. base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)

           uint64_t{0x1cfe85e65fc5225}},
          {"H2w6O8BUKqu6Tvj2xxaecxEI2wRgIgqnTTG1WwOgDSINR13Nm4d4Vg==",
           uint64_t{0x45c474f1cee1d2e8}},
          {"1XBMnIbqD5jy65xTDaf6WtiwtdtQwv1dCVoqpeKj+7cTR1SaMWMyI04=",
  56. base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)

           uint64_t{0x45c474f1cee1d2e8}},
          {"1XBMnIbqD5jy65xTDaf6WtiwtdtQwv1dCVoqpeKj+7cTR1SaMWMyI04=",
           uint64_t{0x6e024e14015f329c}},
          {"znZbdXG2TSFrKHEuJc83gPncYpzXGbAebUpP0XxzH0rpe8BaMQ17nDbt",
  57. base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)

           uint64_t{0x760c40502103ae1c}},
          {"ylu8Atu13j1StlcC1MRMJJXIl7USgDDS22HgVv0WQ8hx/8pNtaiKB17hCQ==",
           uint64_t{0x17fd05c3c560c320}},
          {"M6ZVVzsd7vAvbiACSYHioH/440dp4xG2mLlBnxgiqEvI/aIEGpD0Sf4VS0g=",
  58. base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)

           uint64_t{0x17fd05c3c560c320}},
          {"M6ZVVzsd7vAvbiACSYHioH/440dp4xG2mLlBnxgiqEvI/aIEGpD0Sf4VS0g=",
           uint64_t{0x8b34200a6f8e90d9}},
          {"li3oFSXLXI+ubUVGJ4blP6mNinGKLHWkvGruun85AhVn6iuMtocbZPVhqxzn",
  59. 7 rows of base64-like lines, lines 62-75 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

           uint64_t{0x6be89e50818bdf69}},
          {"kFuQHuUCqBF3Tc3hO4dgdIp223ShaCoog48d5Do5zMqUXOh5XpGK1t5XtxnfGA==",
           uint64_t{0xfb389773315b47d8}},
          {"jWmOad0v0QhXVJd1OdGuBZtDYYS8wBVHlvOeTQx9ZZnm8wLEItPMeihj72E0nWY=",
  60. base64-like blob (70 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

          {"RnpA/"
           "zJnEnnLjmICORByRVb9bCOgxF44p3VMiW10G7PvW7IhwsWajlP9kIwNA9FjAD2GoQHk2Q="
           "=",
           uint64_t{0xbd0291284a49b61c}},
  61. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           "Jf1+"
           "FbsbCpXWPTUSeWyMH6e4CvTFvPE5Fs6Z8hvFITGyr0dtukHzkI84oviVLxhM1xMxrMAy1db"
           "w==",
           uint64_t{0x2599f4f905115869}},
  62. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

           uint64_t{0x2599f4f905115869}},
          {"FvyQ00+j7nmYZVQ8hI1Edxd0AWplhTfWuFGiu34AK5X8u2hLX1bE97sZM0CmeLe+"
           "7LgoUT1fJ/axybE=",
           uint64_t{0xd8256e5444d21e53}},
  63. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          {"CDK0meI07yrgV2kQlZZ+"
           "wuVqhc2NmzqeLH7bmcA6kchsRWFPeVF5Wqjjaj556ABeUoUr3yBmfU3kWOakkg==",
           uint64_t{0x9625b859be372cd1}},
          {"d23/vc5ONh/"
  64. base64-like blob (65 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          {"d23/vc5ONh/"
           "HkMiq+gYk4gaCNYyuFKwUkvn46t+dfVcKfBTYykr4kdvAPNXGYLjM4u1YkAEFpJP+"
           "nX7eOvs=",
           uint64_t{0x7b99940782e29898}},
  65. base64-like blob (46 bytes, compression ratio 1.24) (raw pass, confidence 0.60)

          {"2BOFlcI3Z0RYDtS9T9Ie9yJoXlOdigpPeeT+CRujb/"
           "O39Ih5LPC9hP6RQk1kYESGyaLZZi3jtabHs7DiVx/VDg==",
           uint64_t{0xe2ccb09ac0f5b4b6}},
          {"FF2HQE1FxEvWBpg6Z9zAMH+Zlqx8S1JD/"
  66. base64-like blob (55 bytes, compression ratio 1.20) (raw pass, confidence 0.60)

          {"FF2HQE1FxEvWBpg6Z9zAMH+Zlqx8S1JD/"
           "wIlViL6ZDZY63alMDrxB0GJQahmAtjlm26RGLnjW7jmgQ4Ie3I+014=",
           uint64_t{0x7d0a37adbd7b753b}},
          {"tHmO7mqVL/PX11nZrz50Hc+M17Poj5lpnqHkEN+4bpMx/"
  67. 6 rows of base64-like lines, lines 124-138 (first: base64-like blob (65 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          {"/WiHi9IQcxRImsudkA/KOTqGe8/"
           "gXkhKIHkjddv5S9hi02M049dIK3EUyAEjkjpdGLUs+BN0QzPtZqjIYPOgwsYE9g==",
           uint64_t{0x4fb88ea63f79a0d8}},
          {"qds+1ExSnU11L4fTSDz/QE90g4Jh6ioqSh3KDOTOAo2pQGL1k/"
  68. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"oswxop+"
           "bthuDLT4j0PcoSKby4LhF47ZKg8K17xxHf74UsGCzTBbOz0MM8hQEGlyqDT1iUiAYnaPaUp"
           "L2mRK0rcIUYA4qLt5uOw==",
           uint64_t{0x9a767d5822c7dac4}},
  69. base64-like blob (67 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

           "697p+"
           "BtLSjxj5989OXI004TogEb94VUnDzOVSgMXie72cuYRvTFNIBgtXlKfkiUjeqVpd4a+"
           "n5bxNOD1TGrjQtzKU5r7obo=",
           uint64_t{0xee46254080d6e2db}},
  70. base64-like blob (65 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

           uint64_t{0xee46254080d6e2db}},
          {"E84YZW2qipAlMPmctrg7TKlwLZ68l4L+c0xRDUfyyFrA4MAti0q9sHq3TDFviH0Y+"
           "Kq3tEE5srWFA8LM9oomtmvm5PYxoaarWPLc",
           uint64_t{0xbbb669588d8bf398}},
  71. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           uint64_t{0xbbb669588d8bf398}},
          {"x3pa4HIElyZG0Nj7Vdy9IdJIR4izLmypXw5PCmZB5y68QQ4uRaVVi3UthsoJROvbjDJkP2D"
           "Q6L/eN8pFeLFzNPKBYzcmuMOb5Ull7w==",
           uint64_t{0xdc2afaa529beef44}},
  72. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          {"jVDKGYIuWOP/"
           "QKLdd2wi8B2VJA8Wh0c8PwrXJVM8FOGM3voPDVPyDJOU6QsBDPseoR8uuKd19OZ/"
           "zAvSCB+zlf6upAsBlheUKgCfKww=",
           uint64_t{0xf1f67391d45013a8}},
  73. base64-like blob (68 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

           uint64_t{0xf1f67391d45013a8}},
          {"mkquunhmYe1aR2wmUz4vcvLEcKBoe6H+kjUok9VUn2+eTSkWs4oDDtJvNCWtY5efJwg/"
           "j4PgjRYWtqnrCkhaqJaEvkkOwVfgMIwF3e+d",
           uint64_t{0x16fce2b8c65a3429}},
  74. base64-like blob (57 bytes, compression ratio 1.19) (raw pass, confidence 0.60)

          {"fRelvKYonTQ+s+rnnvQw+JzGfFoPixtna0vzcSjiDqX5s2Kg2//"
           "UGrK+AVCyMUhO98WoB1DDbrsOYSw2QzrcPe0+3ck9sePvb+Q/IRaHbw==",
           uint64_t{0xf4b096699f49fe67}},
          {"DUwXFJzagljo44QeJ7/"
  75. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"DUwXFJzagljo44QeJ7/"
           "6ZKw4QXV18lhkYT2jglMr8WB3CHUU4vdsytvw6AKv42ZcG6fRkZkq9fpnmXy6xG0aO3WPT1"
           "eHuyFirAlkW+zKtwg=",
           uint64_t{0xca584c4bc8198682}},
  76. base64-like blob (69 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

           uint64_t{0xed269fc3818b6aad}},
          {"EXeHBDfhwzAKFhsMcH9+2RHwV+mJaN01+9oacF6vgm8mCXRd6jeN9U2oAb0of5c5cO4i+"
           "Vb/LlHZSMI490SnHU0bejhSCC2gsC5d2K30ER3iNA==",
           uint64_t{0x33f253cbb8fe66a8}},
  77. base64-like blob (43 bytes, compression ratio 1.26) (raw pass, confidence 0.60)

          {"EXeHBDfhwzAKFhsMcH9+2RHwV+mJaN01+9oacF6vgm8mCXRd6jeN9U2oAb0of5c5cO4i+"
           "Vb/LlHZSMI490SnHU0bejhSCC2gsC5d2K30ER3iNA==",
           uint64_t{0x33f253cbb8fe66a8}},
          {"FzkzRYoNjkxFhZDso94IHRZaJUP61nFYrh5MwDwv9FNoJ5jyNCY/"
  78. base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)

          {"FzkzRYoNjkxFhZDso94IHRZaJUP61nFYrh5MwDwv9FNoJ5jyNCY/"
           "eazPZk+tbmzDyJIGw2h3GxaWZ9bSlsol/vK98SbkMKCQ/wbfrXRLcDzdd/8=",
           uint64_t{0xd0b76b2c1523d99c}},
          {"Re4aXISCMlYY/XsX7zkIFR04ta03u4zkL9dVbLXMa/q6hlY/CImVIIYRN3VKP4pnd0AUr/"
  79. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"ueLyMcqJXX+MhO4UApylCN9WlTQ+"
           "ltJmItgG7vFUtqs2qNwBMjmAvr5u0sAKd8jpzV0dDPTwchbIeAW5zbtkA2NABJV6hFM48ib"
           "4/J3A5mseA3cS8w==",
           uint64_t{0x6261fb136482e84}},
  80. base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)

          {"6Si7Yi11L+jZMkwaN+GUuzXMrlvEqviEkGOilNq0h8TdQyYKuFXzkYc/"
           "q74gP3pVCyiwz9KpVGMM9vfnq36riMHRknkmhQutxLZs5fbmOgEO69HglCU=",
           uint64_t{0x458efc750bca7c3a}},
          {"Q6AbOofGuTJOegPh9Clm/"
  81. base64-like blob (68 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

          {"Q6AbOofGuTJOegPh9Clm/"
           "9crtUMQqylKrTc1fhfJo1tqvpXxhU4k08kntL1RG7woRnFrVh2UoMrL1kjin+s9CanT+"
           "y4hHwLqRranl9FjvxfVKm3yvg68",
           uint64_t{0xa7e69ff84e5e7c27}},
  82. base64-like blob (57 bytes, compression ratio 1.19) (raw pass, confidence 0.60)

          {"ieQEbIPvqY2YfIjHnqfJiO1/MIVRk0RoaG/WWi3kFrfIGiNLCczYoklgaecHMm/"
           "1sZ96AjO+a5stQfZbJQwS7Sc1ODABEdJKcTsxeW2hbh9A6CFzpowP1A==",
           uint64_t{0x3c59bfd0c29efe9e}},
          {"zQUv8hFB3zh2GGl3KTvCmnfzE+"
  83. 6 rows of base64-like lines, lines 201-211 (first: base64-like blob (71 bytes, compression ratio 1.15)) (raw pass, confidence 0.60)

          {"US4hcC1+op5JKGC7eIs8CUgInjKWKlvKQkapulxW262E/"
           "B2ye79QxOexf188u2mFwwe3WTISJHRZzS61IwljqAWAWoBAqkUnW8SHmIDwHUP31J0p5sGd"
           "P47L",
           uint64_t{0x41d5320b0a38efa7}},
  84. base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)

           "8yyOw8lQabism19vOQxfmocEOW/"
           "vzY0pEa87qHrAZy4s9fH2Bltu8vaOIe+agYohhYORQ==",
           uint64_t{0xc419cfc7442190}},
          {"1UR5eoo2aCwhacjZHaCh9bkOsITp6QunUxHQ2SfeHv0imHetzt/"
  85. base64-like blob (45 bytes, compression ratio 1.24) (raw pass, confidence 0.60)

           "Z70mhyWZBalv6eAx+YfWKCUib2SHDtz/"
           "A2dc3hqUWX5VfAV7FQsghPUAtu6IiRatq4YSLpDvKZBQ=",
           uint64_t{0xc95e510d94ba270c}},
          {"opubR7H63BH7OtY+Avd7QyQ25UZ8kLBdFDsBTwZlY6gA/"
  86. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           "u+x+"
           "czC9AaZMgmQrUy15DH7YMGsvdXnviTtI4eVI4aF1H9Rl3NXMKZgwFOsdTfdcZeeHVRzBBKX"
           "8jUfh1il",
           uint64_t{0xff1ae05c98089c3f}},
  87. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           uint64_t{0xff1ae05c98089c3f}},
          {"DC0kXcSXtfQ9FbSRwirIn5tgPri0sbzHSa78aDZVDUKCMaBGyFU6BmrulywYX8yzvwprdLs"
           "oOwTWN2wMjHlPDqrvVHNEjnmufRDblW+nSS+xtKNs3N5xsxXdv6JXDrAB/Q==",
           uint64_t{0x90c02b8dceced493}},
  88. base64-like blob (61 bytes, compression ratio 1.18) (raw pass, confidence 0.60)

          {"DC0kXcSXtfQ9FbSRwirIn5tgPri0sbzHSa78aDZVDUKCMaBGyFU6BmrulywYX8yzvwprdLs"
           "oOwTWN2wMjHlPDqrvVHNEjnmufRDblW+nSS+xtKNs3N5xsxXdv6JXDrAB/Q==",
           uint64_t{0x90c02b8dceced493}},
          {"BXRBk+3wEP3Lpm1y75wjoz+PgB0AMzLe8tQ1AYU2/"
  89. 4 rows of base64-like lines, lines 232-239 (first: base64-like blob (59 bytes, compression ratio 1.19)) (raw pass, confidence 0.60)

           "oqrQB2YMC6W+9QDbcOfkGbeH+b7IBkt/"
           "gwCMw2HaQsRFEsurXtcQ3YwRuPz5XNaw5NAvrNa67Fm7eRzdE1+hWLKtA8=",
           uint64_t{0x9f8a76697ab1aa36}},
          {"RRBSvEGYnzR9E45Aps/+WSnpCo/X7gJLO4DRnUqFrJCV/kzWlusLE/"
  90. 4 rows of base64-like lines, lines 243-250 (first: base64-like blob (68 bytes, compression ratio 1.16)) (raw pass, confidence 0.60)

           "wrUXpltlKy2dSBcmK15fOY092CR7KxAjNfaY+"
           "aAmtWbbzQk3MjBg03x39afSUN1fkrWACdyQKRaGxgwq6MGNxI6W+8DLWJBHzIXrntrE/"
           "ml6fnNXEpxplWJ1vEs4=",
           uint64_t{0x8472f1c2b3d230a3}},
  91. 4 rows of base64-like lines, lines 255-260 (first: base64-like blob (44 bytes, compression ratio 1.25)) (raw pass, confidence 0.60)

           "95V7nIW38v7PpzhnTWIml5kw3So1Si0TXtIUPIbsu32BNhoH7QwFvLM+"
           "JACgSpc5e3RjsL6Qwxxi11npwxRmRUqATDeMUfRAjxg=",
           uint64_t{0x5501cfd83dfe706a}},
          {"QC9i2GjdTMuNC1xQJ74ngKfrlA4w3o58FhvNCltdIpuMhHP1YsDA78scQPLbZ3OCUgeQguY"
  92. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"kUw/0z4l3a89jTwN5jpG0SHY5km/"
           "IVhTjgM5xCiPRLncg40aqWrJ5vcF891AOq5hEpSq0bUCJUMFXgct7kvnys905HjerV7Vs1G"
           "y84tgVJ70/2+pAZTsB/PzNOE/G6sOj4+GbTzkQu819OLB",
           uint64_t{0xd52a18abb001cb46}},
  93. 7 rows of base64-like lines, lines 274-285 (first: base64-like blob (45 bytes, compression ratio 1.24)) (raw pass, confidence 0.60)

           "VnA9kfi2C79ENnFnbOReeuZW1b3MUXB9lgC6U4pOTuC+"
           "jHK3Qnpyiqzj7h3ISJSuo2pob7vY6VHZo6Fn7exEqHg==",
           uint64_t{0xe12b76a2433a1236}},
          {"Ldfvy3ORdquM/R2fIkhH/ONi69mcP1AEJ6n/"
  94. base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)

           "81ZoHBFhEBrCdogKqeK+hy9bLDnx7g6rAFUjtn1+cWzQ2YjiOpz4+"
           "ROBB7lnwjyTGWzJD1rXtlso1g2qVH8XJVigC5M9AIxM=",
           uint64_t{0x53d061e5f8e7c04f}},
          {"IWQBelSQnhrr0F3BhUpXUIDauhX6f95Qp+A0diFXiUK7irwPG1oqBiqHyK/SH/"
  95. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           "9S+"
           "rln9DlFROAmeFdH0OCJi2tFm4afxYzJTFR4HnR4cG4x12JqHaZLQx6iiu6CE3rtWBVz99oA"
           "wCZUOEXIsLU24o2Y",
           uint64_t{0xdb4124556dd515e0}},
  96. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"TKo+l+"
           "1dOXdLvIrFqeLaHdm0HZnbcdEgOoLVcGRiCbAMR0j5pIFw8D36tefckAS1RCFOH5IgP8yiF"
           "T0Gd0a2hI3+"
           "fTKA7iK96NekxWeoeqzJyctc6QsoiyBlkZerRxs5RplrxoeNg29kKDTM0K94mnhD9g==",
  97. base64-like blob (68 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

           "T0Gd0a2hI3+"
           "fTKA7iK96NekxWeoeqzJyctc6QsoiyBlkZerRxs5RplrxoeNg29kKDTM0K94mnhD9g==",
           uint64_t{0x4fb31a0dd681ee71}},
          {"YU4e7G6EfQYvxCFoCrrT0EFgVLHFfOWRTJQJ5gxM3G2b+"
  98. base64-like blob (53 bytes, compression ratio 1.21) (raw pass, confidence 0.60)

           "1kJf9YPrpsxF6Xr6nYtS8reEEbDoZJYqnlk9lXSkVArm88Cqn6d25VCx3+"
           "49MqC0trIlXtb7SXUUhwpJK16T0hJUfPH7s5cMZXc6YmmbFuBNPE=",
           uint64_t{0x27cc72eefa138e4c}},
          {"/I/"
  99. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           "eImMwPo1U6wekNFD1Jxjk9XQVi1D+"
           "FPdqcHifYXQuP5aScNQfxMAmaPR2XhuOQhADV5tTVbBKwCDCX4E3jcDNHzCiPvViZF1W27t"
           "xaf2BbFQdwKrNCmrtzcluBFYu0XZfc7RU1RmxK/RtnF1qHsq/O4pp",
           uint64_t{0x44bc2dfba4bd3ced}},
  100. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           uint64_t{0x44bc2dfba4bd3ced}},
          {"CJTT9WGcY2XykTdo8KodRIA29qsqY0iHzWZRjKHb9alwyJ7RZAE3V5Juv4MY3MeYEr1EPCC"
           "MxO7yFXqT8XA8YTjaMp3bafRt17Pw8JC4iKJ1zN+WWKOESrj+"
           "3aluGQqn8z1EzqY4PH7rLG575PYeWsP98BugdA==",
  101. base64-like blob (40 bytes, compression ratio 1.27) (raw pass, confidence 0.60)

           "MxO7yFXqT8XA8YTjaMp3bafRt17Pw8JC4iKJ1zN+WWKOESrj+"
           "3aluGQqn8z1EzqY4PH7rLG575PYeWsP98BugdA==",
           uint64_t{0x242da1e3a439bed8}},
          {"ZlhyQwLhXQyIUEnMH/"
  102. base64-like blob (41 bytes, compression ratio 1.27) (raw pass, confidence 0.60)

           "EpZRtA47ibZDVS8TtaxwyBjuIDwqcN09eCtpC+Ls+"
           "vWDTLmBeDM3u4hmzz4DQAYsLiZYSJcldg9Q3wszw=",
           uint64_t{0xdc559c746e35c139}},
          {"v2KU8y0sCrBghmnm8lzGJlwo6D6ObccAxCf10heoDtYLosk4ztTpLlpSFEyu23MLA1tJkcg"
  103. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

           uint64_t{0xdc559c746e35c139}},
          {"v2KU8y0sCrBghmnm8lzGJlwo6D6ObccAxCf10heoDtYLosk4ztTpLlpSFEyu23MLA1tJkcg"
           "Rko04h19QMG0mOw/"
           "wc93EXAweriBqXfvdaP85sZABwiKO+6rtS9pacRVpYYhHJeVTQ5NzrvBvi1huxAr+"
  104. base64-like blob (65 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

           "Rko04h19QMG0mOw/"
           "wc93EXAweriBqXfvdaP85sZABwiKO+6rtS9pacRVpYYhHJeVTQ5NzrvBvi1huxAr+"
           "xswhVMfL",
           uint64_t{0xd0b0350275b9989}},
  105. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"QhKlnIS6BuVCTQsnoE67E/"
           "yrgogE8EwO7xLaEGei26m0gEU4OksefJgppDh3X0x0Cs78Dr9IHK5b977CmZlrTRmwhlP8p"
           "M+UzXPNRNIZuN3ntOum/QhUWP8SGpirheXENWsXMQ/"
           "nxtxakyEtrNkKk471Oov9juP8oQ==",
  106. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"/ZRMgnoRt+Uo6fUPr9FqQvKX7syhgVqWu+"
           "WUSsiQ68UlN0efSP6Eced5gJZL6tg9gcYJIkhjuQNITU0Q3TjVAnAcobgbJikCn6qZ6pRxK"
           "BY4MTiAlfGD3T7R7hwJwx554MAy++Zb/YUFlnCaCJiwQMnowF7aQzwYFCo=",
           uint64_t{0x2217285eb4572156}},
  107. base64-like blob (59 bytes, compression ratio 1.19) (raw pass, confidence 0.60)

           "WUSsiQ68UlN0efSP6Eced5gJZL6tg9gcYJIkhjuQNITU0Q3TjVAnAcobgbJikCn6qZ6pRxK"
           "BY4MTiAlfGD3T7R7hwJwx554MAy++Zb/YUFlnCaCJiwQMnowF7aQzwYFCo=",
           uint64_t{0x2217285eb4572156}},
          {"NB7tU5fNE8nI+SXGfipc7sRkhnSkUF1krjeo6k+8FITaAtdyz+"
  108. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

           uint64_t{0x81826b553954464e}},
          {"VsSAw72Ro6xks02kaiLuiTEIWBC5bgqr4WDnmP8vglXzAhixk7td926rm9jNimL+"
           "kroPSygZ9gl63aF5DCPOACXmsbmhDrAQuUzoh9ZKhWgElLQsrqo1KIjWoZT5b5QfVUXY9lS"
           "IBg3U75SqORoTPq7HalxxoIT5diWOcJQi",
  109. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"VsSAw72Ro6xks02kaiLuiTEIWBC5bgqr4WDnmP8vglXzAhixk7td926rm9jNimL+"
           "kroPSygZ9gl63aF5DCPOACXmsbmhDrAQuUzoh9ZKhWgElLQsrqo1KIjWoZT5b5QfVUXY9lS"
           "IBg3U75SqORoTPq7HalxxoIT5diWOcJQi",
           uint64_t{0xc2e5d345dc0ddd2d}},
  110. base64-like blob (70 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

          {"j+loZ+C87+"
           "bJxNVebg94gU0mSLeDulcHs84tQT7BZM2rzDSLiCNxUedHr1ZWJ9ejTiBa0dqy2I2ABc++"
           "xzOLcv+//YfibtjKtYggC6/3rv0XCc7xu6d/"
           "O6xO+XOBhOWAQ+IHJVHf7wZnDxIXB8AUHsnjEISKj7823biqXjyP3g==",
  111. base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)

           "xzOLcv+//YfibtjKtYggC6/3rv0XCc7xu6d/"
           "O6xO+XOBhOWAQ+IHJVHf7wZnDxIXB8AUHsnjEISKj7823biqXjyP3g==",
           uint64_t{0x3da6830a9e32631e}},
          {"f3LlpcPElMkspNtDq5xXyWU62erEaKn7RWKlo540gR6mZsNpK1czV/"
  112. base64-like blob (70 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

           "sOmqaq8XAQLEn68LKj6/"
           "cFkJukxRzCa4OF1a7cCAXYFp9+wZDu0bw4y63qbpjhdCl8GO6Z2lkcXy7KOzbPE01ukg7+"
           "gN+7uKpoohgAhIwpAKQXmX5xtd0=",
           uint64_t{0xc9ae5c8759b4877a}},
  113. base64-like blob (40 bytes, compression ratio 1.27) (raw pass, confidence 0.60)

      constexpr char kEncodedPositiveControl[] =
          "U3RyaXBwaW5nVGVzdC5Qb3NpdGl2ZUNvbnRyb2w=";
      const std::string encoded_negative_control =
          absl::Base64Escape("StrippingTest.NegativeControl");
  114. base64-like blob (40 bytes, compression ratio 1.27) (raw pass, confidence 0.60)

      // won't encode to `kEncodedPositiveControl`.
      EXPECT_THAT(Base64UnescapeOrDie("U3RyaXBwaW5nVGVzdC5Qb3NpdGl2ZUNvbnRyb2w="),
                  Eq("StrippingTest.PositiveControl"));
  115. string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

      const absl::CharSet lets(absl::string_view("^abcde", 3));
      const absl::CharSet lets2(absl::string_view("fghij\0klmnop", 10));
      const absl::CharSet lets3("fghij\0klmnop");
      EXPECT_TRUE(lets2.contains('k'));
  116. string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

      const absl::CharSet lets2(absl::string_view("fghij\0klmnop", 10));
      const absl::CharSet lets3("fghij\0klmnop");
      EXPECT_TRUE(lets2.contains('k'));
      EXPECT_FALSE(lets3.contains('k'));
  117. string literal contains an embedded NUL followed by 4 more bytes of source (token pass, confidence 0.85)

          std::string("xxxx\r\t'\"\\"),
          std::string("\0xx\0", 4),
          std::string("\x01\x31"),
          std::string("abc\xb\x42\141bc"),
  118. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

          {"signi\\\\fying\\\\ nothing\\\\", "signi\\fying\\ nothing\\"},
          {"\\010\\t\\n\\013\\014\\r", "\010\011\012\013\014\015"}
      };
      epair hex_values[] = {
  119. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

          {"hel\\\\ter\\\\skel\\\\ter\\\\", "hel\\ter\\skel\\ter\\"},
          {"\\x08\\t\\n\\x0b\\x0c\\r", "\010\011\012\013\014\015"}
      };
      epair utf8_oct_values[] = {
  120. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

          {"\xed\x81\xac\xeb\xa1\xac\\010\\t\\n\\013\\014\\r",
           "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
      };
      epair utf8_hex_values[] = {
  121. 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

          {"\xed\x81\xac\xeb\xa1\xac\\x08\\t\\n\\x0b\\x0c\\r",
           "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
      };
  122. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

      // converted to the equivalent characters.
      EXPECT_EQ(std::string("\0\n"
                            "0\n"
                            "\0\n"
  123. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

                            "0\n"
                            "\0\n"
                            "\0",
                            7),
  124. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

      EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
      EXPECT_EQ(std::string("\0\n"
                            "0\n"
                            "\0\n"
  125. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

                            "0\n"
                            "\0\n"
                            "\0",
                            7),
  126. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

      EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
      EXPECT_EQ(std::string("\0\n"
                            "0\n"
                            "\0",
  127. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      {
        absl::string_view data_set[] = {"ab-/", absl::string_view("\0bcd", 4),
                                        absl::string_view("abc.\0", 5)};
        for (absl::string_view bad_data : data_set) {
  128. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

    TEST(MatchTest, StartsWith) {
      const std::string s1("123\0abc", 7);
      const absl::string_view a("foobar");
      const absl::string_view b(s1);
  129. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

    TEST(MatchTest, EndsWith) {
      const std::string s1("123\0abc", 7);
      const absl::string_view a("foobar");
      const absl::string_view b(s1);
  130. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      const absl::string_view sv("foo");
      const absl::string_view sv2("foo\0bar", 4);
      EXPECT_EQ(s, "foo");
      EXPECT_EQ(sv, "foo");
  131. `snprintf` called with a non-literal format string (format-string bug pattern) (ast pass, confidence 0.80)

        char buf[4096]{};
        snprintf(buf, sizeof(buf), fmt, 123);
        EXPECT_EQ(
            str_format_internal::FormatPack(
  132. string literal contains an embedded NUL followed by 4 more bytes of source (token pass, confidence 0.85)

        // delimiter.
        std::string embedded_nulls("a\0b\0c", 5);
        std::string null_delim("\0", 1);
        std::vector<std::string> v = absl::StrSplit(embedded_nulls, null_delim);
  133. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      const absl::string_view a("foobar");
      const absl::string_view b("123\0abc", 7);
      const absl::string_view e;
      EXPECT_TRUE(a.starts_with(a));
  134. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      const absl::string_view a("foobar");
      const absl::string_view b("123\0abc", 7);
      const absl::string_view e;
      EXPECT_TRUE(a.ends_with(a));
  135. two identifiers collapse to visual skeleton `to` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

      const time_zone utc = utc_time_zone();
      const auto t0 = chrono::system_clock::from_time_t(0);
    
      ExpectTime(chrono::time_point_cast<chrono::nanoseconds>(t0), utc, 1970, 1, 1,
  136. warn identifier-confusable-collision third_party/abseil-cpp/absl/time/time_test.cc:96:24

    two identifiers collapse to visual skeleton `to` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

                    "Time is documented as being trivially destructible");
      constexpr absl::Time t0 = absl::UnixEpoch();
      static_assert(t0 == absl::UnixEpoch(), "UnixEpoch");
      constexpr absl::Time t1 = absl::InfiniteFuture();
  137. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

      // Writes can include embedded NULs.
      ASSERT_EQ(BIO_write(bio.get(), "\0ghijk", 6), 6);
      check_bio_contents(Bytes("abcdef\0ghijk", 12));
      EXPECT_EQ(BIO_eof(bio.get()), 0);
  138. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

      ASSERT_EQ(BIO_write(bio.get(), "\0ghijk", 6), 6);
      check_bio_contents(Bytes("abcdef\0ghijk", 12));
      EXPECT_EQ(BIO_eof(bio.get()), 0);
  139. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

      EXPECT_EQ(Bytes(buf, ret), Bytes("abcd"));
      check_bio_contents(Bytes("ef\0ghijk", 8));
      EXPECT_EQ(BIO_eof(bio.get()), 0);
  140. string literal contains an embedded NUL followed by 11 more bytes of source (token pass, confidence 0.85)

      ASSERT_EQ(BIO_write(bio.get(), "lmnopq", 6), 6);
      check_bio_contents(Bytes("ef\0ghijklmnopq", 14));
      EXPECT_EQ(BIO_eof(bio.get()), 0);
  141. string literal contains an embedded NUL followed by 1 more bytes of source (token pass, confidence 0.85)

      ASSERT_GT(ret, 0);
      EXPECT_EQ(Bytes(buf, ret), Bytes("ef\0g", 4));
      check_bio_contents(Bytes("hijklmnopq"));
      EXPECT_EQ(BIO_eof(bio.get()), 0);
  142. string literal contains an embedded NUL followed by 8 more bytes of source (token pass, confidence 0.85)

          // NUL bytes do not terminate gets.
          {std::string("abc\0def\nghi", 11), 256, std::string("abc\0def\n", 8)},
    
          // An output size of one means we cannot read any bytes. Only the trailing
  143. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

          // NUL bytes do not terminate gets.
          {std::string("abc\0def\nghi", 11), 256, std::string("abc\0def\n", 8)},
    
          // An output size of one means we cannot read any bytes. Only the trailing
  144. base64-like blob (132 bytes over 3 lines, compression ratio 1.02) (raw pass, confidence 0.60)

    -----BEGIN DSA PRIVATE KEY-----
    MGECAQACFQHH+MnFXh4NNlZiV/zUVb5a5ib3kwIVAOP8ZOKvDwabKzEr/moq3y1z
    E3vJAhUAl/2Ylx9fWbzHdh1URsc/c6IM/TECAQECFCsjU4AZRcuks45g1NMOUeCB
    Epvg
  145. base64-like blob (1136 bytes over 18 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN DSA PRIVATE KEY-----
    MIIDTgIBAAKCAQEAyH68EuravtF+7PTFBtWJkwjmp0YJmh8e2Cdpu8ci3dZf87rk
    GwXzfqYkAEkW5H4Hp0cxdICKFiqfxjSaiEauOrNV+nXWZS634hZ9H47I8HnAVS0p
    5MmSmPJ7NNUowymMpyB6M6hfqHl/1pZd7avbTmnzb2SZ0kw0WLWJo6vMekepYWv9
  146. string literal contains an embedded NUL followed by 4 more bytes of source (token pass, confidence 0.85)

    
      ASSERT_TRUE(PKCS5_PBKDF2_HMAC("pass\0word", 9, (const uint8_t *)"sa\0lt", 5,
                                    4096, EVP_sha1(), sizeof(kKey3), key));
      EXPECT_EQ(Bytes(kKey3), Bytes(key, sizeof(kKey3)));
  147. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

    
      ASSERT_TRUE(PKCS5_PBKDF2_HMAC("pass\0word", 9, (const uint8_t *)"sa\0lt", 5,
                                    4096, EVP_sha1(), sizeof(kKey3), key));
      EXPECT_EQ(Bytes(kKey3), Bytes(key, sizeof(kKey3)));
  148. base64-like blob (300 bytes over 5 lines, compression ratio 0.84) (raw pass, confidence 0.60)

    -----BEGIN ENCRYPTED PRIVATE KEY-----
    MIHeMEkGCSqGSIb3DQEFDTA8MBsGCSqGSIb3DQEFDDAOBAjnhMUlb9deeQICCAAw
    HQYJYIZIAWUDBAECBBAO8j5GA5VK8wjvNrzp/iVhBIGQyQKFfFKlFhxiDkFfyhUc
    nPLr0eboQOz8eIaTW1Rblo/qDkQwNtONyfYn909SoIP7iU8UehcBG1UQe41WvQpu
  149. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  150. base64-like blob (332 bytes over 6 lines, compression ratio 0.83) (raw pass, confidence 0.60)

    -----BEGIN ENCRYPTED PRIVATE KEY-----
    MIH0MF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBAXiHC8iDcjzF0I+D2g
    zJOcAgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFlAwQBAgQQwupOMi8DtEWiuXt5
    Odla9QSBkC37uJuG7HSCOyTVCEW76Kmf7GoH+Ou17bDAp6NGwm3KLxRfFoExki9g
  151. base64-like blob (172 bytes over 3 lines, compression ratio 0.94) (raw pass, confidence 0.60)

    
    yfJKjep7Koj8hU/PtGC+NNXSNbItQ2zyeXDMVoazffraoDGMg6g1hFPPjg9reC+J
    iQQIf9uACF27zi9fpWwbszszimrxl0u6n0ddBXizcK6xzkTvk3PZ67Vz1KYmotwC
    XjgdgSEeixwKhDOuHKFdlFGP/7sw5GHlK3jPSpqi2gI=
  152. base64-like blob (184 bytes over 3 lines, compression ratio 0.90) (raw pass, confidence 0.60)

    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ
    TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N
    Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB
  153. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  154. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  155. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  156. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  157. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  158. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  159. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  160. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  161. 21 rows of base64-like lines, lines 36-56 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

        "-----BEGIN PKCS7-----\n"
        "MIID+wYJKoZIhvcNAQcCoIID7DCCA+gCAQExADALBgkqhkiG9w0BBwGgggPQMIID\n"
        "zDCCArSgAwIBAgIIWesoywKxoNQwDQYJKoZIhvcNAQELBQAwSTELMAkGA1UEBhMC\n"
        "VVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRlcm5l\n"
  162. 19 rows of base64-like lines, lines 64-82 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

        "-----BEGIN PKCS7-----\n"
        "MIIDhQYJKoZIhvcNAQcCoIIDdjCCA3ICAQExADALBgkqhkiG9w0BBwGgAKGCA1gw\n"
        "ggNUMIICvTANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJVUzEQMA4GA1UEChMH\n"
        "RXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0\n"
  163. base64-like blob (572 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpzCBkAIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV
  164. base64-like blob (600 bytes over 10 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBvjCBpwIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEyNDRaFw0xNjEwMjYxNTEyNDRaMBUwEwICEAAX
  165. two identifiers collapse to visual skeleton `pubo_precomp` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

                                       &method->h_precomp, &key->y0, NULL, NULL) ||
          !ec_init_precomp(group, &key->pub0_precomp, &pub[0]) ||
          !ec_point_mul_scalar_precomp(group, &pub[1], &method->g_precomp, &key->x1,
                                       &method->h_precomp, &key->y1, NULL, NULL) ||
  166. two identifiers collapse to visual skeleton `idx_Koo` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

        idx_Kb1,
        idx_Ko0,
        idx_Ko1,
        num_idx,
  167. two identifiers collapse to visual skeleton `idx_Ko|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

        idx_Ko0,
        idx_Ko1,
        num_idx,
      };
  168. two identifiers collapse to visual skeleton `minus_co` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

    
      EC_SCALAR k0, k1, minus_co, uo, vo;
      if (  // k0, k1 <- Zp
          !ec_random_nonzero_scalar(group, &k0, kDefaultAdditionalData) ||
  169. two identifiers collapse to visual skeleton `uo` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

    
      EC_SCALAR k0, k1, minus_co, uo, vo;
      if (  // k0, k1 <- Zp
          !ec_random_nonzero_scalar(group, &k0, kDefaultAdditionalData) ||
  170. two identifiers collapse to visual skeleton `vo` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

    
      EC_SCALAR k0, k1, minus_co, uo, vo;
      if (  // k0, k1 <- Zp
          !ec_random_nonzero_scalar(group, &k0, kDefaultAdditionalData) ||
  171. two identifiers collapse to visual skeleton `co` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

      // Select c, u, v in constant-time.
      EC_SCALAR co, c0, c1, u0, u1, v0, v1;
      ec_scalar_neg(group, &co, &minus_co);
      ec_scalar_select(group, &c0, mask, &co, &cb);
  172. base64-like blob (840 bytes over 14 lines, compression ratio 0.70) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICcTCCAdqgAwIBAgIIagJHiPvE0MowDQYJKoZIhvcNAQELBQAwPDEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxHjAcBgNVBAMTFUNyb3NzLXNpZ25pbmcgUm9v
    dCBDQTAgFw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowPDEaMBgGA1UE
  173. base64-like blob (804 bytes over 13 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICVTCCAb6gAwIBAgIIAj5CwoHlWuYwDQYJKoZIhvcNAQELBQAwLjEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxEDAOBgNVBAMTB1Jvb3QgQ0EwIBcNMTUwMTAx
    MDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMC4xGjAYBgNVBAoTEUJvcmluZ1NTTCBU
  174. base64-like blob (820 bytes over 13 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICYzCCAcygAwIBAgIIAj5CwoHlWuYwDQYJKoZIhvcNAQELBQAwPDEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxHjAcBgNVBAMTFUNyb3NzLXNpZ25pbmcgUm9v
    dCBDQTAgFw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowLjEaMBgGA1UE
  175. base64-like blob (816 bytes over 13 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICXjCCAcegAwIBAgIJAKJMH+7rscPcMA0GCSqGSIb3DQEBCwUAMC4xGjAYBgNV
    BAoTEUJvcmluZ1NTTCBURVNUSU5HMRAwDgYDVQQDEwdSb290IENBMCAXDTE1MDEw
    MTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjA2MRowGAYDVQQKExFCb3JpbmdTU0wg
  176. base64-like blob (824 bytes over 13 lines, compression ratio 0.70) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICZjCCAc+gAwIBAgIJAKJMH+7rscPcMA0GCSqGSIb3DQEBCwUAMDYxGjAYBgNV
    BAoTEUJvcmluZ1NTTCBURVNUSU5HMRgwFgYDVQQDEw9JbnRlcm1lZGlhdGUgQ0Ew
    IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDYxGjAYBgNVBAoTEUJv
  177. base64-like blob (816 bytes over 13 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICXjCCAcegAwIBAgIIWjO48ufpunYwDQYJKoZIhvcNAQELBQAwNjEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxGDAWBgNVBAMTD0ludGVybWVkaWF0ZSBDQTAg
    Fw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowMjEaMBgGA1UEChMRQm9y
  178. base64-like blob (760 bytes over 12 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICNTCCAZ6gAwIBAgIJAIFQGaLQ0G2mMA0GCSqGSIb3DQEBCwUAMDYxGjAYBgNV
    BAoTEUJvcmluZ1NTTCBURVNUSU5HMRgwFgYDVQQDEw9JbnRlcm1lZGlhdGUgQ0Ew
    IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDcxGjAYBgNVBAoTEUJv
  179. base64-like blob (828 bytes over 13 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICZzCCAdCgAwIBAgIIdTlMzQoKkeMwDQYJKoZIhvcNAQELBQAwNzEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxGTAXBgNVBAMTEGV2aWwuZXhhbXBsZS5jb20w
    IBcNMTUwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMDoxGjAYBgNVBAoTEUJv
  180. base64-like blob (1188 bytes over 19 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIDdjCCAjqgAwIBAgIJANcwZLyfEv7DMD4GCSqGSIb3DQEBCjAxoA0wCwYJYIZI
    AWUDBAIBoRowGAYJKoZIhvcNAQEIMAsGCWCGSAFlAwQCAaIEAgIA3jAnMSUwIwYD
    VQQDDBxUZXN0IEludmFsaWQgUFNTIGNlcnRpZmljYXRlMB4XDTE1MTEwNDE2MDIz
  181. base64-like blob (816 bytes over 13 lines, compression ratio 0.80) (raw pass, confidence 0.60)

    -----BEGIN RSA PRIVATE KEY-----
    MIICXgIBAAKBgQDYK8imMuRi/03z0K1Zi0WnvfFHvwlYeyK9Na6XJYaUoIDAtB92
    kWdGMdAQhLciHnAjkXLI6W15OoV3gA/ElRZ1xUpxTMhjP6PyY5wqT5r6y8FxbiiF
    KKAnHmUcrgfVW28tQ+0rkLGMryRtrukXOgXBv7gcrmU7G1jC2a7WqmeI8QIDAQAB
  182. base64-like blob (184 bytes over 3 lines, compression ratio 0.90) (raw pass, confidence 0.60)

    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ
    TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N
    Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB
  183. base64-like blob (1180 bytes over 19 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIDbzCCAlegAwIBAgIJAODri7v0dDUFMA0GCSqGSIb3DQEBCwUAME4xCzAJBgNV
    BAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1Nb3VudGFpbiBW
    aWV3MRIwEAYDVQQKDAlCb3JpbmdTU0wwHhcNMTYwOTI2MTUwNjI2WhcNMjYwOTI0
  184. base64-like blob (1224 bytes over 20 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIDkDCCAnigAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwTjELMAkGA1UEBhMCVVMx
    EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxEjAQ
    BgNVBAoMCUJvcmluZ1NTTDAeFw0xNjA5MjYxNTA4MzFaFw0xNzA5MjYxNTA4MzFa
  185. base64-like blob (572 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpzCBkAIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV
  186. base64-like blob (656 bytes over 11 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIB6DCB0QIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEyNDRaFw0xNjEwMjYxNTEyNDRaMD8wEwICEAAX
  187. base64-like blob (608 bytes over 10 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBwjCBqwIBATANBgkqhkiG9w0BAQsFADBSMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzEWMBQGA1UECgwN
    Tm90IEJvcmluZ1NTTBcNMTYwOTI2MTUxMjQ0WhcNMTYxMDI2MTUxMjQ0WjAVMBMC
  188. base64-like blob (592 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBuDCBoQIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoB8wHTAKBgNV
  189. base64-like blob (600 bytes over 10 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBvDCBpQIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoCMwITAKBgNV
  190. base64-like blob (620 bytes over 10 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBzTCBtgIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoDQwMjAKBgNV
  191. base64-like blob (596 bytes over 10 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBujCBowIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoCEwHzAKBgNV
  192. base64-like blob (572 bytes over 9 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpzCBkAIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV
  193. base64-like blob (572 bytes over 9 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpzCBkAIBATANBgkqhkiG9w0BAQwFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV
  194. base64-like blob (540 bytes over 9 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBkTCCAUOgAwIBAgIJAJwooam0UCDmMAUGAytlcDBFMQswCQYDVQQGEwJBVTET
    MBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQ
    dHkgTHRkMB4XDTE0MDQyMzIzMjE1N1oXDTE0MDUyMzIzMjE1N1owRTELMAkGA1UE
  195. base64-like blob (548 bytes over 9 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBlTCCAUWgAwIBAgIJAJwooam0UCDmMAcGAytlcAUAMEUxCzAJBgNVBAYTAkFV
    MRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRz
    IFB0eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQswCQYD
  196. base64-like blob (408 bytes over 7 lines, compression ratio 0.82) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBLDCB36ADAgECAghWAUdKKo3DMDAFBgMrZXAwGTEXMBUGA1UEAwwOSUVURiBUZX
    N0IERlbW8wHhcNMTYwODAxMTIxOTI0WhcNNDAxMjMxMjM1OTU5WjAZMRcwFQYDVQQD
    DA5JRVRGIFRlc3QgRGVtbzAqMAUGAytlbgMhAIUg8AmJMKdUdIt93LQ+91oNvzoNJj
  197. base64-like blob (892 bytes over 14 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIClzCCAgCgAwIBAgIJAOjwnT/iW+qmMA0GCSqGSIb3DQEBCwUAMCsxFzAVBgNV
    BAoTDkJvcmluZ1NTTCBUZXN0MRAwDgYDVQQDEwdSb290IENBMB4XDTE1MDEwMTAw
    MDAwMFoXDTI1MDEwMTAwMDAwMFowLzEXMBUGA1UEChMOQm9yaW5nU1NMIFRlc3Qx
  198. base64-like blob (792 bytes over 13 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICTTCCAbagAwIBAgIIAj5CwoHlWuYwDQYJKoZIhvcNAQELBQAwKzEXMBUGA1UE
    ChMOQm9yaW5nU1NMIFRlc3QxEDAOBgNVBAMTB1Jvb3QgQ0EwHhcNMTUwMTAxMDAw
    MDAwWhcNMjUwMTAxMDAwMDAwWjArMRcwFQYDVQQKEw5Cb3JpbmdTU0wgVGVzdDEQ
  199. base64-like blob (576 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBqjCCAROgAwIBAgIBAjANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowHzEdMBsGA1UEAxMUTm8gQmFzaWMgQ29uc3RyYWludHMw
  200. base64-like blob (456 bytes over 8 lines, compression ratio 0.80) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBUDCB96ADAgECAgEDMAoGCCqGSM49BAMCMB8xHTAbBgNVBAMTFE5vIEJhc2lj
    IENvbnN0cmFpbnRzMCAXDTAwMDEwMTAwMDAwMFoYDzIwOTkwMTAxMDAwMDAwWjAx
    MS8wLQYDVQQDEyZMZWFmIGZyb20gQ0Egd2l0aCBubyBCYXNpYyBDb25zdHJhaW50
  201. base64-like blob (592 bytes over 10 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBuDCCASGgAwIBAgIBAjANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowKjEoMCYGA1UEAxMfTm8gQmFzaWMgQ29uc3RyYWludHMg
  202. base64-like blob (472 bytes over 8 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBXDCCAQKgAwIBAgIBAzAKBggqhkjOPQQDAjAqMSgwJgYDVQQDEx9ObyBCYXNp
    YyBDb25zdHJhaW50cyAoTmV0c2NhcGUpMCAXDTAwMDEwMTAwMDAwMFoYDzIwOTkw
    MTAxMDAwMDAwWjAxMS8wLQYDVQQDEyZMZWFmIGZyb20gQ0Egd2l0aCBubyBCYXNp
  203. base64-like blob (1780 bytes over 28 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIFMjCCAxqgAwIBAgIJAL0mG5fOeJ7xMA0GCSqGSIb3DQEBDQUAMC0xCzAJBgNV
    BAYTAkdCMQ8wDQYDVQQHDAZMb25kb24xDTALBgNVBAoMBFRlc3QwIBcNMTgwOTE3
    MTIxNzU3WhgPMjExODA4MjQxMjE3NTdaMC0xCzAJBgNVBAYTAkdCMQ8wDQYDVQQH
  204. base64-like blob (640 bytes over 10 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIB2zCCAUSgAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowNzEeMBwGA1UEChMVQ29tbW9uIG5hbWUgd2l0aCBTQU5z
  205. base64-like blob (588 bytes over 10 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBtTCCAR6gAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowOjEhMB8GA1UEChMYQ29tbW9uIG5hbWUgd2l0aG91dCBT
  206. base64-like blob (600 bytes over 10 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBvDCCASWgAwIBAgIBAjANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFzEVMBMGA1UEAwwMKi5ob3N0MS50ZXN0MFkwEwYHKoZI
  207. base64-like blob (584 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBsTCCARqgAwIBAgIBAjANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFzEVMBMGA1UEAwwMKi5ob3N0MS50ZXN0MFkwEwYHKoZI
  208. base64-like blob (708 bytes over 12 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICDjCCAXegAwIBAgIBAjANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowKDEmMCQGA1UEAxMdTmFtZSBDb25zdHJhaW50cyBJbnRl
  209. base64-like blob (488 bytes over 8 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBaDCCAQ2gAwIBAgIBAzAKBggqhkjOPQQDAjAoMSYwJAYDVQQDEx1OYW1lIENv
    bnN0cmFpbnRzIEludGVybWVkaWF0ZTAgFw0wMDAxMDEwMDAwMDBaGA8yMDk5MDEw
    MTAwMDAwMFowPjEeMBwGA1UEChMVQ29tbW9uIG5hbWUgcGVybWl0dGVkMRwwGgYD
  210. base64-like blob (492 bytes over 8 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBazCCARCgAwIBAgIBBDAKBggqhkjOPQQDAjAoMSYwJAYDVQQDEx1OYW1lIENv
    bnN0cmFpbnRzIEludGVybWVkaWF0ZTAgFw0wMDAxMDEwMDAwMDBaGA8yMDk5MDEw
    MTAwMDAwMFowQTEiMCAGA1UEChMZQ29tbW9uIG5hbWUgbm90IHBlcm1pdHRlZDEb
  211. base64-like blob (572 bytes over 9 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBqTCCAU+gAwIBAgIBBjAKBggqhkjOPQQDAjAoMSYwJAYDVQQDEx1OYW1lIENv
    bnN0cmFpbnRzIEludGVybWVkaWF0ZTAgFw0wMDAxMDEwMDAwMDBaGA8yMDk5MDEw
    MTAwMDAwMFowSzEsMCoGA1UEChMjQ29tbW9uIG5hbWUgbm90IHBlcm1pdHRlZCB3
  212. base64-like blob (476 bytes over 8 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBYTCCAQagAwIBAgIBCDAKBggqhkjOPQQDAjAoMSYwJAYDVQQDEx1OYW1lIENv
    bnN0cmFpbnRzIEludGVybWVkaWF0ZTAgFw0wMDAxMDEwMDAwMDBaGA8yMDk5MDEw
    MTAwMDAwMFowNzEcMBoGA1UEChMTQ29tbW9uIG5hbWUgbm90IEROUzEXMBUGA1UE
  213. base64-like blob (588 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBtDCCAR2gAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  214. base64-like blob (588 bytes over 10 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBszCCARygAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  215. base64-like blob (584 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBsjCCARugAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  216. base64-like blob (600 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBvjCCASegAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  217. base64-like blob (580 bytes over 10 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBrjCCARegAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  218. base64-like blob (556 bytes over 9 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBnTCCAQagAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  219. base64-like blob (800 bytes over 13 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE REQUEST-----
    MIICVDCCATwCAQAwDzENMAsGA1UEAwwEVGVzdDCCASIwDQYJKoZIhvcNAQEBBQAD
    ggEPADCCAQoCggEBAK+UkwcNJfRhg5MzIQzxDdrqF9a76jNoK/BwCflKYFX7QEqf
    rsLkI0J+m60fUD0v50LnKwbGoMFKZ1R/3cBNXLcdXb7ZP/ZJ7A7QwUrL+W9n3sov
  220. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  221. base64-like blob (516 bytes over 9 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBfTCCASSgAwIBAAIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  222. base64-like blob (516 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBfTCCASSgAwIB/wIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  223. base64-like blob (516 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBfTCCASSgAwIBAwIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  224. base64-like blob (560 bytes over 9 lines, compression ratio 0.71) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBoDCCAUegJgIkAP//////////////////////////////////////////////
    AgkA2UwE2kl9v+swCQYHKoZIzj0EATBFMQswCQYDVQQGEwJBVTETMBEGA1UECAwK
    U29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMB4X
  225. base64-like blob (616 bytes over 10 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIByjCCAXECCQDZTATaSX2/6zAJBgcqhkjOPQQBMEUxCzAJBgNVBAYTAkFVMRMw
    EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0
    eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQswCQYDVQQG
  226. base64-like blob (624 bytes over 10 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBzzCCAXagAwIBAQIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  227. base64-like blob (524 bytes over 9 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBgzCCASoCCQDZTATaSX2/6zAJBgcqhkjOPQQBMEUxCzAJBgNVBAYTAkFVMRMw
    EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0
    eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQswCQYDVQQG
  228. base64-like blob (524 bytes over 9 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBgzCCASoCCQDZTATaSX2/6zAJBgcqhkjOPQQBMEUxCzAJBgNVBAYTAkFVMRMw
    EQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0
    eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQswCQYDVQQG
  229. base64-like blob (568 bytes over 9 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpDCBjTANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UECAwK
    Q2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJQm9y
    aW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNVHRQE
  230. base64-like blob (548 bytes over 9 lines, compression ratio 0.80) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBlzCBgAIBADANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaMA0GCSqGSIb3
  231. base64-like blob (572 bytes over 9 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN X509 CRL-----
    MIIBpzCBkAIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV
  232. base64-like blob (272 bytes over 5 lines, compression ratio 0.85) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE REQUEST-----
    MIHJMHECAQEwDzENMAsGA1UEAwwEVGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEH
    A0IABJjsayyAQod1J7UJYNT8AH4WWxLdKV0ozhrIz6hCzBAze7AqXWOSH8G+1EWC
    pSfL3oMQNtBdJS0kpXXaUqEAgTSgADAKBggqhkjOPQQDAgNIADBFAiAUXVaEYATg
  233. base64-like blob (272 bytes over 5 lines, compression ratio 0.85) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE REQUEST-----
    MIHJMHECAQIwDzENMAsGA1UEAwwEVGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEH
    A0IABJjsayyAQod1J7UJYNT8AH4WWxLdKV0ozhrIz6hCzBAze7AqXWOSH8G+1EWC
    pSfL3oMQNtBdJS0kpXXaUqEAgTSgADAKBggqhkjOPQQDAgNIADBFAiAUXVaEYATg
  234. base64-like blob (392 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBIDCBxqADAgECAgIE0jAKBggqhkjOPQQDAjAPMQ0wCwYDVQQDEwRUZXN0MCAX
    DTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYDVQQDEwRUZXN0
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4NlIpM1Zdrt6ke
  235. base64-like blob (396 bytes over 7 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBJDCByKADAgECAgIE0jAMBggqhkjOPQQDAgUAMA8xDTALBgNVBAMTBFRlc3Qw
    IBcNMDAwMTAxMDAwMDAwWhgPMjEwMDAxMDEwMDAwMDBaMA8xDTALBgNVBAMTBFRl
    c3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATmK2niv2Wfl74vHg2UikzVl2u3
  236. base64-like blob (412 bytes over 7 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBMTCBz6ADAgECAgIE0jATBggqhkjOPQQDAgQHZ2FyYmFnZTAPMQ0wCwYDVQQD
    EwRUZXN0MCAXDTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYD
    VQQDEwRUZXN0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4N
  237. base64-like blob (468 bytes over 8 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBWzCBx6ADAgECAgIE0jALBgkqhkiG9w0BAQswDzENMAsGA1UEAxMEVGVzdDAg
    Fw0wMDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsGA1UEAxMEVGVz
    dDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8eDZSKTNWXa7ep
  238. base64-like blob (476 bytes over 8 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBXzCByaADAgECAgIE0jANBgkqhkiG9w0BAQsFADAPMQ0wCwYDVQQDEwRUZXN0
    MCAXDTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYDVQQDEwRU
    ZXN0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4NlIpM1Zdr
  239. base64-like blob (492 bytes over 8 lines, compression ratio 0.78) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBbTCB0KADAgECAgIE0jAUBgkqhkiG9w0BAQsEB2dhcmJhZ2UwDzENMAsGA1UE
    AxMEVGVzdDAgFw0wMDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsG
    A1UEAxMEVGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8e
  240. base64-like blob (396 bytes over 7 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBJTCBxqADAgECAgIE0jAKBggqhkjOPQQDAjAPMQ0wCwYDVQQDEwRUZXN0MCAX
    DTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYDVQQDEwRUZXN0
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4NlIpM1Zdrt6ke
  241. base64-like blob (396 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBJDCByqADAgECAgIE0jAKBggqhkjOPQQDAjAPMQ0wCwYDVQQDEwRUZXN0MCAX
    DTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYDVQQDEwRUZXN0
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4NlIpM1Zdrt6ke
  242. base64-like blob (392 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIAwgcagAwIBAgICBNIwCgYIKoZIzj0EAwIwDzENMAsGA1UEAxMEVGVzdDAgFw0w
    MDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsGA1UEAxMEVGVzdDBZ
    MBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8eDZSKTNWXa7epHg1G
  243. base64-like blob (624 bytes over 10 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIB0DCCAXagAwIBAgIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  244. base64-like blob (392 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    PxCCASAwgcagAwIBAgICBNIwCgYIKoZIzj0EAwIwDzENMAsGA1UEAxMEVGVzdDAg
    Fw0wMDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsGA1UEAxMEVGVz
    dDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8eDZSKTNWXa7ep
  245. base64-like blob (392 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIMAASAwgcagAwIBAgICBNIwCgYIKoZIzj0EAwIwDzENMAsGA1UEAxMEVGVzdDAg
    Fw0wMDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsGA1UEAxMEVGVz
    dDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8eDZSKTNWXa7ep
  246. base64-like blob (392 bytes over 7 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBITCBxqADAgECAgIE0jAKBggqhkjOPQQDAjAPMQ0wCwYDVQQDEwRUZXN0MCAX
    DTAwMDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAPMQ0wCwYDVQQDEwRUZXN0
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5itp4r9ln5e+Lx4NlIpM1Zdrt6ke
  247. base64-like blob (392 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBITCBx6ADAgECAoECBNIwCgYIKoZIzj0EAwIwDzENMAsGA1UEAxMEVGVzdDAg
    Fw0wMDAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowDzENMAsGA1UEAxMEVGVz
    dDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOYraeK/ZZ+Xvi8eDZSKTNWXa7ep
  248. base64-like blob (824 bytes over 13 lines, compression ratio 0.74) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICZjCCAc+gAwIBAgIQASNFZ4mrze8BI0VniavN7zANBgkqhkiG9w0BAQsFADA2
    MRowGAYDVQQKExFCb3JpbmdTU0wgVEVTVElORzEYMBYGA1UEAxMPSW50ZXJtZWRp
    YXRlIENBMCAXDTE1MDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAyMRowGAYD
  249. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

          {CBS_ASN1_IA5STRING, "abc", V_ASN1_IA5STRING, "abc"},
          {CBS_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4),
           V_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4)},
          {CBS_ASN1_BMPSTRING, std::string("\0a", 2), V_ASN1_BMPSTRING,
  250. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

          {CBS_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4),
           V_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4)},
          {CBS_ASN1_BMPSTRING, std::string("\0a", 2), V_ASN1_BMPSTRING,
           std::string("\0a", 2)},
  251. string literal contains an embedded NUL followed by 1 more bytes of source (token pass, confidence 0.85)

           V_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4)},
          {CBS_ASN1_BMPSTRING, std::string("\0a", 2), V_ASN1_BMPSTRING,
           std::string("\0a", 2)},
          {CBS_ASN1_OCTETSTRING, "abc", V_ASN1_OCTET_STRING, "abc"},
  252. string literal contains an embedded NUL followed by 1 more bytes of source (token pass, confidence 0.85)

          {CBS_ASN1_BMPSTRING, std::string("\0a", 2), V_ASN1_BMPSTRING,
           std::string("\0a", 2)},
          {CBS_ASN1_OCTETSTRING, "abc", V_ASN1_OCTET_STRING, "abc"},
          {CBS_ASN1_UTCTIME, "700101000000Z", V_ASN1_UTCTIME, "700101000000Z"},
  253. string literal contains an embedded NUL followed by 1 more bytes of source (token pass, confidence 0.85)

          {
              "der\0p",
              V_ASN1_TELETEXSTRING,
              5,
  254. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "-----BEGIN SINGLE LINE-----\n"
          "MTIzNDU2Nzg5MGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktM\n"
          "-----END SINGLE LINE-----\n",
          PEMEncode("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL",
  255. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "-----BEGIN WRAPPED LINE-----\n"
          "MTIzNDU2Nzg5MGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktM\nTQ==\n"
          "-----END WRAPPED LINE-----\n",
          PEMEncode("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLM",
  256. 30 rows of base64-like lines, lines 660-689 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kOpenSSLSession[] =
        "MIIFqgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ"
        "kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH"
        "IWoJoQYCBFRDO46iBAICASyjggR6MIIEdjCCA16gAwIBAgIIK9dUvsPWSlUwDQYJ"
  257. 7 rows of base64-like lines, lines 696-702 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kCustomSession[] =
        "MIIBZAIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ"
        "kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH"
        "IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUqAcEBXdvcmxkqQUCAwGJwKqBpwSB"
  258. 95 rows of base64-like lines, lines 707-801 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kBoringSSLSession[] =
        "MIIRwQIBAQICAwMEAsAvBCDdoGxGK26mR+8lM0uq6+k9xYuxPnwAjpcF9n0Yli9R"
        "kQQwbyshfWhdi5XQ1++7n2L1qqrcVlmHBPpr6yknT/u4pUrpQB5FZ7vqvNn8MdHf"
        "9rWgoQYCBFXgs7uiBAICHCCjggR6MIIEdjCCA16gAwIBAgIIf+yfD7Y6UicwDQYJ"
  259. 7 rows of base64-like lines, lines 807-813 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kBadSessionExtraField[] =
        "MIIBdgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ"
        "kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH"
        "IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE"
  260. 7 rows of base64-like lines, lines 819-825 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kBadSessionVersion[] =
        "MIIBdgIBAgICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ"
        "kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH"
        "IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE"
  261. 7 rows of base64-like lines, lines 831-837 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

    static const char kBadSessionTrailingData[] =
        "MIIBdgIBAQICAwMEAsAvBCAG5Q1ndq4Yfmbeo1zwLkNRKmCXGdNgWvGT3cskV0yQ"
        "kAQwJlrlzkAWBOWiLj/jJ76D7l+UXoizP2KI2C7I2FccqMmIfFmmkUy32nIJ0mZH"
        "IWoJoQYCBFRDO46iBAICASykAwQBAqUDAgEUphAEDnd3dy5nb29nbGUuY29tqAcE"
  262. 13 rows of base64-like lines, lines 1319-1331 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN CERTIFICATE-----\n"
          "MIICWDCCAcGgAwIBAgIJAPuwTC6rEJsMMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV\n"
          "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\n"
          "aWRnaXRzIFB0eSBMdGQwHhcNMTQwNDIzMjA1MDQwWhcNMTcwNDIyMjA1MDQwWjBF\n"
  263. 13 rows of base64-like lines, lines 1338-1350 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN CERTIFICATE-----\n"
          "MIICWDCCAcGgAwIBAgIJAPuwTC6rEJsMMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV\n"
          "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\n"
          "aWRnaXRzIFB0eSBMdGQwHhcNMTQwNDIzMjA1MDQwWhcNMTcwNDIyMjA1MDQwWjBF\n"
  264. 13 rows of base64-like lines, lines 1358-1370 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN RSA PRIVATE KEY-----\n"
          "MIICXgIBAAKBgQDYK8imMuRi/03z0K1Zi0WnvfFHvwlYeyK9Na6XJYaUoIDAtB92\n"
          "kWdGMdAQhLciHnAjkXLI6W15OoV3gA/ElRZ1xUpxTMhjP6PyY5wqT5r6y8FxbiiF\n"
          "KKAnHmUcrgfVW28tQ+0rkLGMryRtrukXOgXBv7gcrmU7G1jC2a7WqmeI8QIDAQAB\n"
  265. 10 rows of base64-like lines, lines 1391-1400 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN CERTIFICATE-----\n"
          "MIIBzzCCAXagAwIBAgIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC\n"
          "QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp\n"
          "dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ\n"
  266. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "-----BEGIN PRIVATE KEY-----\n"
          "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ\n"
          "TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N\n"
          "Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB\n"
  267. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ\n"
          "TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N\n"
          "Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB\n"
          "-----END PRIVATE KEY-----\n";
  268. 15 rows of base64-like lines, lines 1423-1437 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN CERTIFICATE-----\n"
          "MIIC0jCCAbqgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwDzENMAsGA1UEAwwEQiBD\n"
          "QTAeFw0xNjAyMjgyMDI3MDNaFw0yNjAyMjUyMDI3MDNaMBgxFjAUBgNVBAMMDUNs\n"
          "aWVudCBDZXJ0IEEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRvaz8\n"
  269. 15 rows of base64-like lines, lines 1450-1464 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "-----BEGIN CERTIFICATE-----\n"
          "MIICwjCCAaqgAwIBAgICEAEwDQYJKoZIhvcNAQELBQAwFDESMBAGA1UEAwwJQyBS\n"
          "b290IENBMB4XDTE2MDIyODIwMjcwM1oXDTI2MDIyNTIwMjcwM1owDzENMAsGA1UE\n"
          "AwwEQiBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALsSCYmDip2D\n"
  270. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "-----BEGIN SUBJECT-----\n"
          "MEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJ\n"
          "bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQ=\n"
          "-----END SUBJECT-----\n";
  271. 24 rows of base64-like lines, lines 1502-1525 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

          "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDRvaz8CC/cshpC\n"
          "afJo4jLkHEoBqDLhdgFelJoAiQUyIqyWl2O7YHPnpJH+TgR7oelzNzt/kLRcH89M\n"
          "/TszB6zqyLTC4aqmvzKL0peD/jL2LWBucR0WXIvjA3zoRuF/x86+rYH3tHb+xs2P\n"
          "Ss8EGL/Ev+ss+qTzTGEn26fuGNHkNw6tOwPpc+o8+wUtzf/kAthamo+cIDs2rQ+l\n"
  272. base64-like blob (444 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBRzCB7aADAgECAgEBMAoGCCqGSM49BAMCMBIxEDAOBgNVBAMTB1Rlc3QgQ0Ew
    IBcNMDAwMTAxMDAwMDAwWhgPMjA5OTAxMDEwMDAwMDBaMBIxEDAOBgNVBAMTB1Rl
    c3QgQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAT5JUjrI1DAxSpEl88UkmJw
  273. base64-like blob (184 bytes over 3 lines, compression ratio 0.92) (raw pass, confidence 0.60)

    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgj5WKHwHnziiyPauf
    7QukxTwtTyGZkk8qNdms4puJfxqhRANCAARNrkhxabALDlJrHtvkuDwvCWUF/oVC
    hr6PDITHi1lDlJzvVT4aXBH87sH2n2UV5zpx13NHkq1bIC8eRT8eOIe0
  274. base64-like blob (488 bytes over 8 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBaDCCAQ6gAwIBAgIBAjAKBggqhkjOPQQDAjASMRAwDgYDVQQDEwdUZXN0IENB
    MCAXDTAwMDEwMTAwMDAwMFoYDzIwOTkwMTAxMDAwMDAwWjAZMRcwFQYDVQQDEw5w
    dWJsaWMuZXhhbXBsZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE2uSHFpsAsO
  275. base64-like blob (488 bytes over 8 lines, compression ratio 0.79) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBaTCCAQ6gAwIBAgIBAzAKBggqhkjOPQQDAjASMRAwDgYDVQQDEwdUZXN0IENB
    MCAXDTAwMDEwMTAwMDAwMFoYDzIwOTkwMTAxMDAwMDAwWjAZMRcwFQYDVQQDEw5z
    ZWNyZXQuZXhhbXBsZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE2uSHFpsAsO
  276. string literal contains an embedded NUL followed by 9 more bytes of source (token pass, confidence 0.85)

                SSL_select_next_proto(&result, &result_len,
                                      (const uint8_t *)"\0\2bb\3ccc", 8,
                                      (const uint8_t *)"\1a\2bb\3ccc", 9));
      EXPECT_EQ(OPENSSL_NPN_NO_OVERLAP,
  277. string literal contains an embedded NUL followed by 9 more bytes of source (token pass, confidence 0.85)

                                      (const uint8_t *)"\1a\2bb\3ccc", 9,
                                      (const uint8_t *)"\0\2bb\3ccc", 8));
      EXPECT_EQ(Bytes(""), Bytes(result, result_len));
    }
  278. base64-like blob (664 bytes over 11 lines, compression ratio 0.72) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIB7DCCAZOgAwIBAgIJANlMBNpJfb/rMAoGCCqGSM49BAMCMEUxCzAJBgNVBAYT
    AkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRn
    aXRzIFB0eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQsw
  279. base64-like blob (664 bytes over 11 lines, compression ratio 0.72) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIB7jCCAZOgAwIBAgIJANlMBNpJfb/rMAoGCCqGSM49BAMCMEUxCzAJBgNVBAYT
    AkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRn
    aXRzIFB0eSBMdGQwHhcNMTQwNDIzMjMyMTU3WhcNMTQwNTIzMjMyMTU3WjBFMQsw
  280. base64-like blob (576 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBqzCCAVGgAwIBAgIQeudG9R61BOxUvWkeVhU5DTAKBggqhkjOPQQDAjArMRIw
    EAYDVQQKEwlBY21lIENvIDIxFTATBgNVBAMTDGV4YW1wbGUzLmNvbTAeFw0yMTEy
    MDYyMDU2NTZaFw0yMjEyMDYyMDU2NTZaMCsxEjAQBgNVBAoTCUFjbWUgQ28gMjEV
  281. base64-like blob (184 bytes over 3 lines, compression ratio 0.92) (raw pass, confidence 0.60)

    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQghsaSZhUzZAcQlLyJ
    MDuy7WPdyqNsAX9rmEP650LF/q2hRANCAAS7l2VOBl2TjVm9WfGk24+hMbVFUNB+
    RVHWbCvFvNZAoWiIJ2z34RLGInyZvCZ8xLAvsuaWULDDaoeDl1M0t4Hm
  282. base64-like blob (624 bytes over 10 lines, compression ratio 0.73) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIIBzzCCAXagAwIBAgIJANlMBNpJfb/rMAkGByqGSM49BAEwRTELMAkGA1UEBhMC
    QVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp
    dHMgUHR5IEx0ZDAeFw0xNDA0MjMyMzIxNTdaFw0xNDA1MjMyMzIxNTdaMEUxCzAJ
  283. base64-like blob (816 bytes over 13 lines, compression ratio 0.75) (raw pass, confidence 0.60)

    -----BEGIN CERTIFICATE-----
    MIICXjCCAcegAwIBAgIIWjO48ufpunYwDQYJKoZIhvcNAQELBQAwNjEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxGDAWBgNVBAMTD0ludGVybWVkaWF0ZSBDQTAg
    Fw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowMjEaMBgGA1UEChMRQm9y
  284. `#define FIAT_25519_FIAT_INLINE inline` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define FIAT_25519_FIAT_INLINE inline
    
    /* The type fiat_25519_loose_field_element is a field element with loose bounds. */
  285. `#define FIAT_P256_FIAT_INLINE inline` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define FIAT_P256_FIAT_INLINE inline
    
    /* The type fiat_p256_montgomery_domain_field_element is a field element in the Montgomery domain. */
  286. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  287. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  288. base64-like blob (360 bytes over 5 lines, compression ratio 0.76) (raw pass, confidence 0.60)

      std::string escaped =
          R"(TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
      IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
      dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
  289. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251                                   \
    /* class A needs to have dll-interface to be used by clients of class B */)
  290. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  291. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  292. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  293. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  294. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  295. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  296. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  297. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    #elif defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_SIMPLE_RE)
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  298. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    #else
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  299. backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)

    
    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    /* class A needs to have dll-interface to be used by clients of class B */)
  300. string literal contains an embedded NUL followed by 21 more bytes of source (token pass, confidence 0.85)

    TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
      const char char_array_with_nul[] = "Here's a NUL\0 and some more string";
      const ::std::string string_with_nul(char_array_with_nul,
                                          sizeof(char_array_with_nul) - 1);
  301. string literal contains an embedded NUL followed by 12 more bytes of source (token pass, confidence 0.85)

    
    static const char kGoldenString[] = "\"Line\0 1\"\nLine 2";
    
    TEST(NonfatalFailureTest, EscapesStringOperands) {
  302. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      fprintf(stdout, "def%cghi", '\0');
      EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
    }
  303. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      fprintf(stderr, "jkl%cmno", '\0');
      EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
    }
  304. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

    TEST(PrintArrayTest, CharArrayWithTerminatingNul) {
      const char a[] = "\0Hi";
      EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a));
    }
  305. string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

    TEST(PrintArrayTest, Char8ArrayWithTerminatingNul) {
      const char8_t a[] = u8"\0世界";
      EXPECT_EQ("u8\"\\0\\xE4\\xB8\\x96\\xE7\\x95\\x8C\"", PrintArrayHelper(a));
    }
  306. string literal contains an embedded NUL followed by 15 more bytes of source (token pass, confidence 0.85)

    TEST(PrintArrayTest, Char16ArrayWithTerminatingNul) {
      const char16_t a[] = u"\0こんにちは";
      EXPECT_EQ("u\"\\0\\x3053\\x3093\\x306B\\x3061\\x306F\"", PrintArrayHelper(a));
    }
  307. string literal contains an embedded NUL followed by 8 more bytes of source (token pass, confidence 0.85)

    TEST(PrintArrayTest, Char32ArrayWithTerminatingNul) {
      const char32_t a[] = U"\0👋🌌";
      EXPECT_EQ("U\"\\0\\x1F44B\\x1F30C\"", PrintArrayHelper(a));
    }
  308. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

    TEST(PrintArrayTest, WCharArrayWithTerminatingNul) {
      const wchar_t a[] = L"\0Hi";
      EXPECT_EQ("L\"\\0Hi\"", PrintArrayHelper(a));
    }
  309. string literal contains an embedded NUL followed by 16 more bytes of source (token pass, confidence 0.85)

    TEST(PrintStringTest, StringInStdNamespace) {
      const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
      const ::std::string str(s, sizeof(s));
      EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
  310. string literal contains an embedded NUL followed by 28 more bytes of source (token pass, confidence 0.85)

    TEST(PrintWideStringTest, StringInStdNamespace) {
      const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
      const ::std::wstring str(s, sizeof(s) / sizeof(wchar_t));
      EXPECT_EQ(
  311. string literal contains an embedded NUL followed by 10 more bytes of source (token pass, confidence 0.85)

    TEST(PrintStringViewTest, UnprintableCharacters) {
      const char str[] = "NUL (\0) and \r\t";
      const internal::StringView sp(str, sizeof(str) - 1);
      EXPECT_EQ("\"NUL (\\0) and \\r\\t\"", Print(sp));
  312. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

    TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
      const wchar_t str[] = L"hi \"w\0rld\"";
      EXPECT_STREQ(
          "L\"hi \\\"w\"",  // The content should be escaped.
  313. string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

    TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
      const char str_with_nul[] = "hello\0 world";
      EXPECT_PRINT_TO_STRING_(str_with_nul, "\"hello\\0 world\"");
  314. string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

    
      char mutable_str_with_nul[] = "hello\0 world";
      EXPECT_PRINT_TO_STRING_(mutable_str_with_nul, "\"hello\\0 world\"");
    }
  315. string literal contains an embedded NUL followed by 12 more bytes of source (token pass, confidence 0.85)

    TEST(UniversalPrintTest, WorksForCharArray) {
      const char str[] = "\"Line\0 1\"\nLine 2";
      ::std::stringstream ss1;
      UniversalPrint(str, &ss1);
  316. string literal contains an embedded NUL followed by 12 more bytes of source (token pass, confidence 0.85)

    
      const char mutable_str[] = "\"Line\0 1\"\nLine 2";
      ::std::stringstream ss2;
      UniversalPrint(mutable_str, &ss2);
  317. string literal contains an embedded NUL followed by 11 more bytes of source (token pass, confidence 0.85)

    TEST(string_ref, compare) {
      const char* s = "alex\0davidjohn\0";
      string_ptr ptr(s, 5);
      EXPECT_EQ(*ptr, "alex");
  318. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

    TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
      EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
    }
  319. string literal contains an embedded NUL followed by 21 more bytes of source (token pass, confidence 0.85)

      static const char char_array_with_nul[] =
          "Here's a NUL\0 and some more string";
      static const std::string string_with_nul(
          char_array_with_nul,
  320. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

                              "Expected equality of these values:\n"
                              "  L'\0'\n"
                              "    Which is: L'\0' (0, 0x0)\n"
                              "  L'x'\n"
  321. string literal contains an embedded NUL followed by 12 more bytes of source (token pass, confidence 0.85)

                              "  L'\0'\n"
                              "    Which is: L'\0' (0, 0x0)\n"
                              "  L'x'\n"
                              "    Which is: L'x' (120, 0x78)");
  322. 20 rows of base64-like lines, lines 1428-1447 (first: base64-like blob (64 bytes, compression ratio 1.17)) (raw pass, confidence 0.60)

      static const char kInput[] =
          "MIIDtTCCAp2gAwIBAgIJALW2IrlaBKUhMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV"
          "BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX"
          "aWRnaXRzIFB0eSBMdGQwHhcNMTYwNzA5MDQzODA5WhcNMTYwODA4MDQzODA5WjBF"
  323. `dlopen` called with a non-literal path (ast pass, confidence 0.75)

      for (i = 0; searchlibs[i] != NULL; i++) {
        dnsinfo->handle = dlopen(searchlibs[i], RTLD_LAZY /* | RTLD_NOLOAD */);
        if (dnsinfo->handle == NULL) {
          /* Fail, loop */
  324. `dlopen` called with a non-literal path (ast pass, confidence 0.75)

      for (i = 0; searchlibs[i] != NULL; i++) {
        handle = dlopen(searchlibs[i], RTLD_LAZY);
        if (handle == NULL) {
          /* Fail, loop! */
  325. string literal contains an embedded NUL followed by 4 more bytes of source (token pass, confidence 0.85)

    TEST_F(LibraryTest, StringLength) {
      const char data[] = "test\0test";
      size_t n = sizeof data;
      for(size_t i = 0; i < n; ++i) {
  326. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      std::string expected2a = "txt2a";
      std::string expected2b("ABC\0ABC", 7);
      pkt.set_qid(0x1234).set_response().set_aa()
        .add_question(new DNSQuestion("example.com", T_TXT))
  327. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

      std::string expected2a = "txt2a";
      std::string expected2b("ABC\0ABC", 7);
      pkt.set_qid(0x1234).set_response().set_aa()
        .add_question(new DNSQuestion("example.com", T_TXT))
  328. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  329. `#define RECVFROM_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recvfrom. */
    #define RECVFROM_TYPE_ARG1 int
    
    /* Define to the type pointed by arg 2 for recvfrom. */
  330. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  331. `#define RECV_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recv. */
    #define RECV_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for recv. */
  332. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  333. `#define SEND_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for send. */
    #define SEND_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for send. */
  334. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  335. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  336. `#define RECVFROM_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recvfrom. */
    #define RECVFROM_TYPE_ARG1 int
    
    /* Define to the type pointed by arg 2 for recvfrom. */
  337. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  338. `#define RECV_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recv. */
    #define RECV_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for recv. */
  339. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  340. `#define SEND_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for send. */
    #define SEND_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for send. */
  341. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  342. `#define GETNAMEINFO_QUAL_ARG1 const` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type qualifier of arg 1 for getnameinfo. */
    #define GETNAMEINFO_QUAL_ARG1 const
    
    /* Define to the type of arg 1 for getnameinfo. */
  343. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  344. `#define RECVFROM_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recvfrom. */
    #define RECVFROM_TYPE_ARG1 int
    
    /* Define to the type pointed by arg 2 for recvfrom. */
  345. `#define RECVFROM_TYPE_ARG2 void` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type pointed by arg 2 for recvfrom. */
    #define RECVFROM_TYPE_ARG2 void
    
    /* Define to 1 if the type pointed by arg 2 for recvfrom is void. */
  346. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  347. `#define RECV_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recv. */
    #define RECV_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for recv. */
  348. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  349. `#define RETSIGTYPE void` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define as the return type of signal handlers (`int' or `void'). */
    #define RETSIGTYPE void
    
    /* Define to the type qualifier of arg 2 for send. */
  350. `#define SEND_QUAL_ARG2 const` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type qualifier of arg 2 for send. */
    #define SEND_QUAL_ARG2 const
    
    /* Define to the type of arg 1 for send. */
  351. `#define SEND_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for send. */
    #define SEND_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for send. */
  352. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  353. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  354. `#define RECVFROM_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recvfrom. */
    #define RECVFROM_TYPE_ARG1 int
    
    /* Define to the type pointed by arg 2 for recvfrom. */
  355. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  356. `#define RECV_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recv. */
    #define RECV_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for recv. */
  357. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  358. `#define SEND_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for send. */
    #define SEND_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for send. */
  359. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  360. `#define GETNAMEINFO_QUAL_ARG1 const` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type qualifier of arg 1 for getnameinfo. */
    #define GETNAMEINFO_QUAL_ARG1 const
    
    /* Define to the type of arg 1 for getnameinfo. */
  361. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  362. `#define RECVFROM_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recvfrom. */
    #define RECVFROM_TYPE_ARG1 int
    
    /* Define to the type pointed by arg 2 for recvfrom. */
  363. `#define RECVFROM_TYPE_ARG2 void` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type pointed by arg 2 for recvfrom. */
    #define RECVFROM_TYPE_ARG2 void
    
    /* Define to 1 if the type pointed by arg 2 for recvfrom is void. */
  364. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  365. `#define RECV_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for recv. */
    #define RECV_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for recv. */
  366. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  367. `#define RETSIGTYPE void` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define as the return type of signal handlers (`int' or `void'). */
    #define RETSIGTYPE void
    
    /* Define to the type qualifier of arg 2 for send. */
  368. `#define SEND_QUAL_ARG2 const` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type qualifier of arg 2 for send. */
    #define SEND_QUAL_ARG2 const
    
    /* Define to the type of arg 1 for send. */
  369. `#define SEND_TYPE_ARG1 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 1 for send. */
    #define SEND_TYPE_ARG1 int
    
    /* Define to the type of arg 2 for send. */
  370. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  371. `#define GETHOSTNAME_TYPE_ARG2 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 2 for gethostname. */
    #define GETHOSTNAME_TYPE_ARG2 int
    
    /* Define to the type qualifier of arg 1 for getnameinfo. */
  372. `#define GETNAMEINFO_TYPE_ARG7 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 7 for getnameinfo. */
    #define GETNAMEINFO_TYPE_ARG7 int
    
    /* Specifies the number of arguments to getservbyport_r */
  373. `#define RECVFROM_TYPE_ARG3 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 3 for recvfrom. */
    #define RECVFROM_TYPE_ARG3 int
    
    /* Define to the type of arg 4 for recvfrom. */
  374. `#define RECVFROM_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recvfrom. */
    #define RECVFROM_TYPE_ARG4 int
    
    /* Define to the type pointed by arg 5 for recvfrom. */
  375. `#define RECVFROM_TYPE_RETV int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the function return type for recvfrom. */
    #define RECVFROM_TYPE_RETV int
    
    /* Define to the type of arg 1 for recv. */
  376. `#define RECV_TYPE_ARG3 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 3 for recv. */
    #define RECV_TYPE_ARG3 int
    
    /* Define to the type of arg 4 for recv. */
  377. `#define RECV_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for recv. */
    #define RECV_TYPE_ARG4 int
    
    /* Define to the function return type for recv. */
  378. `#define RECV_TYPE_RETV int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the function return type for recv. */
    #define RECV_TYPE_RETV int
    
    /* Define as the return type of signal handlers (`int' or `void'). */
  379. `#define SEND_TYPE_ARG3 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 3 for send. */
    #define SEND_TYPE_ARG3 int
    
    /* Define to the type of arg 4 for send. */
  380. `#define SEND_TYPE_ARG4 int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the type of arg 4 for send. */
    #define SEND_TYPE_ARG4 int
    
    /* Define to the function return type for send. */
  381. `#define SEND_TYPE_RETV int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* Define to the function return type for send. */
    #define SEND_TYPE_RETV int
    
    /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
  382. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

        // string.
        {std::string("\0foo", 4),
         "0:0: Invalid control characters encountered in text."},
        {std::string("\0\0foo", 5),
  383. string literal contains an embedded NUL followed by 5 more bytes of source (token pass, confidence 0.85)

         "0:0: Invalid control characters encountered in text."},
        {std::string("\0\0foo", 5),
         "0:0: Invalid control characters encountered in text."},
  384. string literal contains an embedded NUL followed by 3 more bytes of source (token pass, confidence 0.85)

    TEST(FuzzTest, FileNameEmbeddedNull) {
      RoundTripDescriptor(ParseTextProtoOrDie(R"pb(file { name: "\000" })pb"));
    }
  385. string literal contains an embedded NUL followed by 41 more bytes of source (token pass, confidence 0.85)

      RoundTripDescriptor(ParseTextProtoOrDie(
          R"pb(file {
                 name: "\035"
                 enum_type {
  386. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

      EXPECT_EQ(4, SpanStructurallyValid("abcd"));
      EXPECT_EQ(4, SpanStructurallyValid(absl::string_view("a\0cd", 4)));  // NULL
      EXPECT_EQ(4, SpanStructurallyValid("ab\xc2\x81"));                   // 2-byte
      EXPECT_EQ(4, SpanStructurallyValid("a\xe2\x81\x81"));                // 3-byte
  387. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

      EXPECT_TRUE(IsStructurallyValid("abcd"));
      EXPECT_TRUE(IsStructurallyValid(absl::string_view("a\0cd", 4)));  // NULL
      EXPECT_TRUE(IsStructurallyValid("ab\xc2\x81"));                   // 2-byte
      EXPECT_TRUE(IsStructurallyValid("a\xe2\x81\x81"));                // 3-byte
  388. warn macro-keyword-override third_party/xxhash/xxhash.h:2717:1

    `#define inline` rebinds the reserved C keyword `inline` (token pass, confidence 0.85)

    #  elif defined(__ARM_NEON__) || defined(__ARM_NEON)
    #    define inline __inline__  /* circumvent a clang bug */
    #    include <arm_neon.h>
    #    undef inline
  389. warn identifier-confusable-collision third_party/xxhash/xxhash.h:3491:23

    two identifiers collapse to visual skeleton `bitf|ip|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)

        XXH_ASSERT(9 <= len && len <= 16);
        {   xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;
            xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;
            xxh_u64 const input_lo = XXH_readLE64(input)           ^ bitflip1;
  390. warn macro-keyword-override third_party/zlib/contrib/blast/blast.c:36:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static            /* for local function definitions */
    #define MAXBITS 13              /* maximum code length */
    #define MAXWIN 4096             /* maximum window size */
  391. warn macro-keyword-override third_party/zlib/contrib/puff/puff.c:85:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static            /* for local function definitions */
    
    /*
  392. warn macro-keyword-override third_party/zlib/contrib/puff/pufftest.c:31:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    /* Return size times approximately the cube root of 2, keeping the result as 1,
  393. warn macro-keyword-override third_party/zlib/examples/enough.c:112:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    // Special data types.
  394. warn macro-keyword-override third_party/zlib/examples/fitblk.c:59:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    /* print nastygram and leave */
  395. warn macro-keyword-override third_party/zlib/examples/gun.c:73:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    /* function declaration */
    #define local static
    
    /* buffer constants */
  396. warn macro-keyword-override third_party/zlib/examples/gzappend.c:87:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    #define LGCHUNK 14
    #define CHUNK (1U << LGCHUNK)
  397. warn macro-keyword-override third_party/zlib/examples/gzjoin.c:63:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    /* exit with an error (return a value to allow use in an expression) */
  398. warn macro-keyword-override third_party/zlib/examples/gzlog.c:241:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    typedef unsigned int uint;
    typedef unsigned long ulong;
  399. warn macro-keyword-override third_party/zlib/examples/gznorm.c:32:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    // printf to an allocated string. Return the string, or NULL if the printf or
  400. warn macro-keyword-override third_party/zlib/test/infcover.c:20:1

    `#define local static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    
    #define local static
    
    /* -- memory tracking routines -- */
  401. warn macro-keyword-override third_party/zlib/zconf.h:233:1

    `#define const` rebinds the reserved C keyword `const` (token pass, confidence 0.85)

    #  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
    #    define const       /* note: need a more gentle solution here */
    #  endif
    #endif
  402. info critical → info by review dynamic-execution src/core/util/subprocess_posix.cc:60:5

    `execv` called with a non-literal path (ast pass, confidence 0.90)

        exec_args[argc] = nullptr;
        execv(exec_args[0], exec_args);
        // if we reach here, an error has occurred
        LOG(ERROR) << "execv '" << exec_args[0]
    likely benign LLM, confidence 0.90 Calls execv on a command path passed in by the build subprocess wrapper.
    Reasoning

    This is the standard POSIX subprocess launcher pattern used by build tools such as ninja. execv receives a command path the caller constructed, which is the purpose of the function. The snippet shows no encoding, download, or hidden payload, so the non-literal path alone is not malicious.

  403. info critical → info by review dynamic-execution src/core/util/subprocess_posix.cc:103:5

    `execve` called with a non-literal path (ast pass, confidence 0.90)

        envp_args[envc] = nullptr;
        execve(exec_args[0], exec_args, envp_args);
        // if we reach here, an error has occurred
        LOG(ERROR) << "execvpe '" << exec_args[0]
    likely benign LLM, confidence 0.90 Calls execve with caller-supplied argv and environment in the subprocess helper.
    Reasoning

    execve with a caller-built argv and envp is the ordinary way a subprocess helper launches a build command with a custom environment. The error logging after the call is also normal. The non-literal path reflects the function's purpose, not an obfuscated payload.

  404. info warn → info by review macro-keyword-override src/python/grpcio/grpc/_cython/cygrpc.cpp:3310:1

    `#define __pyx_atomic_int_type int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    #define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
    #define __pyx_atomic_int_type int
    #define __pyx_nonatomic_int_type int
    #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
    likely benign LLM, confidence 0.92 Cython-generated macro aliasing int for atomic and nonatomic counter types.
    Reasoning

    Cython emits these __pyx_atomic_int_type and __pyx_nonatomic_int_type macros in its generated compatibility header to select atomic or plain int types. This is standard generated code in a grpc build artifact, not a malicious keyword override.

  405. info warn → info by review macro-keyword-override src/python/grpcio/grpc/_cython/cygrpc.cpp:3311:1

    `#define __pyx_nonatomic_int_type int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)

    #define __pyx_atomic_int_type int
    #define __pyx_nonatomic_int_type int
    #if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
                            (__STDC_VERSION__ >= 201112L) &&\
    likely benign LLM, confidence 0.92 Cython-generated macro aliasing int for the nonatomic counter type.
    Reasoning

    This is the paired Cython-generated macro for the nonatomic int type, emitted in the same compatibility block as the atomic variant. It is routine generated boilerplate.

  406. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8257:39

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_e[] = "e";
    static const char __pyx_k_q[] = "\200!\330\004\010\210\017\220q\330\006\013\320\013\"\240!\240?\260!";
    static const char __pyx_k_t[] = "t";
    static const char __pyx_k_y[] = "y";
    likely benign LLM, confidence 0.88 Cython-generated constant byte string holding encoded code-object metadata.
    Reasoning

    The byte strings with octal escapes such as \200!\330 are Cython's encoded code-object metadata (line and location tables, names) for a generated Cython module. They appear in a machine-generated .cpp file in the grpc package with no executing or decoding logic around them, so the high entropy reflects generator output.

  407. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8264:35

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_Ja[] = "\200!\330\004\005\330\010\t\330\010\014\210J\220a";
    static const char __pyx_k_Qj[] = "\200\001\330\002\025\220Q\220j\240\001";
    static const char __pyx_k__3[] = ": ";
    static const char __pyx_k__4[] = "\": ";
    likely benign LLM, confidence 0.88 Cython-generated constant strings holding encoded metadata and ordinary text.
    Reasoning

    The same Cython metadata-table pattern appears here alongside ordinary string constants such as ": ". These are generated constants inside the Cython output, not a payload being run.

  408. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8272:39

    string literal contains an embedded NUL followed by 25 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k__9[] = ">";
    static const char __pyx_k_aq[] = "\320\000*\250!\330\002&\240a\240q";
    static const char __pyx_k_cb[] = "cb";
    static const char __pyx_k_fn[] = "fn";
    likely benign LLM, confidence 0.85 Cython-generated byte-string constant with an embedded NUL from metadata encoding.
    Reasoning

    Cython encodes location and line-table bytes with embedded \000 in C byte-string literals. The embedded NUL is an artifact of this encoding and is not hiding source text. The file is generated grpc Cython output.

  409. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8285:36

    7 rows of escape runs, lines 8285-8300 (first: 7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_0_q[] = "\200\001\330\0040\260\001\260\026\260q";
    static const char __pyx_k_1Kq[] = "\200\001\340\007\010\330\004#\2401\240K\250q\260\001\340\002\t\210\021";
    static const char __pyx_k_1_2[] = "\200\001\330\002\t\320\t#\2401";
    static const char __pyx_k_1_3[] = "\200!\330\004\013\2101";
    likely benign LLM, confidence 0.85 Rows of Cython-generated encoded metadata constants.
    Reasoning

    These rows are Cython's encoded code-object metadata for the grpc extension, repeated as generated constant arrays. No execution or network logic accompanies them in the snippet, and the pattern matches Cython output.

  410. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8309:49

    string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k__16[] = "\210!";
    static const char __pyx_k__17[] = "\210!\360\006\000,-";
    static const char __pyx_k__18[] = "\210!\360\006\000-.";
    static const char __pyx_k__19[] = "\210!\340\032\033\330&'";
    likely benign LLM, confidence 0.85 Cython-generated short byte constant with an embedded NUL from table encoding.
    Reasoning

    The embedded NUL in short constants such as \210!\360\006\000 is typical of Cython's packed location-table encoding. It appears among other generated constants and carries no dynamic execution.

  411. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8310:49

    string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k__17[] = "\210!\360\006\000,-";
    static const char __pyx_k__18[] = "\210!\360\006\000-.";
    static const char __pyx_k__19[] = "\210!\340\032\033\330&'";
    static const char __pyx_k__20[] = "\200\001\330\002\003\330\002\030\230\001";
    likely benign LLM, confidence 0.85 Cython-generated byte constant with an embedded NUL from metadata encoding.
    Reasoning

    This is another packed Cython metadata constant with an embedded NUL, in the same generated block as the preceding finding. It is consistent with normal generator output.

  412. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8312:36

    10 consecutive `\NNN` octal escapes (entropy 2.7 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k__19[] = "\210!\340\032\033\330&'";
    static const char __pyx_k__20[] = "\200\001\330\002\003\330\002\030\230\001";
    static const char __pyx_k__21[] = "\200\001\330\002\t\320\t \240\001\240\021";
    static const char __pyx_k__22[] = "\200\001\330\002\t\320\t(\250\001\250\021";
    likely benign LLM, confidence 0.85 Cython-generated encoded metadata constants in the grpc extension.
    Reasoning

    Ten consecutive octal escapes in __pyx_k_ constants are Cython's encoded code-object metadata. The surrounding lines are the same generated pattern, and no decoding or executing code is present.

  413. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8315:36

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k__22[] = "\200\001\330\002\t\320\t(\250\001\250\021";
    static const char __pyx_k__23[] = "\200\001\330\014\022\220!";
    static const char __pyx_k__24[] = "\200\001\330\002!\240\021\240!";
    static const char __pyx_k__25[] = "\200\001\330\002\t\210\021";
    likely benign LLM, confidence 0.85 Cython-generated encoded metadata constants in the grpc extension.
    Reasoning

    These __pyx_k_ constants repeat the same Cython metadata encoding seen throughout the generated file. The octal escapes are data for the generated module, not an obfuscated payload.

  414. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8318:36

    9 consecutive `\NNN` octal escapes (entropy 3.2 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k__25[] = "\200\001\330\002\t\210\021";
    static const char __pyx_k__26[] = "\200\001\360\014\000\005\022\220\021";
    static const char __pyx_k_add[] = "add";
    static const char __pyx_k_bin[] = "-bin";
    likely benign LLM, confidence 0.93 Cython-generated C++ static byte constants encoding Python code-object bytecode, inside grpc's bundled Cython output.
    Reasoning

    The octal runs are byte-string constants holding compiled Python bytecode and line-table data (the `\200\001\330...` pattern is typical of Cython-emitted code objects). The file is generated Cython output from grpc's own source, and the raw-pass octal and entropy signal is a known false positive for this kind of data.

  415. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8338:41

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_3[] = "\200!\330\t\n\330\006/\250q\260\001\260\024\260\\\300\021";
    static const char __pyx_k_q_D[] = "\200!\330\004\013\320\013\037\230q\240\004\240D\250\001";
    static const char __pyx_k_q_a[] = "\200\001\330\004'\240q\250\006\250a";
    likely benign LLM, confidence 0.93 Generated Cython static constant holding bytecode-like bytes for a code object.
    Reasoning

    The sequence is the same kind of Cython code-object byte table (`__pyx_k_q_*` constants with bytecode-like escapes), not a payload or dropper. The file is grpc's generated Cython output and the short octal run is an expected artifact of that generation.

  416. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8340:36

    14 consecutive `\NNN` octal escapes (entropy 3.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_a[] = "\200\001\330\004'\240q\250\006\250a";
    static const char __pyx_k_q_q[] = "\200\001\360\026\000\005\006\330\017\020\330\010\017\210q\330\013\014\330\010\017\210q";
    static const char __pyx_k_q_z[] = "\200\001\330\004\007\200q\330\010\023\320\023'\240z\260\021";
    likely benign LLM, confidence 0.93 Generated Cython byte constant for compiled Python code-object data.
    Reasoning

    Cython emits these `__pyx_k_*` byte arrays for compiled code-object metadata; the escape runs are bytecode and line-table bytes. The file is a generated artifact of grpc's Cython build, and nothing in the snippet decodes or executes them.

  417. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8340:52

    string literal contains an embedded NUL followed by 66 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_q_a[] = "\200\001\330\004'\240q\250\006\250a";
    static const char __pyx_k_q_q[] = "\200\001\360\026\000\005\006\330\017\020\330\010\017\210q\330\013\014\330\010\017\210q";
    static const char __pyx_k_q_z[] = "\200\001\330\004\007\200q\330\010\023\320\023'\240z\260\021";
    likely benign LLM, confidence 0.90 Embedded zero byte inside a generated Cython bytecode constant.
    Reasoning

    The embedded NUL is the `\000` byte in the Python line-table/bytecode data emitted by Cython. Token-level NUL flags on generated byte-array constants are expected; the literal is not used to hide a string from humans or a model.

  418. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8340:93

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_a[] = "\200\001\330\004'\240q\250\006\250a";
    static const char __pyx_k_q_q[] = "\200\001\360\026\000\005\006\330\017\020\330\010\017\210q\330\013\014\330\010\017\210q";
    static const char __pyx_k_q_z[] = "\200\001\330\004\007\200q\330\010\023\320\023'\240z\260\021";
    likely benign LLM, confidence 0.93 Generated Cython constant holding bytecode-like escape bytes.
    Reasoning

    Same generated `__pyx_k_q_q` bytecode-style constant in grpc's Cython output. The escape run is compiled-code data, and the file is a build artifact with no runtime decode or execution in the snippet.

  419. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8347:36

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_uds[] = "uds";
    static const char __pyx_k_vQa[] = "\200\001\330\002\017\210v\220Q\220a";
    static const char __pyx_k_xds[] = "xds";
    static const char __pyx_k_yes[] = "yes";
    likely benign LLM, confidence 0.93 Generated Cython name and bytecode constant table in grpc's cygrpc.cpp.
    Reasoning

    This is a Cython `__pyx_k_*` constant of code-object bytes next to plain identifier strings like 'uds', 'xds' and 'yes', which matches Cython's usual name-table output. The octal run is a generation artifact in a vendored grpc build file.

  420. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8353:69

    9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_8_EQ[] = "\200\001\330\002'\320'8\270\001\330\002\r\320\r\036\320\036E\300Q\330\002\t\210\021";
    static const char __pyx_k_AT_A[] = "\200!\330\t\n\330\006$\240A\240T\250\021\330\004\010\320\010\034\230A";
    static const char __pyx_k_A_4q[] = "\200A\330\010\020\320\020\"\240!\2404\240q";
    likely benign LLM, confidence 0.92 Generated Cython byte constant for compiled code-object metadata.
    Reasoning

    The constants are generated Cython code-object bytes with the same bytecode-like escape patterns seen across this file. Raw-pass octal signals on this generated code are high-noise, and nothing in the snippet decodes or executes the data.

  421. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8404:37

    9 consecutive `\NNN` octal escapes (entropy 3.2 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_t1IQ[] = "\210\001\330\014\017\210t\2201\220I\230Q";
    static const char __pyx_k_t6_2[] = "\320\004\031\230\021\330\010\017\210t\2206\230\021";
    static const char __pyx_k_task[] = "task";
    static const char __pyx_k_test[] = "__test__";
    likely benign LLM, confidence 0.93 Generated Cython static byte constant encoding code-object data.
    Reasoning

    The `__pyx_k_t1IQ` and `__pyx_k_t6_2` arrays are Cython-generated bytecode/line-table constants, adjacent to ordinary name strings such as 'task' and '__test__'. This is standard generated output in grpc's Cython build.

  422. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8413:43

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_wrap[] = "wrap";
    static const char __pyx_k_4_A_a[] = "\200!\360\006\000\005\014\2104\210}\230A\230\\\250\025\250a";
    static const char __pyx_k_8_B_1[] = "\200\001\330\002'\320'8\270\001\330\002\r\320\r\036\320\036B\300!\3001\330\002\t\210\021";
    likely benign LLM, confidence 0.93 Generated Cython byte constant for compiled code-object data.
    Reasoning

    `__pyx_k_4_A_a` and `__pyx_k_8_B_1` are Cython-generated code-object byte constants in grpc's generated cygrpc.cpp. The octal run is compiled-code data, not an obfuscated payload.

  423. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8413:51

    string literal contains an embedded NUL followed by 42 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_wrap[] = "wrap";
    static const char __pyx_k_4_A_a[] = "\200!\360\006\000\005\014\2104\210}\230A\230\\\250\025\250a";
    static const char __pyx_k_8_B_1[] = "\200\001\330\002'\320'8\270\001\330\002\r\320\r\036\320\036B\300!\3001\330\002\t\210\021";
    likely benign LLM, confidence 0.90 Embedded zero byte in a generated Cython bytecode constant.
    Reasoning

    The embedded NUL sits inside a generated Cython `__pyx_k_4_A_a` bytecode constant, where zero bytes are normal in line-table data. Token-pass NUL detection on this generated file is a false positive.

  424. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8416:43

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_HJa[] = "\200A\330\010\014\210H\220J\230a";
    static const char __pyx_k_A_gQa[] = "\200A\330\010\014\320\014\036\230g\240Q\240a";
    static const char __pyx_k_A_q_2[] = "\200A\340\010\017\210q\220\001";
    static const char __pyx_k_A_q_3[] = "\200A\330\010\t\340\010\017\210q";
    likely benign LLM, confidence 0.93 Generated Cython byte constants holding bytecode-like data for code objects.
    Reasoning

    The `__pyx_k_A_*` constants are the same Cython code-object byte tables as the rest of the generated file. The raw octal signal is a false positive on this build artifact.

  425. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8453:38

    4 rows of escape runs, lines 8453-8454 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_lower[] = "lower";
    static const char __pyx_k_q_0_a[] = "\200\001\330\023\037\230q\320 0\260\n\270$\270a";
    static const char __pyx_k_q_a_1[] = "\200\001\330\002\003\340\007\010\330\004\t\320\t\037\230q\240\001\330\004(\250\001\330\002\006\200a\330\002\020\220\013\2301";
    likely benign LLM, confidence 0.92 Cython-generated static byte-string constant holding serialized code-object data in grpc's cygrpc.cpp.
    Reasoning

    The escape runs are marshalled CPython code-object data (bytecode, line and exception tables, with \200\001 and \330-style opcode bytes) emitted by Cython's string-constant table. Their high octal-escape density is expected for this format, and the file is grpc's standard generated Cython output.

  426. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8472:127

    string literal contains an embedded NUL followed by 14 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_write[] = "write";
    static const char __pyx_k_8_AUUV[] = "\200\001\330\002'\320'8\270\001\330\002\r\320\r\036\320\036@\300\001\320AU\320UV\360\010\000\003\n\210\021";
    static const char __pyx_k_AT_2Gq[] = "\200!\340\004\013\320\013$\240A\240T\250\031\3202G\300q";
    likely benign LLM, confidence 0.92 Generated code-object byte constant with a NUL byte, part of Cython's static constant table.
    Reasoning

    The embedded NUL is a \000 byte inside a marshalled code-object blob, which is normal for this serialization format. Cython emits these constants in generated grpc source, and the surrounding table is a generated constant table, not executed or hidden logic.

  427. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8482:52

    string literal contains an embedded NUL followed by 26 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_t9Cq[] = "\200A\330\010\017\210t\2209\230C\230q";
    static const char __pyx_k_A_t9G1[] = "\200A\360\022\000\t\020\210t\2209\230G\2401";
    static const char __pyx_k_A_t9O1[] = "\200A\330\010\017\210t\2209\230O\2501";
    likely benign LLM, confidence 0.92 Cython constant table entries holding serialized code-object bytes with embedded NULs.
    Reasoning

    The NUL-containing literals are marshalled bytecode/line-table data from Cython's generated constant pool. The pattern matches ordinary code-object serialization, not a payload or a string split to evade detection.

  428. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8490:53

    9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_POLLER[] = "POLLER";
    static const char __pyx_k_Qj_w_A[] = "\200\001\340\t\021\220\037\240\001\330\010\020\220\r\230Q\230j\250\001\330\010\017\210w\320\026,\250A";
    static const char __pyx_k_Server[] = "Server";
    static const char __pyx_k_Thread[] = "Thread";
    likely benign LLM, confidence 0.90 Generated static char array of marshalled code-object bytes in grpc's Cython output.
    Reasoning

    Consecutive octal escapes in a static char array in a Cython-generated C++ file are the standard encoding of marshalled code-object data. The bytes are constants only and are not decoded or executed at runtime by any suspicious path shown.

  429. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8490:101

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_POLLER[] = "POLLER";
    static const char __pyx_k_Qj_w_A[] = "\200\001\340\t\021\220\037\240\001\330\010\020\220\r\230Q\230j\250\001\330\010\017\210w\320\026,\250A";
    static const char __pyx_k_Server[] = "Server";
    static const char __pyx_k_Thread[] = "Thread";
    likely benign LLM, confidence 0.90 Generated Cython constant holding serialized code-object bytes.
    Reasoning

    Same generated constant table as the neighbouring finding. The octal runs are Python code-object serialization, typical of Cython output, and the file is a known generated artefact in the grpc source tree.

  430. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8541:45

    9 rows of escape runs, lines 8541-8554 (first: 9 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_values[] = "values";
    static const char __pyx_k_1_T_7_q[] = "\200!\330\004\005\360\006\000\005\006\360\n\000\005\014\320\013\033\2301\330\010\014\320\014\035\230T\320!7\260|\300<\310q";
    static const char __pyx_k_4_A_a_2[] = "\200!\330\004\013\2104\210}\230A\230\\\250\025\250a";
    likely benign LLM, confidence 0.90 Cython-generated byte constants for code-object data in cygrpc.cpp.
    Reasoning

    The escape runs are marshalled code-object constants in Cython-generated C++. Their entropy and density are consistent with bytecode and tables, and the snippet shows no decoding or execution of the bytes.

  431. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8541:65

    string literal contains an embedded NUL followed by 93 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_values[] = "values";
    static const char __pyx_k_1_T_7_q[] = "\200!\330\004\005\360\006\000\005\006\360\n\000\005\014\320\013\033\2301\330\010\014\320\014\035\230T\320!7\260|\300<\310q";
    static const char __pyx_k_4_A_a_2[] = "\200!\330\004\013\2104\210}\230A\230\\\250\025\250a";
    likely benign LLM, confidence 0.90 Generated Cython byte-string constant containing a NUL within code-object data.
    Reasoning

    The embedded NUL sits inside a generated marshalled code-object literal, which is normal for Cython's serialized constants. The surrounding code is a static table, with no dynamic execution or shell calls in view.

  432. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8552:56

    string literal contains an embedded NUL followed by 82 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_q_q_a[] = "\200\001\360\014\000\005\024\320\023$\240A\330\004\007\200q\330\010\017\210q\340\004\013\320\013&\240a";
    static const char __pyx_k_A_t9D_A[] = "\200A\330\010\017\210t\2209\230D\320 <\270A";
    likely benign LLM, confidence 0.90 Cython-generated constant with embedded NUL bytes in serialized code-object data.
    Reasoning

    The literal is a static constant from Cython's generated code-object serialization, with \000 bytes and opcode-like escapes typical of that format. The file is a standard generated grpc artefact.

  433. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8590:40

    10 consecutive `\NNN` octal escapes (entropy 3.1 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_prepare[] = "__prepare__";
    static const char __pyx_k_q_q_s_q[] = "\200\001\330\002\003\340\007\010\330\004\t\320\t\037\230q\240\001\330\004\030\230\001\330\004\027\220q\330\004\010\210\001\330\002\005\320\005\027\220s\230!\330\004\027\220q";
    static const char __pyx_k_request[] = "request";
    likely benign LLM, confidence 0.90 Generated static char array of serialized code-object bytes.
    Reasoning

    The octal runs are marshalled code-object bytes in a Cython-generated static array. Nothing in the snippet decodes or runs them, and the pattern is expected for this generated output.

  434. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8590:97

    11 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_prepare[] = "__prepare__";
    static const char __pyx_k_q_q_s_q[] = "\200\001\330\002\003\340\007\010\330\004\t\320\t\037\230q\240\001\330\004\030\230\001\330\004\027\220q\330\004\010\210\001\330\002\005\320\005\027\220s\230!\330\004\027\220q";
    static const char __pyx_k_request[] = "request";
    likely benign LLM, confidence 0.90 Cython-generated byte constant for serialized code-object data in cygrpc.cpp.
    Reasoning

    This is another entry of the same generated Cython constant table. The long escape run is code-object serialization, not an obfuscated payload, and the file is standard generated grpc output.

  435. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8590:142

    12 consecutive `\NNN` octal escapes (entropy 3.3 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_prepare[] = "__prepare__";
    static const char __pyx_k_q_q_s_q[] = "\200\001\330\002\003\340\007\010\330\004\t\320\t\037\230q\240\001\330\004\030\230\001\330\004\027\220q\330\004\010\210\001\330\002\005\320\005\027\220s\230!\330\004\027\220q";
    static const char __pyx_k_request[] = "request";
    dismissed LLM, confidence 0.92 Cython-emitted static byte-string table of encoded CPython code metadata inside grpc's generated cygrpc.cpp.
    Reasoning

    The snippet is a Cython-generated static string constant holding encoded CPython bytecode line/exception tables (the sequences are typical \200\001\330... patterns). It is a build artifact of a standard Cython compile of grpc's cygrpc module, with no decoding or execution, so the octal-escape run is a legitimate serialization format.

  436. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8602:46

    7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_1_q_gQ[] = "\200A\330\010\021\220\027\320\0301\260\021\330\014\020\220\t\320\031/\250q\260\001\330\014\020\220\001\330\010\016\210g\220Q";
    static const char __pyx_k_A_4q_1_q[] = "\200A\360\016\000\t\014\2104\210q\330\014\023\2201\340\010\017\210q";
    dismissed LLM, confidence 0.92 Generated bytecode-metadata string constant in Cython output for grpc.
    Reasoning

    Same Cython-generated pattern: a static const char array of CPython co_linetable-style encoded data. The raw pass flags octal escapes, which are the normal way Cython emits binary data. No runtime behavior is present in this snippet.

  437. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8602:75

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_1_q_gQ[] = "\200A\330\010\021\220\027\320\0301\260\021\330\014\020\220\t\320\031/\250q\260\001\330\014\020\220\001\330\010\016\210g\220Q";
    static const char __pyx_k_A_4q_1_q[] = "\200A\360\016\000\t\014\2104\210q\330\014\023\2201\340\010\017\210q";
    dismissed LLM, confidence 0.92 Generated Cython bytecode-metadata byte string in grpc's cygrpc.cpp.
    Reasoning

    Part of the same generated table of Cython code-metadata byte strings. Octal escapes encode binary offsets and line deltas, which is an expected artifact of Cython's code object generation.

  438. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8602:115

    11 consecutive `\NNN` octal escapes (entropy 3.1 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_1_q_gQ[] = "\200A\330\010\021\220\027\320\0301\260\021\330\014\020\220\t\320\031/\250q\260\001\330\014\020\220\001\330\010\016\210g\220Q";
    static const char __pyx_k_A_4q_1_q[] = "\200A\360\016\000\t\014\2104\210q\330\014\023\2201\340\010\017\210q";
    dismissed LLM, confidence 0.92 Generated Cython binary metadata literal in the grpc extension source.
    Reasoning

    Same generated Cython output: an escaped binary code-metadata constant with no executing or decoding code near it. The high octal-escape density is inherent to binary data emitted as C literals.

  439. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8603:54

    string literal contains an embedded NUL followed by 50 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_4q_1_q[] = "\200A\360\016\000\t\014\2104\210q\330\014\023\2201\340\010\017\210q";
    static const char __pyx_k_A_AQ_K_E[] = "\200A\330\010,\250A\250Q\330\010\014\210K\320\027,\250E\260\021\260!";
    static const char __pyx_k_A_t8_1_Q[] = "\200A\330\010\017\210t\2208\230?\250!\2501\330+=\270Q";
    dismissed LLM, confidence 0.90 Cython-generated binary constant containing a NUL byte in grpc's cygrpc.cpp.
    Reasoning

    The embedded NUL is a byte in Cython's encoded code-metadata table (for example \000 in the line table). The token pass's NUL heuristic fires on binary data in a C string literal, and this is standard Cython output, not a string-construction attack.

  440. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8611:57

    string literal contains an embedded NUL followed by 109 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_RPCState[] = "RPCState";
    static const char __pyx_k_a_Jc_a_A[] = "\200\001\360\014\000\n\033\230!\330\010\031\230\035\240a\330\010\013\320\013\034\230J\240c\250\021\330\014&\240a\330\010\034\230A";
    static const char __pyx_k_add_note[] = "add_note";
    dismissed LLM, confidence 0.90 Cython-generated static string with an embedded NUL in grpc's cygrpc.cpp.
    Reasoning

    Adjacent entries are Cython-generated static constants, including the encoded code-metadata literal with embedded \000. The NUL is part of binary table data, consistent with compiler output rather than an obfuscated payload.

  441. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8611:72

    4 rows of escape runs, lines 8611-8613 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_RPCState[] = "RPCState";
    static const char __pyx_k_a_Jc_a_A[] = "\200\001\360\014\000\n\033\230!\330\010\031\230\035\240a\330\010\013\320\013\034\230J\240c\250\021\330\014&\240a\330\010\034\230A";
    static const char __pyx_k_add_note[] = "add_note";
    dismissed LLM, confidence 0.92 Generated Cython encoded-metadata rows in grpc's cygrpc.cpp.
    Reasoning

    Four rows of escaped binary bytecode metadata in a Cython-generated C file. The raw pass flags the escape density, but these are standard generated constants with no executable payload.

  442. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8613:173

    string literal contains an embedded NUL followed by 33 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_add_note[] = "add_note";
    static const char __pyx_k_c_j_6a_1[] = "\200\001\330\004 \320 @\300\001\330\010\t\330\010\t\330\010\t\340\004\007\200⟨U+007F⟩\220c\230\021\330\010\016\210j\230\001\230\021\360\006\000\033&\320%6\260a\330\004\013\2101";
    static const char __pyx_k_c_target[] = "c_target";
    dismissed LLM, confidence 0.90 Cython-generated constant with an embedded NUL in grpc's cygrpc.cpp.
    Reasoning

    The embedded NUL sits in a Cython-generated binary constant alongside other __pyx_k_ name and metadata strings. This is normal compiler output for Python code objects in a C extension.

  443. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8636:41

    10 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_pyx_type[] = "__pyx_type";
    static const char __pyx_k_q_q_s_Kq[] = "\200\001\330\002\003\330\007\010\330\004\t\320\t\037\230q\240\001\330\004\027\220q\330\004\007\320\007\027\220s\230!\330\006\024\220K\230q\330\004\010\210\001";
    static const char __pyx_k_qualname[] = "__qualname__";
    dismissed LLM, confidence 0.92 Generated Cython binary metadata literal in grpc's cygrpc.cpp.
    Reasoning

    Generated Cython output: an escaped binary code-metadata literal next to ordinary __pyx_k_ name constants. It is part of grpc's build-time C code and does not execute or fetch anything.

  444. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8636:98

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_pyx_type[] = "__pyx_type";
    static const char __pyx_k_q_q_s_Kq[] = "\200\001\330\002\003\330\007\010\330\004\t\320\t\037\230q\240\001\330\004\027\220q\330\004\007\320\007\027\220s\230!\330\006\024\220K\230q\330\004\010\210\001";
    static const char __pyx_k_qualname[] = "__qualname__";
    dismissed LLM, confidence 0.92 Generated Cython encoded-metadata string in grpc's cygrpc.cpp.
    Reasoning

    Same generated pattern of encoded CPython code-metadata bytes in a Cython-compiled C source file. The escape density is typical of binary tables emitted this way.

  445. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8636:123

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_pyx_type[] = "__pyx_type";
    static const char __pyx_k_q_q_s_Kq[] = "\200\001\330\002\003\330\007\010\330\004\t\320\t\037\230q\240\001\330\004\027\220q\330\004\007\320\007\027\220s\230!\330\006\024\220K\230q\330\004\010\210\001";
    static const char __pyx_k_qualname[] = "__qualname__";
    likely benign LLM, confidence 0.93 Cython-generated static string holding marshalled code-object bytes in grpcio's cygrpc.cpp.
    Reasoning

    The snippet is a static const char array named __pyx_k_q_q_s_Kq that holds marshalled Python bytecode (line-table style bytes such as \200\001\330\002), which Cython emits for code objects in generated C. The file is grpcio's generated Cython output, so this is a standard build artifact, not hidden payload.

  446. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8650:108

    4 rows of escape runs, lines 8650-8655 (first: 7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_A_4_S_A_0[] = "\200A\330\010\013\2104\210~\230S\240\004\240A\330\014\020\320\0200\260\001\340\014\020\320\020!\240\021";
    static const char __pyx_k_A_4_aq_4A[] = "\200A\330\010\013\2104\210{\230!\330\014\022\220,\230a\230q\340\014\020\220\013\320\0334\260A";
    likely benign LLM, confidence 0.93 Cython-generated marshalled bytecode constants in the grpcio extension source.
    Reasoning

    Repeated __pyx_k_ constants made of octal escape runs are the same Cython-emitted marshal data for code metadata. The pattern recurs across many generated constants in a single generated file, consistent with normal compilation output.

  447. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8672:102

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_WriteFlag[] = "WriteFlag";
    static const char __pyx_k_a_c_j_A_1[] = "\200\001\330\004 \320 >\270a\330\010\t\340\004\007\200⟨U+007F⟩\220c\230\021\330\010\016\210j\230\001\230\021\330:<\270A\330\004\013\2101";
    static const char __pyx_k_algorithm[] = "algorithm";
    likely benign LLM, confidence 0.93 Generated Cython string constant containing marshalled code-object bytes.
    Reasoning

    The flagged __pyx_k_a_c_j_A_1 constant is marshalled code-object data in Cython output, adjacent to ordinary identifier strings such as WriteFlag and algorithm. Nothing indicates a decoder or dropper.

  448. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8706:208

    6 rows of escape runs, lines 8706-8709 (first: 6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte)) (raw pass, confidence 0.65)

    30\230\n\240(\250\"\250A\340\002\027\220q\330\002 \240\001\340\002\022\220&\230\005\230V\2401\360\006\000\003\032\230\021\230!\360\006\000\003\t\210\t\220\021\220!";
    likely benign LLM, confidence 0.92 Generated Cython marshal-data literal in grpcio's cygrpc.cpp.
    Reasoning

    This is another __pyx_k_ marshal-data literal in the generated cygrpc.cpp. The raw-pass octal-escape signal is a known false positive for this kind of serialized bytecode.

  449. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8706:259

    string literal contains an embedded NUL followed by 58 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_vQ_A_q_V1[] = "\200\001\340\002\003\330\002\003\330\002\003\330\002\003\330\002\003\340\t\n\330\t\n\340\002\017\210v\220Q\330\002\030\230\n\240(\250\"\250A\340\002\027\220q\330\002 \240\001\340\002\022\220&\230\005\230V\2401\360\006\000\003\032\230\021\230!\360\006\000\003\t\210\t\220\021\220!
    likely benign LLM, confidence 0.90 Generated string literal holding marshalled bytes that include NULs, from Cython output.
    Reasoning

    The embedded NUL is part of the marshalled bytecode bytes (\000 appears in code-object line tables). Cython emits these as C string literals with explicit lengths, so the NUL and the rest of the literal are normal generated output.

  450. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8752:43

    9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_y_Q_Qa_6[] = "\200\001\330\002\006\320\006\027\220q\230\007\230y\250\005\250Q\330\002\003\200:\210Q\210a\330\002\003\2006\210\021";
    static const char __pyx_k_query_call[] = "query_call";
    static const char __pyx_k_receive_op[] = "receive_op";
    likely benign LLM, confidence 0.93 Cython-generated marshalled bytecode constant in grpcio's extension source.
    Reasoning

    The __pyx_k_q_y_Q_Qa_6 constant is marshalled code-object data in generated Cython C, surrounded by ordinary identifier names like query_call and receive_op. This is standard Cython output.

  451. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8760:67

    7 rows of escape runs, lines 8760-8764 (first: 8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_write_flag[] = "write_flag";
    static const char __pyx_k_8_c_j_35Q_1[] = "\200\001\330\004 \320 8\270\001\270\021\330\004\007\200⟨U+007F⟩\220c\230\021\330\010\016\210j\230\001\230\021\33035\260Q\330\004\013\2101";
    likely benign LLM, confidence 0.92 Generated Cython marshal-data rows in grpcio's cygrpc.cpp.
    Reasoning

    The flagged rows are generated __pyx_k_ marshal constants with escape runs, the same format as the rest of the Cython output. The file is a generated C extension source with no execution or network logic in these literals.

  452. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8813:132

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_4y_1_A_8_A[] = "\200A\340\010\013\2104\210y\230\003\2301\330\014\023\320\023$\240A\340\014\023\320\0238\270\001\330\020\024\220A\330\020\021";
    likely benign LLM, confidence 0.93 Generated Cython marshal constant with octal escape bytes.
    Reasoning

    The __pyx_k_A_4y_1_A_8_A literal is a marshalled code-object string as emitted by Cython. Its structure matches the other generated constants in this file.

  453. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8814:61

    string literal contains an embedded NUL followed by 191 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_a_4s_s_1_4[] = "\200\001\360\014\000\n\033\230!\330\010\017\320\017 \240\n\250\"\250A\330\010\031\230\035\240a\360$\000\t\014\2104\210s\220%\220s\230#\230^\2501\330\014\r\360\022\000\t\014\2104\320\017 \240\001\330\014 \240\001";
    likely benign LLM, confidence 0.90 Generated Cython literal with embedded NULs from marshalled code data.
    Reasoning

    The literal holds marshalled bytecode with embedded NUL bytes, which Cython generates for code-object metadata. It is a generated constant in a grpcio build file, not a payload.

  454. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8814:114

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_a_4s_s_1_4[] = "\200\001\360\014\000\n\033\230!\330\010\017\320\017 \240\n\250\"\250A\330\010\031\230\035\240a\360$\000\t\014\2104\210s\220%\220s\230#\230^\2501\330\014\r\360\022\000\t\014\2104\320\017 \240\001\330\014 \240\001";
    likely benign LLM, confidence 0.92 Generated Cython marshal constant that repeats the flagged line.
    Reasoning

    This is the same __pyx_k_A_a_4s_s_1_4 marshal constant as the token finding on the same line. The octal-escape signal reflects normal serialized bytecode in generated Cython code.

  455. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8844:45

    10 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_Q_xs_7_1_b[] = "\200\001\330\002\003\330\004\016\320\016!\240\026\240q\320(=\270Q\330\004\007\200x\210s\220!\330\006\007\330\004\t\210\027\220\001\220\021\330\004\013\2107\220!\2201\330\004\006\200b\210\001";
    static const char __pyx_k_request_call[] = "_request_call";
    likely benign LLM, confidence 0.93 Cython-generated marshalled bytecode constant in grpcio's cygrpc.cpp.
    Reasoning

    The __pyx_k_q_Q_xs_7_1_b literal is marshalled code-object data in generated Cython output, placed between normal identifier constants like request_call. Nothing suggests decoding or execution at runtime.

  456. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8844:159

    10 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_Q_xs_7_1_b[] = "\200\001\330\002\003\330\004\016\320\016!\240\026\240q\320(=\270Q\330\004\007\200x\210s\220!\330\006\007\330\004\t\210\027\220\001\220\021\330\004\013\2107\220!\2201\330\004\006\200b\210\001";
    static const char __pyx_k_request_call[] = "_request_call";
    likely benign LLM, confidence 0.93 Cython-generated static string holding a code-object location table in grpc's cygrpc.cpp.
    Reasoning

    The octal run sits in a static const char array named __pyx_k_q_Q_xs_7_1_b, emitted by Cython. The bytes (\200\001\330\002...) match the Python 3.11+ code-object location/exception table encoding, not executable payload. The file is a generated Cython C++ translation unit for grpc, so this is a standard build artifact.

  457. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8854:117

    8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_stringsource[] = "<stringsource>";
    static const char __pyx_k_t4q_Jaq_Q_AT[] = "\200!\330\004\007\200t\2104\210q\330\006\014\210J\220a\220q\330\t\r\210Q\330\006\007\340\013\014\330\010$\240A\240T\250\021";
    static const char __pyx_k_timeout_secs[] = "timeout_secs";
    likely benign LLM, confidence 0.93 Cython-generated constant byte table (code-object position metadata) in grpc's generated C++.
    Reasoning

    The array __pyx_k_t4q_Jaq_Q_AT is one of Cython's __pyx_k_ name/table constants, and its octal bytes follow the same location-table encoding seen throughout the generated file. No decoding or execution path is present in the snippet, and the file is a generated grpc extension source.

  458. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8859:156

    7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_4y_1_81_a_q[] = "\200A\340\010\013\2104\210y\230\003\2301\330\014\023\2208\2301\330\020\021\340\014\r\340\010\014\320\014&\240a\330\014\020\220\010\320\030(\250\001\250\021\340\010\014\320\014(\250\007\250q\260\001";
    likely benign LLM, confidence 0.93 Generated Cython code-object metadata array in grpc's cygrpc.cpp.
    Reasoning

    This is a __pyx_k_ static array of location-table bytes emitted by the Cython compiler for a Python code object. The pattern is the expected output of Cython for grpc's Python bindings, so the octal escapes reflect compiler metadata rather than a hidden payload.

  459. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8859:185

    9 consecutive `\NNN` octal escapes (entropy 2.7 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_4y_1_81_a_q[] = "\200A\340\010\013\2104\210y\230\003\2301\330\014\023\2208\2301\330\020\021\340\014\r\340\010\014\320\014&\240a\330\014\020\220\010\320\030(\250\001\250\021\340\010\014\320\014(\250\007\250q\260\001";
    likely benign LLM, confidence 0.93 Second flagged octal run from the same Cython-generated code-object table.
    Reasoning

    The flagged snippet is the same __pyx_k_A_4y_1_81_a_q array, with the same location-table byte structure. It is a Cython-generated constant in a standard generated source file and carries no runtime behavior in the snippet.

  460. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8869:59

    string literal contains an embedded NUL followed by 111 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_OperationType[] = "OperationType";
    static const char __pyx_k_Q_1_IWHF_Ja_y[] = "\200!\360\006\000\030>\270Q\330\004\013\320\013\033\2301\330\010\014\210I\220W\230H\240F\250*\260J\270a\330\010\037\230y\250\001";
    likely benign LLM, confidence 0.90 Cython-emitted code-object table whose byte encoding contains a NUL.
    Reasoning

    The embedded \000 is part of the Python 3.11 location/exception table encoding inside a Cython __pyx_k_ constant, not a deliberate string-truncation trick. The surrounding names and file are standard generated grpc bindings.

  461. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8869:73

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_OperationType[] = "OperationType";
    static const char __pyx_k_Q_1_IWHF_Ja_y[] = "\200!\360\006\000\030>\270Q\330\004\013\320\013\033\2301\330\010\014\210I\220W\230H\240F\250*\260J\270a\330\010\037\230y\250\001";
    likely benign LLM, confidence 0.93 Generated Cython location-table constant with high-entropy-looking octal bytes.
    Reasoning

    This is the __pyx_k_Q_1_IWHF_Ja_y Cython constant containing location-table bytes. It matches generated compiler output for grpc and shows no decoding, execution, or network use.

  462. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8905:60

    string literal contains an embedded NUL followed by 99 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_unused_future[] = "unused_future";
    static const char __pyx_k_A_4t5_1_t85_3j[] = "\200A\360\014\000\t\014\2104\210t\2205\230\001\330\014\023\2201\340\010\017\210t\2208\2305\240\003\2403\240j\260\001";
    likely benign LLM, confidence 0.90 Cython-generated code-object table with an embedded NUL byte in grpc bindings.
    Reasoning

    The NUL-containing literal is a __pyx_k_A_4t5_1_t85_3j Cython constant encoding code-object position data. The pattern is typical of the generated file and does not involve executable or dropper behavior.

  463. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8905:85

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_unused_future[] = "unused_future";
    static const char __pyx_k_A_4t5_1_t85_3j[] = "\200A\360\014\000\t\014\2104\210t\2205\230\001\330\014\023\2201\340\010\017\210t\2208\2305\240\003\2403\240j\260\001";
    likely benign LLM, confidence 0.93 Generated Cython octal constant for code-object metadata.
    Reasoning

    The same generated __pyx_k_A_4t5_1_t85_3j constant appears here with its octal location-table bytes. Nothing in the snippet decodes or runs them; it is compiler metadata in a standard generated grpc file.

  464. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8948:52

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_wgT_1Jj_4wm1_4[] = "\200!\360\030\000\005\010\200w\210g\220T\230\021\330\006\n\320\n#\2401\240J\250j\270\001\330\017\"\240!\2404\240w\250m\2701\330\004\013\2104\320\017(\250\001\250\027\260\001";
    static const char __pyx_k_yield_to_queue[] = "yield_to_queue";
    likely benign LLM, confidence 0.93 Generated Cython code-object table in grpc's cygrpc.cpp.
    Reasoning

    The __pyx_k_wgT_1Jj_4wm1_4 array is a Cython-emitted location table with the same encoding as the other flagged constants. It is a generated grpc binding artifact with no associated execution in the snippet.

  465. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8948:60

    string literal contains an embedded NUL followed by 156 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_wgT_1Jj_4wm1_4[] = "\200!\360\030\000\005\010\200w\210g\220T\230\021\330\006\n\320\n#\2401\240J\250j\270\001\330\017\"\240!\2404\240w\250m\2701\330\004\013\2104\320\017(\250\001\250\027\260\001";
    static const char __pyx_k_yield_to_queue[] = "yield_to_queue";
    likely benign LLM, confidence 0.90 Cython constant with an embedded NUL from the code-object table encoding.
    Reasoning

    The embedded NUL belongs to the Cython location-table byte sequence in __pyx_k_wgT_1Jj_4wm1_4. This is standard compiler output for Python 3.11+ code objects in a generated grpc source file.

  466. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8951:154

    11 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_A_1D_1_wgQa_q[] = "\200A\330\010\034\230A\330\010\021\320\021#\2401\240D\250\013\2601\330\010\020\220\007\220w\230g\240Q\240a\330\010\020\220\001\220\021\330\010\017\210q";
    likely benign LLM, confidence 0.93 Generated Cython code-object constant with octal escapes in grpc bindings.
    Reasoning

    This is another Cython __pyx_k_ constant (__pyx_k_A_A_1D_1_wgQa_q) with the standard location-table byte pattern. It appears in a generated grpc binding file and has no decoding or execution behavior.

  467. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8952:61

    string literal contains an embedded NUL followed by 148 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_q_4v_Qa_4v_nA[] = "\200A\360\016\000\t\014\210=\230\007\230q\330\014\023\2204\220v\230\\\250\021\330\020\024\320\024-\250Q\250a\360\006\000\r\024\2204\220v\230\\\250\021\250$\250n\270A";
    static const char __pyx_k_AioChannel_call[] = "AioChannel.call";
    likely benign LLM, confidence 0.93 Cython-generated static byte-string constant holding serialized Python code metadata in grpc's cygrpc.cpp.
    Reasoning

    The file is Cython-generated C++ from grpc's cygrpc module. The octal-escaped byte run is a marshalled code-object or line-table blob (the \200, \330, \360 patterns are typical CPython 3.11+ location-table bytes) stored as a static constant. The embedded NUL is an artifact of binary data in a C string literal, and nothing in the snippet decodes or executes the bytes.

  468. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8952:117

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_q_4v_Qa_4v_nA[] = "\200A\360\016\000\t\014\210=\230\007\230q\330\014\023\2204\220v\230\\\250\021\330\020\024\320\024-\250Q\250a\360\006\000\r\024\2204\220v\230\\\250\021\250$\250n\270A";
    static const char __pyx_k_AioChannel_call[] = "AioChannel.call";
    likely benign LLM, confidence 0.93 Dense octal escapes encoding a Cython-generated code-metadata constant.
    Reasoning

    The octal run is the same generated marshalled-code constant as the adjacent token finding. Dense escapes of binary code metadata in generated C are expected, and the value is only a static constant.

  469. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8983:75

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_Ct_e1_a_X_1_A[] = "\200!\330\004\023\220<\230q\240\001\330\004\007\200}\220C\220t\320\033.\250e\2601\340\006\007\330\004.\320.>\270a\270~\310[\320X\\\320\\]\330\004\010\320\010\033\2301\320\034,\250A";
    static const char __pyx_k_receive_message[] = "_receive_message";
    likely benign LLM, confidence 0.93 Generated static byte constant with CPython code-metadata octal escapes.
    Reasoning

    This is another Cython-generated static constant of marshalled code metadata in a generated C++ file. It is data for the module's name table, not executable payload.

  470. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8983:185

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_Ct_e1_a_X_1_A[] = "\200!\330\004\023\220<\230q\240\001\330\004\007\200}\220C\220t\320\033.\250e\2601\340\006\007\330\004.\320.>\270a\270~\310[\320X\\\320\\]\330\004\010\320\010\033\2301\320\034,\250A";
    static const char __pyx_k_receive_message[] = "_receive_message";
    likely benign LLM, confidence 0.93 Generated static constant with octal-escaped binary metadata beside an identifier string.
    Reasoning

    Same generated pattern: a Cython name-table constant in a grpc extension source. Octal escapes are just how the compiler emits binary bytes in C string literals.

  471. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8998:48

    7 rows of escape runs, lines 8998-9003 (first: 9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte)) (raw pass, confidence 0.65)

    static const char __pyx_k_t_q_1_s_Qa_7_31[] = "\200\001\330\004\005\330\010\017\210t\220<\230q\240\001\330\004\013\320\013\033\2301\330\010\013\320\013'\240s\250#\250Q\250a\330\014\023\2207\320\0323\2601\330\020\021\330\020\021\360\006\000\r\016";
    static const char __pyx_k_tracing_enabled[] = "tracing_enabled";
    likely benign LLM, confidence 0.92 Multi-row generated constant table of octal-escaped code metadata.
    Reasoning

    Lines 8998-9003 are a run of generated static constants of the same form. The escape density reflects compiled binary metadata emitted by Cython, and no decode or execution path appears in the snippet.

  472. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:8998:236

    string literal contains an embedded NUL followed by 6 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_t_q_1_s_Qa_7_31[] = "\200\001\330\004\005\330\010\017\210t\220<\230q\240\001\330\004\013\320\013\033\2301\330\010\013\320\013'\240s\250#\250Q\250a\330\014\023\2207\320\0323\2601\330\020\021\330\020\021\360\006\000\r\016";
    static const char __pyx_k_tracing_enabled[] = "tracing_enabled";
    likely benign LLM, confidence 0.92 Generated byte constant containing an embedded NUL from serialized code metadata.
    Reasoning

    Embedded NUL in a generated static byte constant is normal for marshalled binary data emitted by Cython. It is not a hidden-string or payload mechanism in this context.

  473. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9002:62

    string literal contains an embedded NUL followed by 143 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_7_Q_Ja_4_t_AWA[] = "\200A\360\034\000\t\014\2107\220'\230\024\230Q\330\014\020\320\020)\250\021\250*\260J\270a\330\027*\250!\2504\250{\270!\330\010\017\210t\320\023,\250A\250W\260A";
    likely benign LLM, confidence 0.92 Generated static constant with an embedded NUL from serialized code metadata.
    Reasoning

    Same generated Cython constant pattern. The embedded NUL and escapes come from serialized binary code metadata, typical of the generated file.

  474. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9010:63

    9 consecutive `\NNN` octal escapes (entropy 2.9 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_Qj_v_A_vQb_2Qa_q[] = "\200\001\340\t\021\220\037\240\001\330\010\020\220\r\230Q\230j\250\001\330\010\017\210v\220_\240A\330\010\017\210v\220Q\220b\320\030;\2702\270Q\270a\340\010\017\210q";
    static const char __pyx_k_RSA_PKCS1_SHA256[] = "RSA_PKCS1_SHA256";
    likely benign LLM, confidence 0.93 Generated static byte constant with dense octal escapes in a grpc Cython file.
    Reasoning

    This is a Cython-generated name constant encoding CPython code metadata, next to an ordinary identifier string. Nothing in the snippet executes or transmits the bytes.

  475. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9010:111

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_Qj_v_A_vQb_2Qa_q[] = "\200\001\340\t\021\220\037\240\001\330\010\020\220\r\230Q\230j\250\001\330\010\017\210v\220_\240A\330\010\017\210v\220Q\220b\320\030;\2702\270Q\270a\340\010\017\210q";
    static const char __pyx_k_RSA_PKCS1_SHA256[] = "RSA_PKCS1_SHA256";
    likely benign LLM, confidence 0.93 Generated static constant of octal-escaped code metadata.
    Reasoning

    Same generated constant family as the other findings in this file. The escapes are compiled binary metadata, not an obfuscated payload.

  476. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9049:160

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_1_t1_l_1_aq_7_q_q[] = "\200\001\340\004\r\320\r#\2401\330\004\007\200t\2101\330\010\016\210l\230!\2301\340\004\032\320\032>\270a\270q\330\004\007\320\007\033\2307\240!\330\010\017\210q\360\006\000\005\014\320\013'\240q\250\001";
    likely benign LLM, confidence 0.93 Generated static byte constant with CPython-style code-metadata escapes.
    Reasoning

    A generated Cython string constant of marshalled code metadata in grpc's extension source. The octal runs match the compiler's binary-to-literal output and are not reached by any decode or exec in the snippet.

  477. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9049:211

    7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_1_t1_l_1_aq_7_q_q[] = "\200\001\340\004\r\320\r#\2401\330\004\007\200t\2101\330\010\016\210l\230!\2301\340\004\032\320\032>\270a\270q\330\004\007\320\007\033\2307\240!\330\010\017\210q\360\006\000\005\014\320\013'\240q\250\001";
    likely benign LLM, confidence 0.93 Second octal-escape run in the same generated constant, likely serialized code metadata.
    Reasoning

    Same generated pattern. The static constant holds serialized code metadata in a generated C++ translation unit, consistent with Cython output for grpc.

  478. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9049:219

    string literal contains an embedded NUL followed by 30 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_1_t1_l_1_aq_7_q_q[] = "\200\001\340\004\r\320\r#\2401\330\004\007\200t\2101\330\010\016\210l\230!\2301\340\004\032\320\032>\270a\270q\330\004\007\320\007\033\2307\240!\330\010\017\210q\360\006\000\005\014\320\013'\240q\250\001";
    dismissed LLM, confidence 0.90 Cython-generated static byte constant holding encoded Python code-object metadata in grpcio's generated C++ extension source.
    Reasoning

    The literal is a byte string of Python 3.11+ bytecode-style data (co_linetable/exception-table-like octal escapes) emitted by Cython for a code object in the generated grpc cygrpc.cpp. The NUL-in-string finding is an artifact of binary data in a generated file, not an execution payload; no decode or execution path is visible here.

  479. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9050:65

    12 consecutive `\NNN` octal escapes (entropy 3.1 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_0_d_7_wa_AU_avU[] = "\200A\330\010\t\330\014\020\220\010\230\001\330\020\027\320\0270\260\001\260\025\260d\270!\2707\300%\300w\310a\340\014\023\320\023,\250A\250U\260$\260a\260v\270U\300'\310\021";
    static const char __pyx_k_ActiveThreadCount[] = "_ActiveThreadCount";
    dismissed LLM, confidence 0.85 Generated static char array of serialized bytecode bytes in grpcio's cygrpc.cpp.
    Reasoning

    Raw-pass octal-escape density is typical of Cython's serialized code-object constants in a machine-generated file. The adjacent constant is a plain identifier string, so this is a legitimate generated pattern with high-entropy binary content.

  480. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9068:55

    12 consecutive `\NNN` octal escapes (entropy 3.4 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_a_t5_2Q_q_1D_WA_a[] = "\200!\330\004\005\360\006\000\005\010\320\007\036\230a\330\006\027\220t\2305\240\003\2402\240Q\340\006\027\220q\360\010\000\005\014\320\013\033\2301\230D\240\t\250\024\250W\260A\330\034(\250\006\250a";
    static const char __pyx_k_abort_with_status[] = "abort_with_status";
    dismissed LLM, confidence 0.85 Cython-emitted serialized code-object bytes as a C string constant in the grpc extension source.
    Reasoning

    Same generated Cython pattern: a byte-string constant of encoded code-object data followed by ordinary identifier constants. Raw-pass entropy and escape counts reflect binary bytecode, not obfuscated logic.

  481. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9068:75

    string literal contains an embedded NUL followed by 170 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_a_t5_2Q_q_1D_WA_a[] = "\200!\330\004\005\360\006\000\005\010\320\007\036\230a\330\006\027\220t\2305\240\003\2402\240Q\340\006\027\220q\360\010\000\005\014\320\013\033\2301\230D\240\t\250\024\250W\260A\330\034(\250\006\250a";
    static const char __pyx_k_abort_with_status[] = "abort_with_status";
    dismissed LLM, confidence 0.85 Generated C string literal with embedded NULs from serialized Python bytecode in grpcio.
    Reasoning

    The token pass flags an embedded NUL in the same generated bytecode constant. In Cython output this is expected because the constant holds binary code-object data; the string is only stored, never executed.

  482. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9068:161

    9 consecutive `\NNN` octal escapes (entropy 3.2 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_a_t5_2Q_q_1D_WA_a[] = "\200!\330\004\005\360\006\000\005\010\320\007\036\230a\330\006\027\220t\2305\240\003\2402\240Q\340\006\027\220q\360\010\000\005\014\320\013\033\2301\230D\240\t\250\024\250W\260A\330\034(\250\006\250a";
    static const char __pyx_k_abort_with_status[] = "abort_with_status";
    dismissed LLM, confidence 0.85 Serialized bytecode byte constant in grpcio's generated cygrpc.cpp.
    Reasoning

    Raw-pass octal escape run inside a Cython-generated bytecode constant in a standard grpc source file. Consistent with machine-serialized data rather than an encoded dropper.

  483. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9096:134

    8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_t1_D_1_A_1_waq_1[] = "\200A\330\010\037\230t\2401\330\010\022\220*\230D\240\013\2501\330\010\027\320\027(\250\001\250\021\330\010\022\220*\230A\330\010\013\2101\330\014\023\220<\230w\240a\240q\340\014\023\2201";
    static const char __pyx_k_AioChannel_closing[] = "AioChannel.closing";
    dismissed LLM, confidence 0.85 Cython-generated byte-string constant of serialized code metadata in grpcio.
    Reasoning

    Generated Cython code-object byte constant; the octal run is binary bytecode data typical of this file, with no decode-and-run logic present in the snippet.

  484. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9108:55

    string literal contains an embedded NUL followed by 154 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_UUV_B_4q_Q_ay_3a_1[] = "\320\000U\320UV\330\002\014\320\014 \320 B\300!\3004\300q\330\002\005\200Q\330\004\031\320\031.\250a\250y\270\001\330\004\013\2103\210a\210{\230!\340\004\013\2101";
    static const char __pyx_k_UnicodeDecodeError[] = "UnicodeDecodeError";
    dismissed LLM, confidence 0.85 Generated C constant with embedded NULs from serialized Python bytecode in grpcio's cygrpc.cpp.
    Reasoning

    Token-pass NUL finding on a generated bytecode constant. Cython emits these for code objects, so the flag reflects binary content in generated source rather than malicious string construction.

  485. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9108:156

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_UUV_B_4q_Q_ay_3a_1[] = "\320\000U\320UV\330\002\014\320\014 \320 B\300!\3004\300q\330\002\005\200Q\330\004\031\320\031.\250a\250y\270\001\330\004\013\2103\210a\210{\230!\340\004\013\2101";
    static const char __pyx_k_UnicodeDecodeError[] = "UnicodeDecodeError";
    dismissed LLM, confidence 0.85 Serialized bytecode byte string in generated grpcio extension source.
    Reasoning

    Raw-pass escape run within the same generated bytecode constant. Typical Cython serialization of code objects in a widely used project's generated source.

  486. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9175:52

    9 consecutive `\NNN` octal escapes (entropy 3.2 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_A_Q_1_7q_V3a_q_1A[] = "\200\001\360\006\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\n\320\n7\260q\270\001\330\002\005\200V\2103\210a\330\004\n\210!\340\004\n\210(\320\022?\270q\300\001\330\002\033\2301\230A\330\002\t\210\021";
    dismissed LLM, confidence 0.85 Cython-emitted serialized code-object bytes as a static C string in grpcio.
    Reasoning

    Generated Cython bytecode constant with octal escapes. The snippet shows only data bytes and adjacent identifier strings, consistent with the legitimate generated file.

  487. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9175:68

    string literal contains an embedded NUL followed by 228 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_q_A_Q_1_7q_V3a_q_1A[] = "\200\001\360\006\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\n\320\n7\260q\270\001\330\002\005\200V\2103\210a\330\004\n\210!\340\004\n\210(\320\022?\270q\300\001\330\002\033\2301\230A\330\002\t\210\021";
    dismissed LLM, confidence 0.85 Generated C literal containing embedded NULs from serialized Python bytecode in cygrpc.cpp.
    Reasoning

    Token-pass NUL-in-string finding on generated bytecode data. This is a known artifact of Cython's code-object serialization and does not indicate hidden execution.

  488. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9175:173

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_A_Q_1_7q_V3a_q_1A[] = "\200\001\360\006\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\n\320\n7\260q\270\001\330\002\005\200V\2103\210a\330\004\n\210!\340\004\n\210(\320\022?\270q\300\001\330\002\033\2301\230A\330\002\t\210\021";
    dismissed LLM, confidence 0.93 Cython-generated code-object line-table bytes stored as a C string literal.
    Reasoning

    This is a Cython-generated static byte-string constant in grpc's vendored cygrpc.cpp. The octal sequences are Python code-object location-table data (line/column offsets), not an encoded payload. Nothing decodes or executes it, and generated Cython output of this kind is routine.

  489. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9175:252

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_q_A_Q_1_7q_V3a_q_1A[] = "\200\001\360\006\000\003\022\320\021'\240q\250\004\250A\330\002\005\200]\220#\220Q\330\004\013\2101\330\002\n\320\n7\260q\270\001\330\002\005\200V\2103\210a\330\004\n\210!\340\004\n\210(\320\022?\270q\300\001\330\002\033\2301\230A\330\002\t\210\021";
    dismissed LLM, confidence 0.93 Cython-generated code-object line-table bytes stored as a C string literal.
    Reasoning

    Same constant as the previous finding, from the same Cython-generated grpc source. The octal bytes are compiled-code position metadata, and the literal is only referenced as data.

  490. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9180:53

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_too_many_operations[] = "too_many_operations";
    static const char __pyx_k_7_ay_72FayPSSZZmmnno[] = "\200\001\340\004\013\2107\220,\230a\230y\250\003\2507\3202F\300a\300y\320PS\320SZ\320Zm\320mn\320no";
    static const char __pyx_k_Abort_already_called[] = "Abort already called!";
    dismissed LLM, confidence 0.92 Cython-generated code-object location-table bytes in a C string constant.
    Reasoning

    The octal-escape string is a Cython-generated code-object location table in the same generated file. The neighbouring constants are ordinary identifier and message strings, which is typical of Cython output.

  491. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9209:53

    8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    atic const char __pyx_k_hk_A_1_9HAQ_7_1L_a_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\360\000\000\"|\004\360\000\000|\004~\004\360\000\000~\004⟨U+007F⟩\004\330\004\023\2209\230H\240A\240Q\330\004\007\200|\2207\230!\330\010+\2501\250L\270\016\300a\330\004\013\2101";
    dismissed LLM, confidence 0.92 Cython-generated location-table bytes in a static C string constant.
    Reasoning

    This is a Cython-generated static constant whose escapes encode code-object position data, with the \000 bytes as zero-valued fields. It is compiled-in metadata in generated grpc code, not a dropper or payload.

  492. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9209:69

    string literal contains an embedded NUL followed by 248 more bytes of source (token pass, confidence 0.85)

    t char __pyx_k_hk_A_1_9HAQ_7_1L_a_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\360\000\000\"|\004\360\000\000|\004~\004\360\000\000~\004⟨U+007F⟩\004\330\004\023\2209\230H\240A\240Q\330\004\007\200|\2207\230!\330\010+\2501\250L\270\016\300a\330\004\013\2101";
    dismissed LLM, confidence 0.92 Embedded NUL bytes inside a Cython-generated location-table string constant.
    Reasoning

    The embedded NULs are zero-valued fields inside the Cython code-object location table. Generated Cython emits such constants routinely, and this finding does not show anything being run from them.

  493. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9223:100

    7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_Q_q_t_a_7_4q_q_q_8_7q[] = "\200\001\330\004\r\210Q\330\004\007\200q\330\r\030\230\001\330\014\017\210t\220;\230a\330\020\023\2207\230!\2304\230q\330\024\026\320\026'\240q\250\007\250q\330(8\270\001\330(7\260q\330\024\037\320\037:\270!";
    dismissed LLM, confidence 0.92 Cython-generated code-object location-table bytes in a C string constant.
    Reasoning

    This is another Cython-generated code-object location table in grpc's generated C++. The octal bytes are compiled metadata, and there is no decode-and-execute path in the snippet.

  494. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9237:54

    8 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_hk_A_1_kkmmn_7_q0_a_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\220=\240\010\250\001\250\021\330\004\007\200|\2207\230!\330\010/\250q\3200@\300\016\310a\330\004\013\2101";
    dismissed LLM, confidence 0.92 Cython-generated code-object location-table bytes in a static C string.
    Reasoning

    This is a Cython-generated location-table constant in grpc's generated source. The escape run is compiled position metadata, not an obfuscated payload.

  495. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9237:70

    string literal contains an embedded NUL followed by 213 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_hk_A_1_kkmmn_7_q0_a_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\220=\240\010\250\001\250\021\330\004\007\200|\2207\230!\330\010/\250q\3200@\300\016\310a\330\004\013\2101";
    dismissed LLM, confidence 0.92 Embedded NUL bytes inside a Cython-generated location-table string constant.
    Reasoning

    The embedded NULs are zero-valued fields inside a Cython code-object location table in generated grpc code. This is standard generator output rather than hidden data.

  496. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9237:186

    10 consecutive `\NNN` octal escapes (entropy 3.1 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_hk_A_1_kkmmn_7_q0_a_1[] = "\200\001\360\006\000\005\010\200⟨U+007F⟩\220h\230k\250\033\260A\330\010\r\210^\2301\330\010\016\320\016!\320!k\320km\320mn\330\004\023\220=\240\010\250\001\250\021\330\004\007\200|\2207\230!\330\010/\250q\3200@\300\016\310a\330\004\013\2101";
    dismissed LLM, confidence 0.92 Cython-generated code-object location-table bytes in a static C string.
    Reasoning

    This is a Cython-generated location-table constant in grpc's generated C++. The 10-escape run is compiled position metadata, and the snippet shows no decoding or execution.

  497. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:60

    7 consecutive `\NNN` octal escapes (entropy 2.8 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_9_Q_1_t1__HAQ_gQ_q_q[] = "\200A\340\010\031\230\024\320\0359\270\024\270Q\330\014 \240\t\250\021\340\010\013\210?\230'\240\021\330\014\023\2201\360\006\000\t\r\320\014\037\230t\2401\330\014\035\230_\250H\260A\260Q\330\014\017\210⟨U+007F⟩\230g\240Q\330\020\027\220q\330\010\017\210q";
    dismissed LLM, confidence 0.92 Cython-generated code-object location-table bytes in a C string constant.
    Reasoning

    This is a Cython-generated code-object location table in grpc's generated source, from the same family of constants. The octal bytes are compiled metadata, not an encoded dropper.

  498. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:117

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_9_Q_1_t1__HAQ_gQ_q_q[] = "\200A\340\010\031\230\024\320\0359\270\024\270Q\330\014 \240\t\250\021\340\010\013\210?\230'\240\021\330\014\023\2201\360\006\000\t\r\320\014\037\230t\2401\330\014\035\230_\250H\260A\260Q\330\014\017\210⟨U+007F⟩\230g\240Q\330\020\027\220q\330\010\017\210q";
    likely benign LLM, confidence 0.85 Cython-generated static byte-string constant holding serialized code-object data in the gRPC Cython extension.
    Reasoning

    The octal-escape run is a byte string of marshalled or bytecode-like data inside a Cython-generated __pyx_k_ constant, which is a standard Cython artifact for embedded code objects. The high-entropy look comes from binary serialized data, not from hidden logic, and the raw pass has a high false-positive rate.

  499. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:147

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    static const char __pyx_k_A_9_Q_1_t1__HAQ_gQ_q_q[] = "\200A\340\010\031\230\024\320\0359\270\024\270Q\330\014 \240\t\250\021\340\010\013\210?\230'\240\021\330\014\023\2201\360\006\000\t\r\320\014\037\230t\2401\330\014\035\230_\250H\260A\260Q\330\014\017\210⟨U+007F⟩\230g\240Q\330\020\027\220q\330\010\017\210q";
    likely benign LLM, confidence 0.85 Second octal-escape run within the same Cython-generated serialized constant.
    Reasoning

    Same literal as the previous finding at a different column; it is a Cython-generated binary constant embedded in generated C++, with no execution or network behaviour in the snippet.

  500. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:180

    string literal contains an embedded NUL followed by 119 more bytes of source (token pass, confidence 0.85)

    static const char __pyx_k_A_9_Q_1_t1__HAQ_gQ_q_q[] = "\200A\340\010\031\230\024\320\0359\270\024\270Q\330\014 \240\t\250\021\340\010\013\210?\230'\240\021\330\014\023\2201\360\006\000\t\r\320\014\037\230t\2401\330\014\035\230_\250H\260A\260Q\330\014\017\210⟨U+007F⟩\230g\240Q\330\020\027\220q\330\010\017\210q";
    likely benign LLM, confidence 0.85 Embedded NUL in the same generated binary-data string literal.
    Reasoning

    The embedded NUL is a consequence of binary marshalled data in a generated C string literal. It is consistent with Cython output and does not show a concealed payload being decoded or executed.

  501. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9260:69

    6 consecutive `\NNN` octal escapes (entropy 2.6 bits/byte) (raw pass, confidence 0.65)

    __pyx_k_WA_wc_1_q_q_l_2_a_fCxq[] = "\200!\330\004!\240\021\330\004\007\200~\220W\230A\330\006\030\230\010\240\001\330\004\007\200w\210c\220\032\2301\330\006\027\220q\230\n\240!\240<\250q\260\001\330\013\014\330\010\n\210!\210;\220l\320\"2\260(\270!\330\006\031\230\021\230,\240a\340\013\014\330\010\n\210!\210;\220f\230C
    likely benign LLM, confidence 0.85 Cython-generated static byte-string constant with octal-escaped binary data.
    Reasoning

    This is another Cython-generated __pyx_k_ constant of serialized code-object bytes, the same pattern as the other cygrpc.cpp findings, and it is a generated artifact rather than an obfuscated dropper.

  502. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9260:104

    11 consecutive `\NNN` octal escapes (entropy 3.3 bits/byte) (raw pass, confidence 0.65)

    "\200!\330\004!\240\021\330\004\007\200~\220W\230A\330\006\030\230\010\240\001\330\004\007\200w\210c\220\032\2301\330\006\027\220q\230\n\240!\240<\250q\260\001\330\013\014\330\010\n\210!\210;\220l\320\"2\260(\270!\330\006\031\230\021\230,\240a\340\013\014\330\010\n\210!\210;\220f\230C\230x\240q";
    likely benign LLM, confidence 0.85 Cython-generated binary constant with a run of octal escapes.
    Reasoning

    The octal run is serialized binary inside a Cython-generated constant. Nothing in the snippet decodes or runs it, and the pattern matches compiler output.

  503. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9260:205

    7 consecutive `\NNN` octal escapes (entropy 2.5 bits/byte) (raw pass, confidence 0.65)

    220\032\2301\330\006\027\220q\230\n\240!\240<\250q\260\001\330\013\014\330\010\n\210!\210;\220l\320\"2\260(\270!\330\006\031\230\021\230,\240a\340\013\014\330\010\n\210!\210;\220f\230C\230x\240q";
    likely benign LLM, confidence 0.85 Tail of a Cython-generated binary string constant with octal escapes.
    Reasoning

    The fragment is the tail of the same generated binary constant. It contains no executable calls and is consistent with Cython's serialization of code objects.

  504. line length 536 characters (raw pass, confidence 0.50)

    static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_97__Pyx_CFunc_4grpc_7_cython_6cygrpc_object__lParen_LatentEventArg__rParen_to_py_16latent_event_arg_1wrap = {"wrap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_11cfunc_dot_to_py_97__Pyx_CFunc_4grpc_7_cython_6cygrpc_object__lParen_LatentEv
  505. line length 506 characters (raw pass, confidence 0.50)

    static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_87__Pyx_CFunc_1f6ebd__4grpc_7_cython_6cygrpc_object__lParenobject__c__etc_to_py_2cb_4args_1wrap = {"wrap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_11cfunc_dot_to_py_87__Pyx_CFunc_1f6ebd__4grpc_7_cython_6cygrpc_object__lParenobject__c__
  506. line length 599 characters (raw pass, confidence 0.50)

    static void __pyx_f_4grpc_7_cython_6cygrpc__call(struct __pyx_obj_4grpc_7_cython_6cygrpc__ChannelState *__pyx_v_channel_state, struct __pyx_obj_4grpc_7_cython_6cygrpc__CallState *__pyx_v_call_state, grpc_completion_queue *__pyx_v_c_completion_queue, PyObject *__pyx_v_on_success, int __pyx_v_flags, PyObject *__pyx_v_met
  507. line length 506 characters (raw pass, confidence 0.50)

      __pyx_f_4grpc_7_cython_6cygrpc__call(((struct __pyx_obj_4grpc_7_cython_6cygrpc__ChannelState *)__pyx_t_1), ((struct __pyx_obj_4grpc_7_cython_6cygrpc__CallState *)__pyx_t_3), __pyx_cur_scope->__pyx_v_state->c_call_completion_queue, __pyx_v_on_success, __pyx_v_flags, __pyx_v_method, __pyx_v_host, __pyx_v_deadline, __py
  508. compression ratio 0.819 is >2σ above file mean 0.551 (raw pass, confidence 0.50)

    PyDoc_STRVAR(__pyx_doc_4grpc_7_cython_6cygrpc_156init_grpc_aio, "Initializes the gRPC AsyncIO module.\n\n    Expected to be invoked on critical class constructors.\n    E.g., AioChannel, AioServer.\n    ");
  509. compression ratio 0.824 is >2σ above file mean 0.551 (raw pass, confidence 0.50)

    PyDoc_STRVAR(__pyx_doc_4grpc_7_cython_6cygrpc_158shutdown_grpc_aio, "Shuts down the gRPC AsyncIO module.\n\n    Expected to be invoked on critical class destructors.\n    E.g., AioChannel, AioServer.\n    ");
  510. line length 529 characters (raw pass, confidence 0.50)

      __pyx_mstate->__pyx_ptype___pyx_scope_struct____Pyx_CFunc_4grpc_7_cython_6cygrpc_object__lParen_LatentEventArg__rParen_to_py_16latent_event_arg = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_scope_struct____Pyx_CFunc_4grpc_7_cython_6cygrpc_object__lParen_LatentEventArg__rParen_to_py_16latent_event_
  511. compression ratio 0.836 is >2σ above file mean 0.551 (in comment) (raw pass, confidence 0.30)

    #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS
    #error "Module state with PEP489 requires atomics. Currently that's one of\
     C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics"
    #endif
  512. compression ratio 0.825 is >2σ above file mean 0.551 (in comment) (raw pass, confidence 0.30)

    #else
    #error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\
     Requires C standard >= C11, or C++ standard >= C++11,\
     or pthreads, or the Windows 32 API, or Python >= 3.13."
  513. 1215 of 1800 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  514. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/internal/str_format/convert_test.cc:1408:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_TRUE(FormatFails("%s", 1));
      EXPECT_TRUE(FormatFails("%n", 1));
    
      // Double input
    dismissed LLM, confidence 0.95 Abseil test asserting that the StrFormat parser rejects the %n directive.
    Reasoning

    This is an Abseil unit test asserting that the format parser rejects %n. The string is passed to a test helper expecting failure, not to a real printf, so the write directive is never exercised.

  515. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/internal/str_format/convert_test.cc:1413:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_TRUE(FormatFails("%s", 1.));
      EXPECT_TRUE(FormatFails("%n", 1.));
      EXPECT_TRUE(FormatFails("%c", 1.));
      EXPECT_TRUE(FormatFails("%d", 1.));
    dismissed LLM, confidence 0.95 Negative test case in Abseil's format tests verifying %n is rejected.
    Reasoning

    The %n inside FormatFails is a negative test case in Abseil's format test suite. It checks that the formatter refuses the directive for a double argument.

  516. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/internal/str_format/convert_test.cc:1420:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      // String input
      EXPECT_TRUE(FormatFails("%n", ""));
      EXPECT_TRUE(FormatFails("%c", ""));
      EXPECT_TRUE(FormatFails("%d", ""));
    dismissed LLM, confidence 0.95 Negative test case asserting that %n with a string argument is rejected.
    Reasoning

    Another negative test in Abseil's StrFormat tests where %n is expected to fail for string input. This is a standard conformance check, not an exploit.

  517. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:188:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      int n = 0;
      EXPECT_EQ("", StrFormat("%n", FormatCountCapture(&n)));
      EXPECT_EQ(0, n);
      EXPECT_EQ("123", StrFormat("%d%n", 123, FormatCountCapture(&n)));
    dismissed LLM, confidence 0.95 Test of Abseil's type-safe %n count capture via FormatCountCapture.
    Reasoning

    Abseil's StrFormat %n is type-safe: it writes through a FormatCountCapture object, not an arbitrary pointer. The test checks that the captured count is correct, which is the library's intended safe behaviour.

  518. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:190:33

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_EQ(0, n);
      EXPECT_EQ("123", StrFormat("%d%n", 123, FormatCountCapture(&n)));
      EXPECT_EQ(3, n);
    }
    dismissed LLM, confidence 0.95 Test verifying the count captured by Abseil's safe %n directive.
    Reasoning

    This asserts the captured count after %d%n with FormatCountCapture. It exercises the library's intended, bounded write path and is ordinary library testing.

  519. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:196:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      int n = 0;
      EXPECT_EQ("", StrFormat("%n", FormatCountCapture(&n)));
      EXPECT_EQ(0, n);
      EXPECT_EQ("123", StrFormat("%v%n", 123, FormatCountCapture(&n)));
    dismissed LLM, confidence 0.95 Abseil test of %n count capture through the safe StrFormat API.
    Reasoning

    Same pattern as the other str_format_test findings: a unit test of the type-safe FormatCountCapture mechanism in Abseil's StrFormat, with no unsafe printf write.

  520. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:198:33

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_EQ(0, n);
      EXPECT_EQ("123", StrFormat("%v%n", 123, FormatCountCapture(&n)));
      EXPECT_EQ(3, n);
    }
    likely benign LLM, confidence 0.97 Abseil test exercising StrFormat's %n count-capture support.
    Reasoning

    This is a unit test for absl's StrFormat, which tests the %n directive handling. The %n is inside a test string literal and is captured through a safe FormatCountCapture wrapper; it is not an exploit.

  521. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:205:31

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      int n = 0;
      UntypedFormatSpec format("%d%n");
      int i = 123, *ip = &n;
      FormatArgImpl args[2] = {FormatArgImpl(i), FormatArgImpl(ip)};
    likely benign LLM, confidence 0.97 Abseil StrFormat test of %n writing to an int pointer under test control.
    Reasoning

    Unit test for abseil's format library, passing a pointer to an int to be filled by %n in a controlled test. Legitimate library test code.

  522. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:217:31

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      int n = 0;
      UntypedFormatSpec format("%v%n");
      int i = 123, *ip = &n;
      FormatArgImpl args[2] = {FormatArgImpl(i), FormatArgImpl(ip)};
    likely benign LLM, confidence 0.97 Abseil StrFormat test using %n with a fixed format string.
    Reasoning

    Same pattern as the other abseil StrFormat tests; the format string is a fixed literal in a test file.

  523. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:230:27

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_EQ("    1         2",
                StrFormat("%5d%n%10d%n", 1, FormatCountCapture(&n1), 2,
                          FormatCountCapture(&n2)));
      EXPECT_EQ(5, n1);
    likely benign LLM, confidence 0.97 Abseil StrFormat test for %n with width specifiers.
    Reasoning

    Test verifying %n count capture in StrFormat with literal format; no attacker-controlled input.

  524. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:230:33

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      EXPECT_EQ("    1         2",
                StrFormat("%5d%n%10d%n", 1, FormatCountCapture(&n1), 2,
                          FormatCountCapture(&n2)));
      EXPECT_EQ(5, n1);
    likely benign LLM, confidence 0.97 Abseil StrFormat test for %n with width specifiers.
    Reasoning

    Duplicate report on the same test line; same benign library test usage.

  525. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:239:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      std::string s;
      StrAppendFormat(&s, "%s: %n%s\n", "(1,1)", FormatCountCapture(&n), "(1,2)");
      StrAppendFormat(&s, "%*s%s\n", n, "", "(2,2)");
      EXPECT_EQ(7, n);
    likely benign LLM, confidence 0.97 Abseil StrAppendFormat test using %n.
    Reasoning

    StrAppendFormat test with fixed literal format string exercising %n; standard library test.

  526. info critical → info by review format-string-write third_party/abseil-cpp/absl/strings/str_format_test.cc:254:28

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

      std::string a3 = "(2,2)";
      StrAppendFormat(&s, "%v: %n%v\n", a1, FormatCountCapture(&n), a2);
      StrAppendFormat(&s, "%*s%v\n", n, "", a3);
      EXPECT_EQ(7, n);
    likely benign LLM, confidence 0.97 Abseil StrAppendFormat test using %v and %n.
    Reasoning

    Test of StrAppendFormat with %v and %n on fixed literal formats; benign.

  527. info critical → info by review format-string-write third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_format_test.cc:204:32

    printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

    #endif
      TestFormatSpecifier(tp, tz, "%n", "\n");
      TestFormatSpecifier(tp, tz, "%R", "00:00");
      TestFormatSpecifier(tp, tz, "%t", "\t");
    likely benign LLM, confidence 0.97 cctz time format test where %n denotes a newline.
    Reasoning

    %n here is a strftime-style specifier for newline in cctz time formatting tests, not a printf write directive. Benign.

  528. printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)

    
      EXPECT_TRUE(parse("%n", "\n", tz, &tp));
    
      tp = reset;
    likely benign LLM, confidence 0.97 cctz parse test using %n as whitespace specifier.
    Reasoning

    In cctz, %n is a strptime/strftime whitespace specifier parsed as newline; this is a time parsing test, not a memory write.

  529. identifier `𝑥z` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

      // The use of z̅ is that, when working mod (𝑥^701 - 1), vz[0] = <v,
      // z̅>, vz[1] = <v, 𝑥z̅>, …. (Where <a, b> is the inner product: the sum
      // of the point-wise products.) Although we calculated the inverse mod
      // Φ(N), we can work mod (𝑥^N - 1) and reduce mod Φ(N) at the end.
  530. identifier `𝑥z` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

      //
      // Thus we can consider what the pattern of z̅, 𝑥z̅, 𝑥^2z̅, … looks like:
      //
      // def reverse(xs):
  531. identifier `tΦ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      //   t = (−b(1)/N) mod Q
      //   c' = b + tΦ(N) + lift(m) mod Q
      //
      // When polynomials are transmitted, the final coefficient is omitted and
  532. identifier `tΦ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      // coefficient. Therefore b(1) = -c[N-1]×N. The value of |t|, above, then is
      // just recovering |c[N-1]|, and adding tΦ(N) is simply undoing the reduction.
      // Therefore b + tΦ(N) + lift(m) = c by construction and we don't need to
      // recover |c| at all so long as we do the checks in
  533. identifier `tΦ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      // just recovering |c[N-1]|, and adding tΦ(N) is simply undoing the reduction.
      // Therefore b + tΦ(N) + lift(m) = c by construction and we don't need to
      // recover |c| at all so long as we do the checks in
      // |poly3_from_poly_checked|.
  534. 237 of 533 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  535. 381 of 629 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  536. 51 of 124 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  537. 25 rows of base64-like lines, lines 248-272 (first: base64-like blob (64 bytes, compression ratio 1.17) (in comment)) (raw pass, confidence 0.36)

    //     -----BEGIN RSA PRIVATE KEY-----
    //     MIIEpAIBAAKCAQEAo16WiLWZuaymsD8n5SKPmxV1y6jjgr3BS/dUBpbrzd1aeFzN
    //     lI8l2jfAnzUyp+I21RQ+nh/MhqjGElkTtK9xMn1Y+S9GMRh+5R/Du0iCb1tCZIPY
    //     07Tgrb0KMNWe0v2QKVVruuYSgxIWodBfxlKO64Z8AJ5IbnWpuRqO6rctN9qUoMlT
  538. 13 rows of base64-like lines, lines 538-550 (first: base64-like blob (64 bytes, compression ratio 1.17) (in comment)) (raw pass, confidence 0.36)

    // -----BEGIN RSA PRIVATE KEY-----
    // MIICWwIBAAKBgQDbRn2TLhInBki8Bighq37EtqJd/h5SRYh6NkelCA2SQlvCgcC+
    // l3mYQPtPbRT9KxOLwqUuZ9jUCZ7WIji3Sgt0cyvCNPHRk+WW2XR781ifbGE8wLBB
    // 1NkrKyQjd1scO711Xc4gVM+hY4cdHiTE8x0aUIuqthRD7ZendWL0FMhS1wIDAQAB
  539. 13 rows of base64-like lines, lines 572-584 (first: base64-like blob (64 bytes, compression ratio 1.17) (in comment)) (raw pass, confidence 0.36)

    // -----BEGIN RSA PRIVATE KEY-----
    // MIICXAIBAAKBgQDpDn8RDOZa5oaDcPZRBy4CeBH1siSSOO4mYgLHlPE+oXdqwI/V
    // Imi2XeJM2uCFETXCknJJjYG0iJdrt/yyRFvZTQZw+QzGj+mz36NqhGxDWb6dstB2
    // m8PX+plZw7jl81MDvUnWs8yiQ/6twgu5AbhWKZQDJKcNKCEpqa6UW0r5nwIDAQAB
  540. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    // -----BEGIN PRIVATE KEY-----
    // MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgTXUM4tJWM7OzATty
    // JhNOfIv/d8heWFBeKOfMR+RfaROhRANCAASbbbWYiN6mn+BCpg4XNpibOH0D/DN4
    // kZ5C/Ml2YVomC9T83OKk2CzB8fPAabPb4P4Vv+fIabpEfjWS5nzKLY1y
  541. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    // MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgTXUM4tJWM7OzATty
    // JhNOfIv/d8heWFBeKOfMR+RfaROhRANCAASbbbWYiN6mn+BCpg4XNpibOH0D/DN4
    // kZ5C/Ml2YVomC9T83OKk2CzB8fPAabPb4P4Vv+fIabpEfjWS5nzKLY1y
    // -----END PRIVATE KEY-----
  542. 912 of 1706 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  543. identifier `xωaωa` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

                                          enum ssl_grease_index_t index) {
      // This generates a random value of the form 0xωaωa, for all 0 ≤ ω < 16.
      uint16_t ret = hs->grease_seed[index];
      ret = (ret & 0xf0) | 0x0a;
  544. `execv` called with a non-literal path (ast pass, confidence 0.90)

      // one path separator.
      execv(args->argv[0], args->argv);
      DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
                     original_dir + " failed: " + GetLastErrnoDescription());
    likely benign LLM, confidence 0.90 googletest death-test code re-executing the test binary via execv.
    Reasoning

    This is gtest's death-test child path, where execv runs the test binary's own argv[0] to re-execute itself for death tests. Passing a non-literal path is expected here and not a dropper.

  545. `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

      )
      CAN_PASS_EMPTY_ENV = eval(child.output)
    likely benign LLM, confidence 0.95 gtest Python test using eval on child test binary output at module scope.
    Reasoning

    gtest's filter unit test evaluates output of its own test binary that prints a Python literal (a boolean about env support). This is test-harness code run locally, not a supply-chain payload, though eval on subprocess output is poor practice.

  546. `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)

      )
      CAN_UNSET_ENV = eval(child.output)
    likely benign LLM, confidence 0.95 gtest Python test using eval on child binary output to detect env unset support.
    Reasoning

    Same pattern as the other eval: evaluates the boolean output of the googletest helper binary in a test file. Benign test harness code.

  547. identifier `λμνοπ` contains homoglyph candidates: ν (03BD)→v, ο (03BF)→o (in string/comment) (raw pass, confidence 0.35)

          "δδπππσσσ",
          "λμνοπ",
          "ψρστυ",
        },
  548. identifier `λμνοπ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

          "δδπππσσσ",
          "λμνοπ",
          "ψρστυ",
        },
  549. identifier `αcd` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    } error_tests[] = {
      { "ab\\αcd", RE2::ErrorBadEscape, "\\α" },
      { "ef\\x☺01", RE2::ErrorBadEscape, "\\x☺0" },
      { "gh\\x1☺01", RE2::ErrorBadEscape, "\\x1☺" },
  550. identifier `αcd` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    } error_tests[] = {
      { "ab\\αcd", RE2::ErrorBadEscape, "\\α" },
      { "ef\\x☺01", RE2::ErrorBadEscape, "\\x☺0" },
      { "gh\\x1☺01", RE2::ErrorBadEscape, "\\x1☺" },
  551. identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

    } error_tests[] = {
      { "ab\\αcd", RE2::ErrorBadEscape, "\\α" },
      { "ef\\x☺01", RE2::ErrorBadEscape, "\\x☺0" },
      { "gh\\x1☺01", RE2::ErrorBadEscape, "\\x1☺" },
  552. identifier `áxβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\bx\\b", "axb" },
      { "\\bx\\b", "áxβ" },
      { "\\Bx\\B", "axb" },
      { "\\Bx\\B", "áxβ" },
  553. identifier `áxβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\Bx\\B", "axb" },
      { "\\Bx\\B", "áxβ" },
    
      // Weird boundary cases.
  554. identifier `aαβb` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

      // Unicode scripts.
      { "\\p{Greek}+", "aαβb" },
      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
  555. identifier `aαβb` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      // Unicode scripts.
      { "\\p{Greek}+", "aαβb" },
      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
  556. identifier `aαβb` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

      { "\\p{Greek}+", "aαβb" },
      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
  557. identifier `aαβb` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\p{Greek}+", "aαβb" },
      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
  558. identifier `aαβb` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
  559. identifier `aαβb` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\P{Greek}+", "aαβb" },
      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
  560. identifier `aαβb` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)

      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
    
      // Unicode properties.  Nd is decimal number.  N is any number.
  561. identifier `aαβb` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\p{^Greek}+", "aαβb" },
      { "\\P{^Greek}+", "aαβb" },
    
      // Unicode properties.  Nd is decimal number.  N is any number.
  562. identifier `𤭢XX` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
          "$¢€𤭢XX",
          "$¢€𤭢XX",
  563. identifier `𤭢XX` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

          "$¢€𤭢XX",
          "$¢€𤭢XX",
    
          "\xed\xa1\x92XX",

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o grpcio-1.84.1.tar.gz https://files.pythonhosted.org/packages/c0/3a/5c8e0eea2af3d30cb20d33ac325a98d9b799c069d63101ca4da20bcc776a/grpcio-1.84.1.tar.gz
printf '%s  %s\n' 446e7876b9b991fa124c1d414899fa7cf95f89a3e71237ea0161863dc0b2c09f grpcio-1.84.1.tar.gz | shasum -a 256 -c -
mkdir pkg && tar -xzf grpcio-1.84.1.tar.gz -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg