PyPI / grpcio / 1.84.0

grpcio 1.84.0

Source
https://github.com/grpc/grpc
Artifact scanned
grpcio-1.84.0.tar.gz (sdist · 12.9 MB · SHA-256 19aaf172fc2e…)
Compared with
grpcio-1.83.1.tar.gz (19 signals introduced since)
Files
5027 scanned, 422 skipped (binary, oversized, or unrecognised)
Signals
0 critical · 404 warn · 162 info
Scan time
120.1 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): the 120 most severe of 524 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 03:41

Signals

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

  1. 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!";
  2. 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";
  3. 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";
  4. 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";
  5. 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
  6. 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";
  7. 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";
  8. 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\
  9. 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
  10. 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";
  11. 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";
  12. 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";
  13. 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";
  14. 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";
  15. 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";
  16. 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";
  17. 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";
  18. 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\
  19. 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";
  20. 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";
  21. 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
  22. 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";
  23. 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";
  24. 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!";
  25. 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!";
  26. 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";
  27. 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";
  28. 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";
  29. 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";
  30. 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\
  31. 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";
  32. 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
  33. 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
  34. 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";
  35. 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
  36. 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";
  37. 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";
  38. 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";
  39. 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
  40. 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\
  41. 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
  42. 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";
  43. 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
  44. 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
  45. 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
  46. 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
  47. 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
  48. 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
  49. 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
  50. 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
  51. 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
  52. 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());
  53. 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));
  54. 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=",
  55. 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",
  56. base64-like blob (52 bytes, compression ratio 1.21) (raw pass, confidence 0.60)

           uint64_t{0x4ec948b8e7f27288}},
          {"A9G8pw2+m7+rDtWYAdbl8tb2fT7FFo4hLi2vAsa5Y8mKH3CX3g==",
           uint64_t{0xce46c7213c10032}},
          {"DFaJGishGwEHDdj9ixbCoaTjz9KS0phLNWHVVdFsM93CvPft3hM=",
  57. 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",
  58. base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)

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

           uint64_t{0x45c474f1cee1d2e8}},
          {"1XBMnIbqD5jy65xTDaf6WtiwtdtQwv1dCVoqpeKj+7cTR1SaMWMyI04=",
           uint64_t{0x6e024e14015f329c}},
          {"znZbdXG2TSFrKHEuJc83gPncYpzXGbAebUpP0XxzH0rpe8BaMQ17nDbt",
  60. 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=",
  61. 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",
  62. 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=",
  63. base64-like blob (70 bytes, compression ratio 1.16) (raw pass, confidence 0.60)

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

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

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

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

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

          {"2BOFlcI3Z0RYDtS9T9Ie9yJoXlOdigpPeeT+CRujb/"
           "O39Ih5LPC9hP6RQk1kYESGyaLZZi3jtabHs7DiVx/VDg==",
           uint64_t{0xe2ccb09ac0f5b4b6}},
          {"FF2HQE1FxEvWBpg6Z9zAMH+Zlqx8S1JD/"
  69. 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/"
  70. 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/"
  71. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

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

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

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

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

          {"jVDKGYIuWOP/"
           "QKLdd2wi8B2VJA8Wh0c8PwrXJVM8FOGM3voPDVPyDJOU6QsBDPseoR8uuKd19OZ/"
           "zAvSCB+zlf6upAsBlheUKgCfKww=",
           uint64_t{0xf1f67391d45013a8}},
  76. 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}},
  77. 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/"
  78. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

          {"DUwXFJzagljo44QeJ7/"
           "6ZKw4QXV18lhkYT2jglMr8WB3CHUU4vdsytvw6AKv42ZcG6fRkZkq9fpnmXy6xG0aO3WPT1"
           "eHuyFirAlkW+zKtwg=",
           uint64_t{0xca584c4bc8198682}},
  79. 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}},
  80. base64-like blob (43 bytes, compression ratio 1.26) (raw pass, confidence 0.60)

          {"EXeHBDfhwzAKFhsMcH9+2RHwV+mJaN01+9oacF6vgm8mCXRd6jeN9U2oAb0of5c5cO4i+"
           "Vb/LlHZSMI490SnHU0bejhSCC2gsC5d2K30ER3iNA==",
           uint64_t{0x33f253cbb8fe66a8}},
          {"FzkzRYoNjkxFhZDso94IHRZaJUP61nFYrh5MwDwv9FNoJ5jyNCY/"
  81. 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/"
  82. base64-like blob (71 bytes, compression ratio 1.15) (raw pass, confidence 0.60)

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

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

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

          {"ieQEbIPvqY2YfIjHnqfJiO1/MIVRk0RoaG/WWi3kFrfIGiNLCczYoklgaecHMm/"
           "1sZ96AjO+a5stQfZbJQwS7Sc1ODABEdJKcTsxeW2hbh9A6CFzpowP1A==",
           uint64_t{0x3c59bfd0c29efe9e}},
          {"zQUv8hFB3zh2GGl3KTvCmnfzE+"
  86. 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}},
  87. base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)

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

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

           "u+x+"
           "czC9AaZMgmQrUy15DH7YMGsvdXnviTtI4eVI4aF1H9Rl3NXMKZgwFOsdTfdcZeeHVRzBBKX"
           "8jUfh1il",
           uint64_t{0xff1ae05c98089c3f}},
  90. 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}},
  91. 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/"
  92. 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/"
  93. 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}},
  94. 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"
  95. 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}},
  96. 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/"
  97. base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           "sOmqaq8XAQLEn68LKj6/"
           "cFkJukxRzCa4OF1a7cCAXYFp9+wZDu0bw4y63qbpjhdCl8GO6Z2lkcXy7KOzbPE01ukg7+"
           "gN+7uKpoohgAhIwpAKQXmX5xtd0=",
           uint64_t{0xc9ae5c8759b4877a}},
  116. 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");
  117. 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"));
  118. 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'));
  119. 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'));
  120. 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"),
  121. 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[] = {
  122. 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[] = {
  123. 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[] = {
  124. 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"}
      };
  125. 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"
  126. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

                            "0\n"
                            "\0\n"
                            "\0",
                            7),
  127. 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"
  128. string literal contains an embedded NUL followed by 2 more bytes of source (token pass, confidence 0.85)

                            "0\n"
                            "\0\n"
                            "\0",
                            7),
  129. 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",
  130. 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) {
  131. 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);
  132. 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);
  133. 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");
  134. `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(
  135. 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);
  136. 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));
  137. 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));
  138. 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,
  139. 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();
  140. 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);
  141. 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);
  142. 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);
  143. 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);
  144. 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);
  145. 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
  146. 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
  147. 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
  148. 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
  149. 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)));
  150. 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)));
  151. 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
  152. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  153. 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
  154. base64-like blob (172 bytes over 3 lines, compression ratio 0.94) (raw pass, confidence 0.60)

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

    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ
    TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N
    Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB
  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. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

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

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

    
    RK7DUIGDHWTFh2rpTX+dR88hUyC1PyDlIULiNCkuWFwHrJbc1gM6hMVOKmU196XC
    iITrIKmilFm9CPD6Tpfk/NhI/QPxyJlk1geIkxpvUZ2FCeMuYI1To14oYOUKv14q
    wr6JtaX2G+pOmwcSPymZC4u2TncAP7KHgS8UGcMw8CE=
  164. 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"
  165. 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"
  166. base64-like blob (572 bytes over 9 lines, compression ratio 0.77) (raw pass, confidence 0.60)

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

    -----BEGIN X509 CRL-----
    MIIBvjCBpwIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE
    CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ
    Qm9yaW5nU1NMFw0xNjA5MjYxNTEyNDRaFw0xNjEwMjYxNTEyNDRaMBUwEwICEAAX
  168. 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) ||
  169. 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,
  170. 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,
      };
  171. 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) ||
  172. 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) ||
  173. 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) ||
  174. 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);
  175. base64-like blob (840 bytes over 14 lines, compression ratio 0.70) (raw pass, confidence 0.60)

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

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

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

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

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

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

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

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

    -----BEGIN CERTIFICATE-----
    MIIDdjCCAjqgAwIBAgIJANcwZLyfEv7DMD4GCSqGSIb3DQEBCjAxoA0wCwYJYIZI
    AWUDBAIBoRowGAYJKoZIhvcNAQEIMAsGCWCGSAFlAwQCAaIEAgIA3jAnMSUwIwYD
    VQQDDBxUZXN0IEludmFsaWQgUFNTIGNlcnRpZmljYXRlMB4XDTE1MTEwNDE2MDIz
  184. 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
  185. base64-like blob (184 bytes over 3 lines, compression ratio 0.90) (raw pass, confidence 0.60)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -----BEGIN CERTIFICATE-----
    MIIBnTCCAQagAwIBAgIBAzANBgkqhkiG9w0BAQsFADArMRcwFQYDVQQKEw5Cb3Jp
    bmdTU0wgVGVzdDEQMA4GA1UEAxMHUm9vdCBDQTAgFw0wMDAxMDEwMDAwMDBaGA8y
    MDk5MDEwMTAwMDAwMFowFDESMBAGA1UEAxMJRUtVIG1zU0dDMFkwEwYHKoZIzj0C
  222. 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
  223. base64-like blob (172 bytes over 3 lines, compression ratio 0.93) (raw pass, confidence 0.60)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -----BEGIN CERTIFICATE-----
    MIICZjCCAc+gAwIBAgIQASNFZ4mrze8BI0VniavN7zANBgkqhkiG9w0BAQsFADA2
    MRowGAYDVQQKExFCb3JpbmdTU0wgVEVTVElORzEYMBYGA1UEAxMPSW50ZXJtZWRp
    YXRlIENBMCAXDTE1MDEwMTAwMDAwMFoYDzIxMDAwMTAxMDAwMDAwWjAyMRowGAYD
  252. 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,
  253. 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)},
  254. 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"},
  255. 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"},
  256. string literal contains an embedded NUL followed by 1 more bytes of source (token pass, confidence 0.85)

          {
              "der\0p",
              V_ASN1_TELETEXSTRING,
              5,
  257. 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",
  258. 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",
  259. 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"
  260. 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"
  261. 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"
  262. 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"
  263. 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"
  264. 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"
  265. 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"
  266. 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"
  267. 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"
  268. 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"
  269. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

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

          "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgBw8IcnrUoEqc3VnJ\n"
          "TYlodwi1b8ldMHcO6NHJzgqLtGqhRANCAATmK2niv2Wfl74vHg2UikzVl2u3qR4N\n"
          "Rvvdqakendy6WgHn1peoChj5w8SjHlbifINI2xYaHPUdfvGULUvPciLB\n"
          "-----END PRIVATE KEY-----\n";
  271. 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"
  272. 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"
  273. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

          "-----BEGIN SUBJECT-----\n"
          "MEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJ\n"
          "bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQ=\n"
          "-----END SUBJECT-----\n";
  274. 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"
  275. base64-like blob (444 bytes over 7 lines, compression ratio 0.76) (raw pass, confidence 0.60)

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

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

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

    -----BEGIN CERTIFICATE-----
    MIIBaTCCAQ6gAwIBAgIBAzAKBggqhkjOPQQDAjASMRAwDgYDVQQDEwdUZXN0IENB
    MCAXDTAwMDEwMTAwMDAwMFoYDzIwOTkwMTAxMDAwMDAwWjAZMRcwFQYDVQQDEw5z
    ZWNyZXQuZXhhbXBsZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE2uSHFpsAsO
  279. 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,
  280. 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));
    }
  281. base64-like blob (664 bytes over 11 lines, compression ratio 0.72) (raw pass, confidence 0.60)

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

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

    -----BEGIN CERTIFICATE-----
    MIIBqzCCAVGgAwIBAgIQeudG9R61BOxUvWkeVhU5DTAKBggqhkjOPQQDAjArMRIw
    EAYDVQQKEwlBY21lIENvIDIxFTATBgNVBAMTDGV4YW1wbGUzLmNvbTAeFw0yMTEy
    MDYyMDU2NTZaFw0yMjEyMDYyMDU2NTZaMCsxEjAQBgNVBAoTCUFjbWUgQ28gMjEV
  284. 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
  285. base64-like blob (624 bytes over 10 lines, compression ratio 0.73) (raw pass, confidence 0.60)

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

    -----BEGIN CERTIFICATE-----
    MIICXjCCAcegAwIBAgIIWjO48ufpunYwDQYJKoZIhvcNAQELBQAwNjEaMBgGA1UE
    ChMRQm9yaW5nU1NMIFRFU1RJTkcxGDAWBgNVBAMTD0ludGVybWVkaWF0ZSBDQTAg
    Fw0xNTAxMDEwMDAwMDBaGA8yMTAwMDEwMTAwMDAwMFowMjEaMBgGA1UEChMRQm9y
  287. `#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. */
  288. `#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. */
  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. base64-like blob (360 bytes over 5 lines, compression ratio 0.76) (raw pass, confidence 0.60)

      std::string escaped =
          R"(TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
      IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
      dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
  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)

    
    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)

    
    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. 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 */)
  301. 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 */)
  302. 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 */)
  303. 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);
  304. 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) {
  305. 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()));
    }
  306. 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()));
    }
  307. 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));
    }
  308. 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));
    }
  309. 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));
    }
  310. 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));
    }
  311. 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));
    }
  312. 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\"",
  313. 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(
  314. 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));
  315. 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.
  316. 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\"");
  317. 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\"");
    }
  318. 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);
  319. 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);
  320. 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");
  321. 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());
    }
  322. 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,
  323. 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"
  324. 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)");
  325. 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"
  326. `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 */
  327. `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! */
  328. 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) {
  329. 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))
  330. 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))
  331. `#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 */
  332. `#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. */
  333. `#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. */
  334. `#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. */
  335. `#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. */
  336. `#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. */
  337. `#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. */
  338. `#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 */
  339. `#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. */
  340. `#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. */
  341. `#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. */
  342. `#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. */
  343. `#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. */
  344. `#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. */
  345. `#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. */
  346. `#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 */
  347. `#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. */
  348. `#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. */
  349. `#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. */
  350. `#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. */
  351. `#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. */
  352. `#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. */
  353. `#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. */
  354. `#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. */
  355. `#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. */
  356. `#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 */
  357. `#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. */
  358. `#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. */
  359. `#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. */
  360. `#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. */
  361. `#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. */
  362. `#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. */
  363. `#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. */
  364. `#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 */
  365. `#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. */
  366. `#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. */
  367. `#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. */
  368. `#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. */
  369. `#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. */
  370. `#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. */
  371. `#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. */
  372. `#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. */
  373. `#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. */
  374. `#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. */
  375. `#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 */
  376. `#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. */
  377. `#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. */
  378. `#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. */
  379. `#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. */
  380. `#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. */
  381. `#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'). */
  382. `#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. */
  383. `#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. */
  384. `#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>. */
  385. 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),
  386. 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."},
  387. 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"));
    }
  388. 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 {
  389. 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
  390. 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
  391. 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
  392. 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;
  393. 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 */
  394. 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 */
    
    /*
  395. 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,
  396. 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.
  397. 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 */
  398. 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 */
  399. 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)
  400. 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) */
  401. 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;
  402. 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
  403. 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 -- */
  404. 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
  405. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8653:87 new in this release

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

    static const char __pyx_k_A_IQ_Q_C1[] = "\200A\330\010\t\330\014\020\220\014\230I\240Q\340\020\030\230\001\340\014\023\220:\230Q\320\036C\3001";
    static const char __pyx_k_A_K_oQa_K[] = "\200A\330\010\014\210K\220⟨U+007F⟩\240o\260Q\260a\330\010\014\210K\320\027)\250\021";
    dismissed LLM, confidence 0.90 Cython-generated code-object bytes in a gRPC extension's C++ output.
    Reasoning

    Generated Cython name/bytecode constant with the typical octal-escape density of marshalled Python bytecode. Nothing in the snippet runs or fetches anything.

  406. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8859:156 new in this release

    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.92 Generated binary code-table constant in grpcio's Cython output.
    Reasoning

    This is one more generated code-object table of the kind Cython emits for each compiled function. The high escape density reflects binary encoding, not a hidden dropper.

  407. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8859:185 new in this release

    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.92 Generated static byte constant of CPython metadata.
    Reasoning

    The same generated pattern appears again in a Cython-compiled C file. The literal is static const data and is never decoded by code shown in the finding.

  408. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8948:52 new in this release

    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.88 Cython-generated static byte array holding marshalled Python bytecode, emitted in the grpc C++ extension source.
    Reasoning

    The run of octal escapes sits in a static const char array named __pyx_k_..., which is the naming pattern Cython uses for its string constant table. The bytes start with 0x80 0x01 and 0xF0-style marshal/bytecode opcodes, consistent with a marshalled Python code object emitted by Cython. This is a generated-source artifact, not an encoded payload, and the adjacent entries are ordinary identifier strings.

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

    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.88 Embedded NUL byte inside a Cython-generated marshalled bytecode constant.
    Reasoning

    The embedded NUL is a normal byte inside the marshalled code-object constant emitted by Cython (the \000 is part of the bytecode stream). The array is a generated __pyx_k_ constant in a cygrpc build artifact, so the NUL-in-literal finding reflects marshal output rather than hidden string tricks.

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

    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.87 Embedded NUL in a Cython-generated marshalled bytecode constant.
    Reasoning

    The NUL sits inside a __pyx_k_ marshalled code constant in a Cython-generated file. The following line is an ordinary readable identifier string, which is typical of Cython's constant table layout.

  411. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:8952:117 new in this release

    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.88 Cython-generated marshalled bytecode byte array in the grpc extension source.
    Reasoning

    Generated Cython __pyx_k_ constant holding marshalled bytecode; the octal escapes encode opcodes and small integers, not a payload that is decoded or executed by hand-written code.

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

    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.87 Embedded NUL in a Cython-generated marshalled bytecode constant.
    Reasoning

    Generated __pyx_k_ marshalled code constant with an embedded NUL, in a Cython build artifact for the grpc extension. Nothing in the snippet decodes or executes the bytes.

  413. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9209:53 new in this release

    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";
    likely benign LLM, confidence 0.88 Generated static C string holding marshalled bytecode.
    Reasoning

    The octal sequence is Cython-marshalled code data in a generated static string constant. The surrounding constants are ordinary identifiers and messages, so this is compiler output rather than a dropper.

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

    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";
    likely benign LLM, confidence 0.88 Embedded NUL within a Cython marshalled bytecode constant.
    Reasoning

    The embedded NUL is part of the marshal-format bytes in a Cython-generated constant. It is expected in generated code of this kind and carries no sign of a hidden string.

  415. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:60 new in this release

    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";
    likely benign LLM, confidence 0.90 Generated Cython marshalled bytecode literal, octal escape run.
    Reasoning

    The constant is generated Cython output containing marshalled bytecode escapes, with the same structure as the other __pyx_k_ literals in this file. It is compiler-produced data, not evidence of obfuscated malicious logic.

  416. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:117 new in this release

    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.90 Generated Cython bytecode constant, additional octal run.
    Reasoning

    Continuation of the same generated marshalled-bytecode constant. Nothing in the snippet decodes or executes it, and the file is a standard grpc Cython build artifact.

  417. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:147 new in this release

    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 string constant holding marshalled data as octal escapes.
    Reasoning

    The octal run sits inside a static const char array named like a Cython-generated constant. Cython emits marshalled code-object data this way in generated C files, and grpc's cygrpc.cpp is a Cython output. The high-entropy look comes from binary marshal data, not hidden payload logic, and no execution or decoding is visible in the snippet.

  418. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9246:180 new in this release

    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.80 Binary marshal blob in a generated Cython string literal that contains NUL bytes.
    Reasoning

    Embedded NULs are expected in marshalled binary blobs stored as C string literals in Cython output. The token pass flags the byte layout, not any sensitive identifier or dangerous construction, and the file is a standard generated grpc artifact.

  419. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9600:64 new in this release

    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
    likely benign LLM, confidence 0.85 Generated Cython constant array of marshalled bytes encoded as octal escapes.
    Reasoning

    Same pattern as the other cygrpc.cpp findings: a Cython-generated static char array with marshal-style binary data. The naming and layout match Cython's constant emission, and the snippet shows no executable logic or network or process activity.

  420. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9600:80 new in this release

    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
    likely benign LLM, confidence 0.80 Generated Cython constant containing NUL bytes from binary data.
    Reasoning

    The embedded NUL is part of the Cython-generated binary constant data. It is a generated-code artifact in a legitimate grpc source file rather than a deliberate hiding technique in the snippet.

  421. info warn → info by review encoding-octal src/python/grpcio/grpc/_cython/cygrpc.cpp:9600:1751 new in this release

    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";
    likely benign LLM, confidence 0.85 End of a generated Cython binary constant array.
    Reasoning

    The tail of the same generated constant array closes the marshal-style blob. The snippet is data only, with no decode-and-execute path, so it reads as normal Cython output.

  422. info warn → info by review embedded-nul-in-string src/python/grpcio/grpc/_cython/cygrpc.cpp:9624:76 new in this release

    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";
    likely benign LLM, confidence 0.80 Generated Cython binary constant with embedded NULs in a grpc C++ file.
    Reasoning

    This is another generated Cython string constant holding marshalled data. The embedded NULs and octal escapes are consistent with Cython serialization of code constants inside a grpc build artifact, and the snippet has no active code.

  423. info long-line src/python/grpcio/grpc/_cython/cygrpc.cpp:24897:1 new in this release

    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
  424. 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.85 Build-tool subprocess launcher calling execv on its configured command.
    Reasoning

    execv with a path taken from a build command's argument list is the standard way a build tool's subprocess runner launches commands. Nothing in the snippet shows attacker-controlled input or concealment, and the code only logs on failure.

  425. 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.85 Build-tool subprocess launcher calling execve with a constructed environment.
    Reasoning

    execve with an argv and envp built from the command to run is the normal pattern for a subprocess runner that passes an environment. The snippet shows no obfuscation or hidden fetch-and-run behaviour.

  426. 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.90 Cython-generated macro alias for an atomic integer type.
    Reasoning

    This is Cython-generated compatibility preprocessor code that maps atomic type macros to int depending on compiler support. Macro aliases of this kind are routine in generated C and are not a sign of malice.

  427. 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.90 Cython-generated macro alias for a non-atomic integer type.
    Reasoning

    Same Cython-generated compatibility macro pattern as the adjacent atomic alias, used for the non-atomic case. This is expected output from the Cython code generator.

  428. 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.85 Cython-embedded code-object table bytes stored as octal-escaped string constants.
    Reasoning

    These octal-escaped byte strings sit among many short Cython name constants and match the layout of CPython code-object line and exception tables, which Cython embeds for tracebacks. The entropy comes from bytecode-style encoding, not from a payload being decoded or run.

  429. 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.85 Cython-embedded code-object table bytes in generated string constants.
    Reasoning

    The same generated table format appears here, with the escaped bytes adjacent to ordinary short string constants. This is consistent with Cython emitting code-object metadata, not with a dropper.

  430. 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 Generated byte-table string constant containing a NUL byte.
    Reasoning

    The embedded NUL is a byte inside a bytecode-style table emitted by the generator, and the literal is a generated constant rather than something the program decodes at runtime. The token pass flags the byte value, not any behaviour.

  431. 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 Consecutive generated Cython byte-table constants.
    Reasoning

    A run of rows with the same escaped-byte structure in generated constants is consistent with Cython code-object tables. No decoding, execution or network use appears in the snippet.

  432. 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 Generated byte constant containing an embedded NUL in a code-object table.
    Reasoning

    The NUL byte sits inside a short generated bytecode-style constant, the kind Cython produces for code-object metadata. The finding reflects the byte content of generated data, not runtime behaviour.

  433. 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 Generated byte constant containing an embedded NUL in a code-object table.
    Reasoning

    This is another generated bytecode-style constant with a NUL byte, in the same table as the neighbouring entries. It is consistent with compiler output, not payload delivery.

  434. 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 Generated Cython code-object byte table with a run of octal escapes.
    Reasoning

    The run of escaped bytes matches the Cython-generated code-object table layout seen elsewhere in this file. Nothing in the snippet decodes or executes the bytes.

  435. 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 Generated Cython code-object byte table entries with octal escapes.
    Reasoning

    Consecutive generated constants with the same escaped-byte pattern are typical Cython output for code-object metadata. The snippet contains no runtime decoding or execution path.

  436. 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.92 Cython-emitted marshalled code-object constants in grpc's generated cygrpc.cpp.
    Reasoning

    Cython-generated static string constants holding marshalled Python code-object bytes (the \200\001\330 pattern is typical of CPython 3.11+ bytecode and location tables). The file is a generated C++ translation unit from grpc's Cython build, and the octal escapes are expected serialized data, not a payload.

  437. 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.92 Generated static byte constants for Cython code-object metadata.
    Reasoning

    Same Cython-generated bytecode/marshal constant table as the rest of cygrpc.cpp. The sequences are short, structured, and paired with ordinary identifier constants, which matches generator output rather than hidden logic.

  438. 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.92 Cython-generated marshalled bytecode constant in cygrpc.cpp.
    Reasoning

    Generated Cython constant holding marshalled code-object bytes. The octal escapes are the standard serialized form, and the surrounding constants are the same kind of generated data.

  439. 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 NUL byte inside a Cython-generated marshalled constant.
    Reasoning

    The embedded NUL comes from a \000 byte inside the marshalled code-object encoding (e.g. the \360\026\000\005 structure). It is a normal artifact of serialized bytecode in a generated file, not a deliberate string-termination trick.

  440. 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.92 Generated serialized code-object bytes in cygrpc.cpp.
    Reasoning

    Another Cython-generated marshalled code-object constant in the same generated block. The escape run is consistent with serialized bytecode.

  441. 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.92 Generated marshalled bytes next to ordinary identifier constants.
    Reasoning

    Generated Cython constant table. It sits next to plain identifier strings such as 'uds', 'xds' and 'yes', which indicates auto-generated interned-string and code-object data.

  442. 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 Cython-generated serialized bytecode constant.
    Reasoning

    Generated Cython code-object constant. The mixed plain and octal-escaped entries are typical of Cython's __pyx_k table output.

  443. 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.92 Cython-generated marshalled constant for code-object metadata.
    Reasoning

    Generated __pyx_k constant containing marshalled code-object bytes, alongside plain identifier strings such as 'task' and '__test__'. This is standard Cython output.

  444. 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.92 Generated serialized bytecode constant in cygrpc.cpp.
    Reasoning

    Generated Cython string constant of marshalled bytecode, consistent with the rest of the __pyx_k table in this generated file.

  445. 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 NUL within a Cython-generated serialized constant.
    Reasoning

    The embedded NUL is the \000 inside a marshalled code-object byte sequence in a generated Cython constant. It is a serialization artifact, not an evasion technique.

  446. 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.92 Generated marshalled bytecode constant in cygrpc.cpp.
    Reasoning

    Generated Cython __pyx_k constant of marshalled code-object bytes, one of many similar entries in this auto-generated file.

  447. 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.93 Cython-generated byte constant holding Python bytecode location metadata, emitted as octal escapes in cygrpc.cpp.
    Reasoning

    The flagged bytes are octal-escaped constants in a Cython-generated C++ file. The sequences such as \200\001\330\002 match CPython 3.11+ code-object line and exception table encodings, which Cython emits as interned byte strings. The escape density comes from the binary format, not from hidden logic, and the file is a standard gRPC build artifact.

  448. 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.93 Binary code-metadata blob in a Cython static const char array containing a literal NUL byte.
    Reasoning

    The NUL bytes sit inside Cython's __pyx_k_ static arrays, whose contents are binary CPython code-metadata blobs rather than text. The embedded NUL is the expected \000 in a line table entry, so the token-pass signal reflects the binary payload and not a concealed string.

  449. 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.93 Cython static byte array with embedded NUL holding encoded bytecode metadata.
    Reasoning

    Same pattern as the other __pyx_k_ constants: short binary bytecode-metadata strings produced by Cython. The NUL is a normal part of the encoded table, and the constant is only used as an identifier or code-object payload.

  450. 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.93 Cython-generated binary code-location data for a Python code object, encoded as octal escapes.
    Reasoning

    Nine consecutive octal escapes in a __pyx_k_ constant that matches CPython's compact location-table format (values such as \200, \330, \220 are typical opcode and length prefixes). It is generated data in a compiled extension source, not a payload or dropper.

  451. 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.93 Further binary location-table bytes in a Cython-generated constant from cygrpc.cpp.
    Reasoning

    A second run of escape bytes in the same generated constant, with the same structure and entropy as the other Cython metadata strings. Nothing here executes or decodes at runtime beyond the normal Python interpreter's use of the code object.

  452. 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.93 Generated binary bytecode metadata in a Cython static string array.
    Reasoning

    The escape run is part of a Cython-emitted static constant holding CPython code-object metadata. The layout and byte values are consistent with the bytecode location format, and the surrounding file is a standard generated C++ extension source.

  453. 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.92 Cython static byte constant with embedded NUL in encoded code-object metadata.
    Reasoning

    The NUL byte is inside a Cython __pyx_k_ constant encoding interpreter metadata, which normally contains NULs. The token signal reflects that binary content and not a deliberately hidden string.

  454. 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.92 Cython-generated static constant with embedded NUL in binary code-metadata.
    Reasoning

    Same generated pattern: a Cython static byte array containing NUL-separated binary location and opcode data. Nothing in the snippet decodes or runs the bytes, and the file is ordinary build output for grpcio.

  455. 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.93 Generated binary code-object metadata in a Cython constant from cygrpc.cpp.
    Reasoning

    Ten consecutive octal escapes in a __pyx_k_ constant, matching the CPython code-metadata encoding Cython emits. The high entropy is expected for compact binary metadata, and the raw pass has a higher false-positive rate for this kind of data.

  456. 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.93 Second binary metadata run in the Cython-generated constant near the 8590 line.
    Reasoning

    A further octal-escape run inside the same generated static constant. It is compact bytecode-table data for a Python code object, with no execution or network behaviour in the snippet, and it is consistent with a normal Cython build.

  457. 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.90 Cython-generated static byte constant encoding Python code-location metadata inside the grpcio cygrpc.cpp build artifact.
    Reasoning

    The flagged octal run is a static byte-string constant of the form __pyx_k_* in a Cython-generated C++ file. The escapes encode a compact line/position table (the pattern of Python code-object location data), not executable payload. Nothing in the snippet decodes or runs the bytes, and the surrounding names are ordinary Python identifiers. This is a known false positive for generated Cython output.

  458. 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.90 Generated Cython constant holding compressed Python location data in grpcio's cygrpc.cpp.
    Reasoning

    Same generated Cython file and the same __pyx_k_* constant pattern. The octal escape sequences are a compressed location table, and the constant is only ever used as data for Python's code object. Raw-pass octal and entropy signals are expected for this encoding.

  459. 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.90 Another generated Cython location-table byte string in the grpcio build artifact.
    Reasoning

    A second octal run in the same generated __pyx_k_* table of cygrpc.cpp. It is the same benign encoded location metadata, with no decoding, execution or network use in the snippet.

  460. 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.90 Generated Cython static bytes for Python code location data, flagged by the raw octal-escape heuristic.
    Reasoning

    Generated Cython output with the same __pyx_k_* structure. The high escape density is the normal form of Cython's serialized line tables and does not indicate a hidden payload.

  461. 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.88 Generated byte-literal constant with a NUL inside Cython's location table in cygrpc.cpp.
    Reasoning

    The token pass flags an embedded NUL inside a byte literal. Cython's location-table encoding legitimately contains zero bytes, and the constant is a static data array, not a string used for code execution. The NUL is an artifact of the encoding, not evidence of obfuscation.

  462. 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.88 Cython-generated location-table byte string containing a NUL, flagged by the token pass.
    Reasoning

    The embedded NUL is a normal byte in Cython's compressed location data. The adjacent __pyx_k_RPCState and __pyx_k_add_note constants are ordinary identifier names, so this is generated metadata in a standard grpcio build file.

  463. 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.90 Generated Cython location-data constant flagged for octal escape density in cygrpc.cpp.
    Reasoning

    Raw-pass octal escape run in the same generated constant table. It reflects Cython's serialized location encoding, which the heuristic misreads as an encoded blob.

  464. 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.88 Generated Cython byte constant with an embedded NUL in grpcio's cygrpc.cpp.
    Reasoning

    The embedded NUL is in a generated byte constant (__pyx_k_c_j_6a_1) that is part of Cython's location-table output. The constant is passed as data to Python's code-object construction and is never decoded or executed as code in this file.

  465. 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.90 Generated Cython location-table static bytes in the grpcio C++ extension source.
    Reasoning

    Generated Cython constant table entry (__pyx_k_q_q_s_Kq) with the usual compressed location encoding. Nothing in the snippet suggests a dropper or runtime decode; the raw entropy signal is a false positive for this format.

  466. 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.90 Generated Cython byte constant flagged by the raw pass in cygrpc.cpp.
    Reasoning

    Second octal run in the same generated constant. It is part of the Cython-emitted metadata for Python code objects, and the file is the standard grpcio Cython build output.

  467. 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__";
    dismissed LLM, confidence 0.90 Cython-generated binary code-object constant in a gRPC C++ extension source.
    Reasoning

    The string is a Cython-generated __pyx_k_ constant holding compressed Python code-object data (bytecode/line-table bytes in the \200\001\330... style). It sits in a machine-generated C++ file alongside ordinary identifier strings, so the octal escapes are generated bytecode, not hidden payload.

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

    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";
    dismissed LLM, confidence 0.90 Cython-generated code-object byte string in a generated C++ source file.
    Reasoning

    Same Cython __pyx_k_ pattern: compressed code-object bytes in a generated C++ file, with no execution or decoding path in the snippet. The escape density is typical of marshalled bytecode and line tables.

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

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

    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";
    static const char __pyx_k_A_4uA_A_q[] = "\200A\330\010\013\2104\210u\220A\330\014\024\220A\340\014\020\320\020 \240\007\240q\250\001";
    dismissed LLM, confidence 0.90 Cython-emitted binary constant of compressed code-object data.
    Reasoning

    The literal is a Cython-emitted bytes constant of the same form as its neighbours (code-object or line-table data). It is generated boilerplate in a standard gRPC build artifact.

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

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

    static const char __pyx_k_A_K_oQa_K[] = "\200A\330\010\014\210K\220⟨U+007F⟩\240o\260Q\260a\330\010\014\210K\320\027)\250\021";
    static const char __pyx_k_A_Yhaz_Kz[] = "\200A\330\010\r\210Y\220h\230a\230z\250\021\330\010\014\210K\220z\240\027\250\001\250\021";
    static const char __pyx_k_AioServer[] = "AioServer";
    dismissed LLM, confidence 0.90 Generated Cython bytecode-style string constant in a C++ source file.
    Reasoning

    Standard Cython __pyx_k_ constant holding compressed code-object data. The high escape density is expected for bytecode and line tables in generated C++.

  471. 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";
    dismissed LLM, confidence 0.90 Cython-generated bytecode/line-table constant in generated C++.
    Reasoning

    The flagged string is a Cython-generated code-object constant, the same as the other __pyx_k_ entries in this file. The octal escapes encode bytecode, not an encoded dropper.

  472. 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!";
    dismissed LLM, confidence 0.88 Generated Cython code-object byte blob spanning several escape-run lines.
    Reasoning

    Generated Cython constant made of consecutive octal-escaped bytecode and exception-table bytes, consistent with the rest of the file. No dynamic execution or decoding appears in this snippet.

  473. 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.85 Generated Cython code-object constant containing NUL bytes from binary table encoding.
    Reasoning

    The NUL bytes come from encoded Python 3.11+ exception-table/line-table entries (e.g. \360\006\000\003) inside a generated __pyx_k_ constant. The embedded NUL is a byproduct of the binary encoding, which is why Cython emits a length-aware array, so it is not evidence of an attack.

  474. 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";
    dismissed LLM, confidence 0.90 Generated Cython bytecode-style string constant in a C++ extension source.
    Reasoning

    Cython-generated code-object constant in the same file, adjacent to ordinary identifier strings such as query_call and receive_op. The escape pattern is standard for compressed bytecode.

  475. 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";
    dismissed LLM, confidence 0.90 Cython-generated binary code-object constant spanning several lines.
    Reasoning

    Generated __pyx_k_ constant holding compressed code-object data, a standard Cython output. The run of octal escapes is bytecode and line-table data, not a payload.

  476. 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";
    dismissed LLM, confidence 0.90 Generated Cython code-object byte string in a C++ extension source.
    Reasoning

    Standard Cython-generated bytecode constant in a gRPC build artifact. Its octal escape density and layout match the other __pyx_k_ entries and show no execution or network behaviour.

  477. 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.93 Generated Cython byte-string constant holding a binary code-object table in grpcio's cygrpc.cpp.
    Reasoning

    The NUL-containing literal is a binary blob of the form Cython emits for embedded code-object location tables (the \200\001 / \360 prefixes and small-integer bytes are typical of CPython 3.11+ linetable encoding). The file is generated Cython output in grpcio, and the blob is inert data with no decode or execute path.

  478. 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.93 Octal-escaped binary constant from Cython-generated grpcio code.
    Reasoning

    Octal escapes are how the C compiler represents raw bytes in a generated bytes constant. The sequence matches the same CPython location-table pattern, and the file is standard Cython output inside the grpc source tree.

  479. 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 Generated Cython constant of binary code-object data.
    Reasoning

    This is a generated static byte array of interpreter metadata with the same structure as the other __pyx_k_ constants in the file. Nothing in the literal is executed or decoded at runtime beyond Python's own table handling.

  480. 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 Another generated binary metadata constant in cygrpc.cpp.
    Reasoning

    The adjacent line is an ordinary string constant and this literal is the same kind of generated binary table. The escape density is characteristic of compiled bytecode metadata, not a payload.

  481. 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.92 Generated Cython binary table constant.
    Reasoning

    The literal begins with the same location-table opening bytes and sits between ordinary identifier constants in Cython output. It is data consumed by the interpreter's debug and traceback machinery, with no execution or network behaviour.

  482. 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.92 Generated Cython constant containing an embedded NUL in binary table data.
    Reasoning

    The embedded NUL is the binary portion of a Cython-generated byte constant that encodes interpreter location data. The surrounding identifiers are ordinary, and the file is part of grpcio's standard build output.

  483. 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.92 Octal-escaped generated binary table in cygrpc.cpp.
    Reasoning

    The raw-pass octal run is the same generated binary table encoding, and the entropy is low for an encoded blob. This is a normal Cython artifact in the grpc source.

  484. 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.92 Generated Cython byte constant with a binary NUL-containing table.
    Reasoning

    The literal is a generated Cython byte constant with an embedded NUL from binary table encoding. It lies among other __pyx_k_ identifier constants, consistent with compiler output.

  485. 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.92 Generated binary table constant with octal escapes in grpcio.
    Reasoning

    This octal run is the same generated code-object encoding seen throughout cygrpc.cpp. The file is build-generated C from grpcio's Cython sources, and the bytes are passive data.

  486. 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.88 Cython-generated static byte array of marshalled bytecode in the grpc C++ source.
    Reasoning

    Same generated pattern: a __pyx_k_ static const char array of marshalled bytecode with the characteristic opcode-like octal sequences, in Cython's output for the grpc extension. Raw-pass octal runs are a known false-positive source for this kind of generated code.

  487. 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.88 Cython-generated marshalled bytecode constant in the grpc C++ source.
    Reasoning

    Standard Cython constant table entry (__pyx_k_ prefix) containing marshalled code-object bytes. The file is a generated C++ translation of the grpc Cython module, and the adjacent entry is a plain identifier string.

  488. 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.88 Cython-generated marshalled bytecode byte array in the grpc extension.
    Reasoning

    Same generated static char array of marshal output; the escape run is bytecode encoding rather than an obfuscated dropper, and the file is build-generated Cython output.

  489. 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.87 Multi-row Cython-generated marshalled bytecode constant in the grpc C++ source.
    Reasoning

    A __pyx_k_ generated constant with multiple rows of escape runs, consistent with Cython emitting a long marshalled code object across several source lines. No decoding or execution logic is present in the snippet; the array is only static data.

  490. 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.87 Embedded NUL byte in a Cython-generated marshalled bytecode constant.
    Reasoning

    Embedded NUL inside a Cython-generated marshalled code constant. The adjacent line is a normal identifier string, and the pattern matches Cython's output rather than deliberate string-level obfuscation.

  491. 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.87 Cython-generated marshalled bytecode byte array in the grpc extension source.
    Reasoning

    Generated Cython constant array of marshalled bytecode, and the following entry is a plain RSA identifier string. The octal run reflects bytecode encoding, which is expected for Cython output and is a common raw-pass false positive.

  492. 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.92 Cython-emitted static byte constant holding serialized Python code-object data inside the generated grpc cygrpc.cpp.
    Reasoning

    The octal run is a Cython-generated constant holding serialized CPython bytecode and line-table data (the \200\001, \340, \330 pattern is typical of Python 3.11+ code objects). It is a static const char array in a generated C++ file from the gRPC Python build. The adjacent symbol is a plain string, so this is a standard compiled artifact, not a payload.

  493. 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.92 Generated Cython constant containing encoded CPython bytecode and line-table bytes.
    Reasoning

    Same Cython bytecode-constant pattern: a __pyx_k_ string literal of marshalled code-object bytes in a generated file. The raw-pass octal and entropy flags are expected for compiled bytecode, and the snippet shows no execution or decoding logic.

  494. 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.92 Generated Cython bytecode constant in the gRPC extension source.
    Reasoning

    Same generated __pyx_k_ bytecode literal, flagged for octal escapes and entropy. Compiled Python bytecode is naturally high-entropy and escape-heavy, so this is a false positive for an obfuscation signal.

  495. 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";
    likely benign LLM, confidence 0.90 Bytecode constant with embedded zero bytes, typical of marshalled Python code objects.
    Reasoning

    The embedded NUL is an ordinary byte within marshalled bytecode and line-table data, which routinely contains zero bytes. The string is a generated code-object constant, and the token pass is reacting to its byte content rather than to any string-construction or sensitive-name pattern.

  496. 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";
    likely benign LLM, confidence 0.92 Cython-generated bytecode constant in the gRPC extension's C++ output.
    Reasoning

    Generated Cython __pyx_k_ literal of bytecode-like octal data; the adjacent entry is a readable identifier string. Nothing in the snippet is executed or decoded at runtime beyond Cython's normal interning of these constants.

  497. 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";
    likely benign LLM, confidence 0.90 Generated Cython constant holding serialized bytecode in cygrpc.cpp.
    Reasoning

    Same generated bytecode constant pattern in a Cython output file. The octal-escape density and entropy are characteristic of marshalled code objects and do not indicate a hidden payload.

  498. 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";
    likely benign LLM, confidence 0.90 Bytecode constant with embedded zero bytes in generated Cython output.
    Reasoning

    The embedded NUL sits inside a generated bytecode/line-table constant, which is expected for marshalled code objects. The token-pass finding is triggered by the byte content of a generated artifact, not by sensitive identifiers or runtime string construction.

  499. 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";
    likely benign LLM, confidence 0.90 Generated bytecode constant from the Cython build of grpc's cygrpc module.
    Reasoning

    Generated Cython constant of compiled bytecode-like data, with a neighbouring plain identifier string. This is a standard build artifact of the gRPC Python extension and matches no malicious pattern in the snippet.

  500. 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";
    likely benign LLM, confidence 0.90 Cython-generated encoded bytecode constant in the grpc extension source.
    Reasoning

    Same generated __pyx_k_ bytecode literal pattern, flagged on escape density and entropy. Compiled Python code objects produce exactly this signature, so the raw-pass flag is a false positive.

  501. 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";
    likely benign LLM, confidence 0.90 Bytecode constant with embedded NULs in generated Cython output.
    Reasoning

    Generated Cython bytecode constant containing zero bytes, consistent with marshalled code objects. The adjacent string is an ordinary identifier, and the snippet shows no execution or network behaviour.

  502. 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";
    likely benign LLM, confidence 0.90 Cython-emitted marshalled bytecode constant inside grpc's generated cygrpc.cpp.
    Reasoning

    The octal run is Cython-generated marshalled Python bytecode (code-object data with the usual \330/\320/\240 opcode-like bytes and NULs) stored as a static C string constant. It is a standard artifact of compiling a .pyx module in grpc's C++ output, not hidden payload logic. The raw pass flags it on byte patterns alone, a known high false-positive area.

  503. 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";
    likely benign LLM, confidence 0.90 Generated Cython constant holding marshalled bytecode bytes.
    Reasoning

    Same pattern as other Cython-generated __pyx_k_ string constants: a binary marshal blob of a code object encoded as octal escapes. Its presence in generated grpc C++ output is expected and nothing in the snippet shows execution or decoding code.

  504. 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";
    likely benign LLM, confidence 0.88 Embedded NUL bytes within a Cython-generated marshalled bytecode literal.
    Reasoning

    The embedded NUL comes from the binary marshal data in a Cython __pyx_k_ constant, which is normal for marshalled code objects. The token pass reports it, but the literal is generated data, not a string built to hide a name.

  505. 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";
    likely benign LLM, confidence 0.90 Generated Cython marshalled bytecode run in cygrpc.cpp.
    Reasoning

    Another octal run inside the same generated Cython bytecode constant. Entropy and escape density are typical of marshal output and the file is an ordinary generated grpc extension source.

  506. 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";
    likely benign LLM, confidence 0.90 Generated Cython bytecode constant, further octal escape run.
    Reasoning

    Continuation of the same generated marshalled-bytecode constant. No decoding or execution is shown; this is standard Cython output.

  507. 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!";
    likely benign LLM, confidence 0.90 Cython-generated marshalled bytecode literal in cygrpc.cpp.
    Reasoning

    A static __pyx_k_ constant with marshalled code-object bytes, adjacent to ordinary string constants. This is routine Cython codegen for the grpc extension and matches the other findings in this file.

  508. 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
  509. 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__
  510. 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
  511. 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    ");
  512. 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    ");
  513. 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_
  514. 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
  515. 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."
  516. 1215 of 1800 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  517. 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 unit test checking that StrFormat rejects the %n directive.
    Reasoning

    This is an abseil test asserting that FormatFails rejects the %n conversion. The format string is passed to a checked StrFormat-style API that does not write memory, and the expectation confirms %n is unsupported. The critical severity comes from the token pattern matching the literal, not from any real write.

  518. 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 Abseil test expecting a %n format string to fail.
    Reasoning

    Same as the other convert_test finding: %n appears only as a negative test string for FormatFails. It never reaches a C printf or write path, so there is no exploitable write.

  519. 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 Abseil test using %n as an expected-failure format string.
    Reasoning

    The %n here is a negative-test input to a type-checked formatting function that is expected to fail. The token signal fires on the string literal alone, and the surrounding context is a standard library test.

  520. 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 Abseil test exercising the safe %n count-capture feature of StrFormat.
    Reasoning

    Abseil's StrFormat is type-safe, and %n is handled through FormatCountCapture, a library type that records a count rather than writing through an arbitrary pointer. The test verifies this behavior, so the finding is a false positive on the literal.

  521. 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 Abseil test checking %n count capture with a safe wrapper type.
    Reasoning

    The %n is consumed by FormatCountCapture, a safe abseil wrapper that stores the number of characters output. This is a standard feature under test, not an attacker-controlled write primitive.

  522. 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 for %n count capture in StrFormat.
    Reasoning

    This is the same safe StrFormat %n count-capture test with a different format. The directive writes only through the library's capture object, so the critical severity reflects the string match, not real risk.

  523. 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 Unit test for absl StrFormat's %n count-capture support.
    Reasoning

    The %n directive appears inside a test string literal exercising absl's StrFormat, which deliberately supports %n via FormatCountCapture (a safe capture type). This is a vendored library's unit test, not an exploit.

  524. 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 Tests absl format spec handling of %n with a local counter.
    Reasoning

    Test of UntypedFormatSpec with %d%n writing into a local int via FormatArgImpl; expected library behavior in a test suite.

  525. 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 Tests absl format handling of %v%n with local count capture.
    Reasoning

    Same pattern as the prior finding, testing %v%n against a local variable inside vendored absl tests.

  526. 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 Test asserting %n writes correct character counts after padded output.
    Reasoning

    Verifies width-padded %n counting into n1/n2 with EXPECT_EQ assertions; a standard library conformance test.

  527. 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 Second %n capture in the same absl padded-format test.
    Reasoning

    Second %n capture in the same vendored test; benign library conformance check.

  528. 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 Test of StrAppendFormat with %n-driven dynamic width.
    Reasoning

    StrAppendFormat test using %n followed by %*s driven by the captured count; benign test of library behavior.

  529. 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 Test of StrAppendFormat %v/%n handling in absl.
    Reasoning

    Analogous StrAppendFormat test with %v and %n in vendored absl; benign.

  530. 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 mapping %n to a newline.
    Reasoning

    %n here is a strftime-style specifier mapping to newline in cctz's format tests; it is a documented format character, not a memory write.

  531. 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 where %n matches a newline.
    Reasoning

    parse("%n", "\n") in cctz tests expects %n to parse as whitespace/newline, consistent with strptime semantics; no memory write.

  532. 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.
  533. 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):
  534. 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
  535. 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
  536. 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|.
  537. 237 of 533 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  538. 381 of 629 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  539. 51 of 124 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  540. 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
  541. 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
  542. 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
  543. 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
  544. 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-----
  545. 912 of 1706 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  546. 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;
  547. `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 child process execs the test binary via execv.
    Reasoning

    Standard googletest death-test implementation calling execv on argv in a forked child; the path comes from the test binary's own argv, which is the expected design of the library.

  548. `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.93 Googletest test harness evals child process output at module scope.
    Reasoning

    Googletest's filter unit test evals output from a child test binary to get a boolean flag; the child is the project's own test program, so this is a known test-harness pattern, though eval on process output is poor practice.

  549. `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.93 Googletest test harness evals child process output to read an env flag.
    Reasoning

    Same pattern as the other eval: parses a Python boolean printed by the project's own test binary; benign in context of googletest's test suite.

  550. identifier `λμνοπ` contains homoglyph candidates: ν (03BD)→v, ο (03BF)→o (in string/comment) (raw pass, confidence 0.35)

          "δδπππσσσ",
          "λμνοπ",
          "ψρστυ",
        },
  551. identifier `λμνοπ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

          "δδπππσσσ",
          "λμνοπ",
          "ψρστυ",
        },
  552. 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☺" },
  553. 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☺" },
  554. 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☺" },
  555. 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β" },
  556. identifier `áxβ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

      { "\\Bx\\B", "axb" },
      { "\\Bx\\B", "áxβ" },
    
      // Weird boundary cases.
  557. 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" },
  558. 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" },
  559. 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" },
  560. 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" },
  561. 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" },
  562. 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" },
  563. 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.
  564. 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.
  565. identifier `𤭢XX` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
          "$¢€𤭢XX",
          "$¢€𤭢XX",
  566. 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.0.tar.gz https://files.pythonhosted.org/packages/3f/4f/4435c0aae54657258d9cfcba78598f3d9e5fe4c82ff18d78558567b90faf/grpcio-1.84.0.tar.gz
printf '%s  %s\n' 19aaf172fc2edbefccce3f6e92c5150975dbe56c45744e9e87cf72ebdf85bfbe grpcio-1.84.0.tar.gz | shasum -a 256 -c -
mkdir pkg && tar -xzf grpcio-1.84.0.tar.gz -C pkg --strip-components 1
disclude scan --untrusted --severity info pkg