Kevin/ServerSync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2ced3a81b6cf5931dad8e48eba75650dba37533f
ServerSync/lib/markdown_it/__pycache__/main.cpython-314.pyc

156 lines
20 KiB
Plaintext
Raw Normal View History

Init im going to bed -=-
2026-02-12 02:28:23 +02:00
+
<00> <0C>i<EFBFBD>1<00> <01>(a<00>0t$^RIHt^RIHtHtHtHtHt^RI H
t
^RI H t H t Ht^RIHtHt^RIHtHt^RIHt^RIHt^R IHt^R
IHtHt^R IHt^R I H!t!^R IH"t"H#t#H$t$H%t%^RI&t&R]PPPS4R]PTPS4R]PVPS4R]PXPS4R]PZPS4/t.R]/R&!RR4t0R# ]'dRt&L<>i;i)<18>)<01> annotations)<05>Callable<6C> Generator<6F>Iterable<6C>Mapping<6E>MutableMapping)<01>contextmanager)<03>Any<6E>Literal<61>overload)<02>helpers<72>presets)<02> normalize_url<72>utils)<01> ParserBlock)<01>
ParserCore)<01> ParserInline)<02> RendererHTML<4D>RendererProtocol)<01> StateCore)<01>Token)<04>EnvType<70> OptionsDict<63> OptionsType<70>
PresetTypeN<EFBFBD>defaultz
js-default<6C>zero<72>
commonmarkzgfm-likezdict[str, PresetType]<5D>_PRESETSc<01><><00>]tRt^ tR4R]/RRllltRRlt]RRl4t]R R
l4t]R R l4t]R Rl4t]RRl4tRRltRRlt R5RRllt
RRlt RRlt R6RRllt R6RRllt]RR l4tR7R!R"lltR#R$ltR5R%R&lltR5R'R(lltR5R)R*lltR5R+R,lltR-R.ltR/R0ltR1R2ltR3tR#)8<>
MarkdownItN<EFBFBD> renderer_clsc<01>$<00>V^8<>dQhRRRRRR/#)<07><00>config<69>str | PresetType<70>options_update<74>Mapping[str, Any] | Noner"z(Callable[[MarkdownIt], RendererProtocol]<5D>)<01>formats"<22>7/tmp/pip-target-qd_sq_1j/lib/python/markdown_it/main.py<70> __annotate__<5F>MarkdownIt.__annotate__!s(<00><00> ><3E> ><3E> <20> ><3E>1<> ><3E>
?<3F> ><3E>c <0A>t<00>\Vn\Vn\4Vn\ 4Vn\ 4VnV!V4Vn\'d\P!4MRVn V'd&\V\4'g\RV R24hVPWR7R#)aMain parser class
:param config: name of configuration to load or a pre-defined dictionary
:param options_update: dictionary that will be merged into ``config["options"]``
:param renderer_cls: the class to load as the renderer:
``self.renderer = renderer_cls(self)
Nz$options_update should be a mapping: z4
(Perhaps you intended this to be the renderer_cls?))r')rr r<00>inliner<00>blockr<00>core<72>renderer<65>
linkify_it<EFBFBD> LinkifyIt<49>linkify<66>
isinstancer<00> TypeError<6F> configure)<04>selfr%r'r"s&&&$r+<00>__init__<5F>MarkdownIt.__init__!s<><00><00><1B><04>
<EFBFBD><1E><04> <0C>#<23>n<EFBFBD><04> <0B> <20>]<5D><04>
<EFBFBD><1E>L<EFBFBD><04> <09>$<24>T<EFBFBD>*<2A><04> <0A>1;<3B><1A>z<EFBFBD>+<2B>+<2B>-<2D><14><04> <0C> <1A>*<2A>^<5E>W<EFBFBD>"E<>"E<><1B>6<>~<7E>6F<36>G<>H<01><0E> <0E> <0A><0E><0E>v<EFBFBD><0E>=r.c<01><00>V^8<>dQhRR/#)r$<00>return<72>strr))r*s"r+r,r-Cs<00><00>J<01>J<01>#<23>Jr.c <09>b<00>VPP RVPP R2#)<02>.z())<03> __class__<5F>
__module__<EFBFBD>__name__)r:s&r+<00>__repr__<5F>MarkdownIt.__repr__Cs+<00><00><16>.<2E>.<2E>+<2B>+<2B>,<2C>A<EFBFBD>d<EFBFBD>n<EFBFBD>n<EFBFBD>.E<>.E<>-F<>b<EFBFBD>I<>Ir.c<01> <00>V^8<>dQhRRRR/#)r$<00>namezLiteral['inline']r>rr))r*s"r+r,r-Gs<00><00>G<>G<> 1<>G<>l<EFBFBD>Gr.c <09><00>R#<00>Nr)<00>r:rHs&&r+<00> __getitem__<5F>MarkdownIt.__getitem__Fs<00><00>DGr.c<01> <00>V^8<>dQhRRRR/#)r$rHzLiteral['block']r>rr))r*s"r+r,r-Js<00><00>E<>E<> 0<>E<>[<5B>Er.c <09><00>R#rJr)rKs&&r+rLrMIs<00><00>BEr.c<01> <00>V^8<>dQhRRRR/#)r$rHzLiteral['core']r>rr))r*s"r+r,r-Ms<00><00>C<>C<><0F>C<>J<EFBFBD>Cr.c <09><00>R#rJr)rKs&&r+rLrMLs<00><00>@Cr.c<01> <00>V^8<>dQhRRRR/#)r$rHzLiteral['renderer']r>rr))r*s"r+r,r-Ps<00><00>M<>M<> 3<>M<>8H<38>Mr.c <09><00>R#rJr)rKs&&r+rLrMOs<00><00>JMr.c<01> <00>V^8<>dQhRRRR/#<00>r$rHr?r>r
r))r*s"r+r,r-Ss<00><00>0<>0<><03>0<><03>0r.c <09><00>R#rJr)rKs&&r+rLrMRs<00><00>-0r.c<01> <00>V^8<>dQhRRRR/#rUr))r*s"r+r,r-Us<00><00><10><10><03><10><03>r.c <09>t<00>RVPRVPRVPRVP/V,#<00>r0r1r2r3rYrKs&&r+rLrMUs:<00><00> <14>d<EFBFBD>k<EFBFBD>k<EFBFBD> <13>T<EFBFBD>Z<EFBFBD>Z<EFBFBD> <12>D<EFBFBD>I<EFBFBD>I<EFBFBD> <16><04> <0A> <0A> 
<EFBFBD>
<0F> <10> r.c<01> <00>V^8<>dQhRRRR/#)r$<00>optionsrr><00>Noner))r*s"r+r,r-]s<00><00>,<2C>,<2C>;<3B>,<2C>4<EFBFBD>,r.c <0A>&<00>\V4VnR#)atSet parser options (in the same format as in constructor).
Probably, you will never need it, but you can change options after constructor call.
__Note:__ To achieve the best possible performance, don't modify a
`markdown-it` instance options on the fly. If you need multiple configurations
it's best to create multiple instances and initialize each with separate config.
N)rr[)r:r[s&&r+<00>set<65>MarkdownIt.set]s<00><00>#<23>7<EFBFBD>+<2B><04> r.c<01>$<00>V^8<>dQhRRRRRR/#)r$rr&r'r(r>r!r))r*s"r+r,r-gs$<00><00>$<14>$<14>'<27>$<14>9Q<39>$<14> <13>$r.c <0A>`<00>\V\4'd)V\9d\RV R24h\V,pMTpV'g \ R4hVP R/4;'g/pV'd/VCVCpVP V4RV9d<>VR,P4F}wrVVP RR4pV'd"W,PPV4VP RR4pV'gK\W,PPV4K V#) auBatch load of all options and component settings.
This is an internal method, and you probably will not need it.
But if you will - see available presets and data structure
[here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
We strongly recommend to use presets instead of direct config loads.
That will give better compatibility with next versions.
zWrong `markdown-it` preset 'z ', check namez*Wrong `markdown-it` config, can't be emptyr[<00>
components<EFBFBD>rulesN<73>rules2) r7r?r<00>KeyError<6F>
ValueError<EFBFBD>getr^<00>items<6D>ruler<65>
enableOnly<EFBFBD>ruler2) r:rr'r%r[rH<00> componentrcrds &&& r+r9<00>MarkdownIt.configuregs<00><00> <16>g<EFBFBD>s<EFBFBD> #<23> #<23><16>h<EFBFBD>&<26><1E>!=<3D>g<EFBFBD>Y<EFBFBD>m<EFBFBD>T<>U<>U<><1D>g<EFBFBD>&<26>F<EFBFBD><1C>F<EFBFBD><15><1C>I<>J<> J<><18>*<2A>*<2A>Y<EFBFBD><02>+<2B>1<>1<>r<EFBFBD><07> <19>3<><17>3<>N<EFBFBD>3<>G<EFBFBD> <0C><08><08><17><19> <17>6<EFBFBD> !<21>#)<29>,<2C>#7<>#=<3D>#=<3D>#?<3F><0F><04>!<21> <0A> <0A>g<EFBFBD>t<EFBFBD>4<><05><18><18>J<EFBFBD>$<24>$<24>/<2F>/<2F><05>6<>"<22><1D><1D>x<EFBFBD><14>6<><06><19>6<EFBFBD><18>J<EFBFBD>%<25>%<25>0<>0<><16>8<> $@<01><14> r.c<01><00>V^8<>dQhRR/#<00>r$r>zdict[str, list[str]]r))r*s"r+r,r-<00>s<00><00><15><15>3<>r.c <0A><><00>RUu/uF$pWV,PP4bK& ppVPPP4VR&V#uupi<00>z%Return the names of all active rules.<2E>inline2<65>r2r1r0)ri<00> get_all_rulesr0rk<00>r:<00>chainrcs& r+rt<00>MarkdownIt.get_all_rules<65>sc<00><00>5<>
<EFBFBD>4<><05> <12><05>;<3B>$<24>$<24>2<>2<>4<> 4<>4<> <0E>
<EFBFBD> <20>;<3B>;<3B>-<2D>-<2D>;<3B>;<3B>=<3D><05>i<EFBFBD><18><14> <0C><> 
<EFBFBD><00>*Ac<01><00>V^8<>dQhRR/#ror))r*s"r+r,r-<00>s<00><00><15><15>"6<>r.c <0A><><00>RUu/uF$pWV,PP4bK& ppVPPP4VR&V#uupirq)ri<00>get_active_rulesr0rkrus& r+r{<00>MarkdownIt.get_active_rules<65>sc<00><00>5<>
<EFBFBD>4<><05> <12><05>;<3B>$<24>$<24>5<>5<>7<> 7<>4<> <0E>
<EFBFBD> <20>;<3B>;<3B>-<2D>-<2D>><3E>><3E>@<40><05>i<EFBFBD><18><14> <0C><> 
rxc<01>$<00>V^8<>dQhRRRRRR/#<00>r$<00>nameszstr | Iterable[str]<5D> ignoreInvalid<69>boolr>r!r))r*s"r+r,r-<00>s$<00><00><14><14>(<28><14>9=<3D><14> <13>r.c <0A><><00>.p\V\4'dV.pRF4pVPW,PP VR44K6 VPVP
P P VR44VUu.uF qUV9gK VNK ppV'dV'g\RV 24hV#uupi)a<>Enable list or rules. (chainable)
:param names: rule name or list of rule names to enable.
:param ignoreInvalid: set `true` to ignore errors when rule not found.
It will automatically find appropriate components,
containing rules with given names. If rule not found, and `ignoreInvalid`
not set - throws exception.
Example::
md = MarkdownIt().enable(['sub', 'sup']).disable('smartquotes')
Tz.MarkdownIt. Failed to enable unknown rule(s): rs)r7r?<00>extendri<00>enabler0rkrf<00>r:rr<><00>resultrvrH<00>misseds&&& r+r<><00>MarkdownIt.enable<6C>s<><00><00>"<14><06> <15>e<EFBFBD>S<EFBFBD> !<21> !<21><1A>G<EFBFBD>E<EFBFBD>0<>E<EFBFBD> <12>M<EFBFBD>M<EFBFBD>$<24>+<2B>+<2B>+<2B>2<>2<>5<EFBFBD>$<24>?<3F> @<40>1<><0E> <0A> <0A>d<EFBFBD>k<EFBFBD>k<EFBFBD>(<28>(<28>/<2F>/<2F><05>t<EFBFBD><<3C>=<3D>#(<28>?<3F>5<EFBFBD>4<EFBFBD><06>,><3E>$<24>$<24>5<EFBFBD><06>?<3F> <11>-<2D><1C>M<>f<EFBFBD>X<EFBFBD>V<>W<> W<><13> <0B><> @<01> <00>C<04>Cc<01>$<00>V^8<>dQhRRRRRR/#r~r))r*s"r+r,r-<00>s$<00><00><14><14>(<28><14>9=<3D><14> <13>r.c <0A><><00>.p\V\4'dV.pRF4pVPW,PP VR44K6 VPVP
P P VR44VUu.uF qUV9gK VNK ppV'dV'g\RV 24hV#uupi)z<>The same as [[MarkdownIt.enable]], but turn specified rules off. (chainable)
:param names: rule name or list of rule names to disable.
:param ignoreInvalid: set `true` to ignore errors when rule not found.
Tz/MarkdownIt. Failed to disable unknown rule(s): rs)r7r?r<>ri<00>disabler0rkrfr<>s&&& r+r<><00>MarkdownIt.disable<6C>s<><00><00><14><06> <15>e<EFBFBD>S<EFBFBD> !<21> !<21><1A>G<EFBFBD>E<EFBFBD>0<>E<EFBFBD> <12>M<EFBFBD>M<EFBFBD>$<24>+<2B>+<2B>+<2B>3<>3<>E<EFBFBD>4<EFBFBD>@<40> A<>1<><0E> <0A> <0A>d<EFBFBD>k<EFBFBD>k<EFBFBD>(<28>(<28>0<>0<><15><04>=<3D>><3E>#(<28>?<3F>5<EFBFBD>4<EFBFBD><06>,><3E>$<24>$<24>5<EFBFBD><06>?<3F> <11>-<2D><1C>N<>v<EFBFBD>h<EFBFBD>W<>X<> X<><13> <0B><>@r<>c<01><00>V^8<>dQhRR/#)r$r>zGenerator[None, None, None]r))r*s"r+r,r-<00>s<00><00>><3E>><3E>8<>>r.c# <0A>"<00>VP4pRx<00>VP4F/wr#VR8wgKW,PPV4K1 VPP
PVR,4R#5i)zEA context manager, that will reset the current enabled rules on exit.Nrr)r{rhrirjr0rk)r:<00> chain_rulesrvrcs& r+<00> reset_rules<65>MarkdownIt.reset_rules<65>sj<00><00><00><1B>+<2B>+<2B>-<2D> <0B> <0A>'<27>-<2D>-<2D>/<2F>L<EFBFBD>E<EFBFBD><14> <09>!<21><14> <0B>!<21>!<21>,<2C>,<2C>U<EFBFBD>3<>0<> <0A> <0B> <0B><1A><1A>%<25>%<25>k<EFBFBD>)<29>&<<3C>=<3D>s <00>.B<01>ABc<01>(<00>V^8<>dQhRRRRRRRR/#)r$rHr?<00>functionzCallable[..., Any]<5D>fmtr>r\r))r*s"r+r,r-<00>s2<00><00>H<01>H<01><17>H<01>#5<>H<01><?<3F>H<01> <0A>Hr.c <0A><><00>VPPV8Xd5VPVP4VPPV&R#R#)zdAdd a rule for rendering a particular Token type.
Only applied when ``renderer.__output__ == fmt``
N)r3<00>
__output__<EFBFBD>__get__rc)r:rHr<>r<>s&&&&r+<00>add_render_rule<6C>MarkdownIt.add_render_rule<6C>s><00><00> <10>=<3D>=<3D> #<23> #<23>s<EFBFBD> *<2A>(0<>(8<>(8<><14><1D><1D>(G<>D<EFBFBD>M<EFBFBD>M<EFBFBD> <1F> <1F><04> %<25> +r.c<01>(<00>V^8<>dQhRRRRRRRR/#)r$<00>pluginzCallable[..., None]<5D>paramsr
r[r>r!r))r*s"r+r,r-<00>s,<00><00><14><14>)<29><14>47<34><14>DG<44><14> <13>r.c <0A><00>V!V.VO5/VBV#)a?Load specified plugin with given params into current parser instance. (chainable)
It's just a sugar to call `plugin(md, params)` with curring.
Example::
def func(tokens, idx):
tokens[idx].content = tokens[idx].content.replace('foo', 'bar')
md = MarkdownIt().use(plugin, 'foo_replace', 'text', func)
r))r:r<>r<>r[s&&*,r+<00>use<73>MarkdownIt.use<73>s<00><00> <0F>t<EFBFBD>(<28>f<EFBFBD>(<28><07>(<28><13> r.c<01>$<00>V^8<>dQhRRRRRR/#<00>r$<00>srcr?<00>env<6E>EnvType | Noner>z list[Token]r))r*s"r+r,r-<00>s!<00><00><1C><1C><13><1C>><3E><1C>[<5B>r.c <0A>,<00>Vf/MTp\V\4'g\R\V4 24h\V\4'g\R\V4 24h\ WV4pVP PV4VP#)a<>Parse the source string to a token stream
:param src: source string
:param env: environment sandbox
Parse input string and return list of block tokens (special token type
"inline" will contain list of inline tokens).
`env` is used to pass data between "distributed" rules and return additional
metadata like reference info, needed for the renderer. It also can be used to
inject data in specific cases. Usually, you will be ok to pass `{}`,
and then pass updated object to renderer.
z+Input data should be a MutableMapping, not <20>#Input data should be a string, not ) r7rr8<00>typer?rr2<00>process<73>tokens<6E>r:r<>r<><00>states&&& r+<00>parse<73>MarkdownIt.parse<73>s<00><00><18>K<EFBFBD>b<EFBFBD>S<EFBFBD><03><19>#<23>~<7E>.<2E>.<2E><1B>I<>$<24>s<EFBFBD>)<29><1B>U<>V<> V<><19>#<23>s<EFBFBD>#<23>#<23><1B>A<>$<24>s<EFBFBD>)<29><1B>M<>N<> N<><19>#<23>S<EFBFBD>)<29><05> <0C> <09> <09><19><19>%<25> <20><14>|<7C>|<7C>r.c<01>$<00>V^8<>dQhRRRRRR/#<00>r$r<>r?r<>r<>r>r
r))r*s"r+r,r-s&<00><00> M<01> M<01>#<23> M<01>N<EFBFBD> M<01>c<EFBFBD> Mr.c <0A>~<00>Vf/MTpVPPVPW4VPV4#)aERender markdown string into html. It does all magic for you :).
:param src: source string
:param env: environment sandbox
:returns: The output of the loaded renderer
`env` can be used to inject additional metadata (`{}` by default).
But you will not need it with high probability. See also comment
in [[MarkdownIt.parse]].
)r3<00>renderr<72>r[<00>r:r<>r<>s&&&r+r<><00>MarkdownIt.renders5<00><00><18>K<EFBFBD>b<EFBFBD>S<EFBFBD><03><13>}<7D>}<7D>#<23>#<23>D<EFBFBD>J<EFBFBD>J<EFBFBD>s<EFBFBD>$8<>$<24>,<2C>,<2C><03>L<>Lr.c<01>$<00>V^8<>dQhRRRRRR/#r<>r))r*s"r+r,r- s!<00><00><1C><1C>s<EFBFBD><1C><1E><1C>;<3B>r.c <0A>:<00>Vf/MTp\V\4'g\R\V4 24h\V\4'g\R\V4 24h\ WV4pRVnVPPV4VP#)a The same as [[MarkdownIt.parse]] but skip all block rules.
:param src: source string
:param env: environment sandbox
It returns the
block tokens list with the single `inline` element, containing parsed inline
tokens in `children` property. Also updates `env` object.
z,Input data should be an MutableMapping, not r<>T)
r7rr8r<>r?r<00>
inlineModer2r<>r<>r<>s&&& r+<00> parseInline<6E>MarkdownIt.parseInline s<><00><00><18>K<EFBFBD>b<EFBFBD>S<EFBFBD><03><19>#<23>~<7E>.<2E>.<2E><1B>J<>4<EFBFBD>PS<50>9<EFBFBD>+<2B>V<>W<> W<><19>#<23>s<EFBFBD>#<23>#<23><1B>A<>$<24>s<EFBFBD>)<29><1B>M<>N<> N<><19>#<23>S<EFBFBD>)<29><05><1F><05><18> <0C> <09> <09><19><19>%<25> <20><14>|<7C>|<7C>r.c<01>$<00>V^8<>dQhRRRRRR/#r<>r))r*s"r+r,r-4s&<00><00>
S<01>
S<01><03>
S<01>.<2E>
S<01>C<EFBFBD>
Sr.c <0A>~<00>Vf/MTpVPPVPW4VPV4#)z<>Similar to [[MarkdownIt.render]] but for single paragraph content.
:param src: source string
:param env: environment sandbox
Similar to [[MarkdownIt.render]] but for single paragraph content. Result
will NOT be wrapped into `<p>` tags.
)r3r<>r<>r[r<>s&&&r+<00> renderInline<6E>MarkdownIt.renderInline4s7<00><00><18>K<EFBFBD>b<EFBFBD>S<EFBFBD><03><13>}<7D>}<7D>#<23>#<23>D<EFBFBD>$4<>$4<>S<EFBFBD>$><3E><04> <0C> <0C>c<EFBFBD>R<>Rr.c<01> <00>V^8<>dQhRRRR/#)r$<00>urlr?r>r<>r))r*s"r+r,r-Bs<00><00>/<2F>/<2F><03>/<2F><04>/r.c <0A>.<00>\P!V4#)aValidate if the URL link is allowed in output.
This validator can prohibit more than really needed to prevent XSS.
It's a tradeoff to keep code simple and to be secure by default.
Note: the url should be normalized at this point, and existing entities decoded.
)r<00> validateLink<6E>r:r<>s&&r+r<><00>MarkdownIt.validateLinkBs<00><00><1D>)<29>)<29>#<23>.<2E>.r.c<01> <00>V^8<>dQhRRRR/#)r$r<>r?r>r))r*s"r+r,r-Ls<00><00>0<>0<><13>0<><13>0r.c <0A>.<00>\P!V4#)zfNormalize destination URLs in links
::
[label]: destination 'title'
^^^^^^^^^^^
)r<00> normalizeLinkr<6B>s&&r+r<><00>MarkdownIt.normalizeLinkLs<00><00><1D>*<2A>*<2A>3<EFBFBD>/<2F>/r.c<01> <00>V^8<>dQhRRRR/#)r$<00>linkr?r>r))r*s"r+r,r-Vs<00><00>5<>5<>c<EFBFBD>5<>c<EFBFBD>5r.c <0A>.<00>\P!V4#)zBNormalize autolink content
::
<destination>
~~~~~~~~~~~
)r<00>normalizeLinkText)r:r<>s&&r+r<><00>MarkdownIt.normalizeLinkTextVs<00><00><1D>.<2E>.<2E>t<EFBFBD>4<>4r.)r1r2r r0r6r[r3r)rNrJ)F)<01>html)rDrC<00> __qualname__<5F>__firstlineno__rr;rEr rLr^r9rtr{r<>r<>r r<>r<>r<>r<>r<>r<>r<>r<>r<>r<><00>__static_attributes__r)r.r+r!r! s<><00><00> ><3E>
BN<01> ><3E> ><3E>DJ<01><0E>G<><0E>G<> <0A>E<><0E>E<> <0A>C<><0E>C<> <0A>M<><0E>M<> <0A>0<><0E>0<><10>,<2C>$<14>L<15><15><14>@<14>.<14>><3E><14>><3E>H<01><14>"<1C>. M<01><1C>(
S<01>/<2F>0<>5<>5r.r!)1<>__conditional_annotations__<5F>
__future__r<00>collections.abcrrrrr<00>
contextlibr <00>typingr
r r <00>r r<00>commonrr<00> parser_blockr<00> parser_corer<00> parser_inlinerr3rr<00>rules_core.state_corer<00>tokenrrrrrr4<00>ModuleNotFoundErrorr<00>make<6B>
js_defaultrr<00>gfm_liker<00>__annotations__r!)r<>s@r+<00><module>r<>s<><00><><01>"<22>"<22>R<>R<>%<25>)<29>)<29><1E>(<28>%<25>#<23>'<27>4<>,<2C><18>@<40>@<40><16><15> <0E>w<EFBFBD><EFBFBD><EFBFBD>#<23>#<23>%<25><10>'<27>$<24>$<24>)<29>)<29>+<2B>
<EFBFBD>G<EFBFBD>L<EFBFBD>L<EFBFBD> <1D> <1D> <1F><10>'<27>$<24>$<24>)<29>)<29>+<2B><0E><07> <20> <20>%<25>%<25>'<27> #<02><08>
<1F><02>~5<>~5<><35><1B><16><15>J<EFBFBD><16>s<00>,D<00> D<03>D
Reference in New Issue Copy Permalink