old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/jinja2/__pycache__/compiler.cpython-37.pyc

B
<00>/<2F>]j<><00>	@s<>
dZd
dl
mZ
d
dlmZ
d
dlmZ
d
dlm	Z	
d
dl
mZ
d
dlm
Z

d
dlmZ
d
d	lmZ
d
d
lmZ
d
dlmZmZmZ
d
dlmZmZmZmZmZmZmZ
d
d
l m!Z!m"Z"m#Z#m$Z$m%Z%
ddddddddd<16>Z&e'e(d<17>r<>dZ)ndZ)dg
Z*ye+d<1A>

e*<2A>,d<1B>

Wne-k
<EFBFBD>
r 


YnXye+d<1C>

Wne-k
<EFBFBD>
rH


dZ.YnXdZ.dd <20>Z/d6d"d#<23>
Z0d$d%<25>Z1d&d'<27>Z2Gd(d)<29>d)e3<65>Z4Gd*d+<2B>d+e3<65>Z5Gd,d-<2D>d-e6<65>Z7Gd.d/<2F>d/e<0F>Z8Gd0d1<64>d1e<0F>Z9Gd2d3<64>d3e:<3A>Z;Gd4d5<64>d5e<0F>Z<d!S)7z<37>
    jinja2.compiler
    ~~~~~~~~~~~~~~~

    Compiles nodes into python code.

    :copyright: (c) 2017 by the Jinja Team.
    :license: BSD, see LICENSE for more details.
<EFBFBD>)
<01>chain)
<01>deepcopy)
<01>	iskeyword)
<01>update_wrapper)
<01>nodes)
<01>EvalContext)
<01>NodeVisitor)
<01>	Optimizer)
<01>TemplateAssertionError)<03>Markup<75>concat<61>escape)<07>
range_type<EFBFBD>	text_type<70>string_types<65>	iteritems<6D>NativeStringIO<49>imap<61>izip)<05>Symbols<6C>VAR_LOAD_PARAMETER<45>VAR_LOAD_RESOLVE<56>VAR_LOAD_ALIAS<41>VAR_LOAD_UNDEFINEDz==z!=<3D>
>z>=<3D>
<z<=<3D>inznot in)<08>eq<65>ne<6E>gtZgteq<65>ltZlteqr<00>notinr<00>items<6D>divisionz%from __future__ import generator_stop<6F>generator_stopzdef f(): yield from x()FTc
s<00>f
d
d<02>}
t|
<01><00>S)NcsB|jr2|j
js2|j<03>|
|j
<01>}||
kr2|<00>||<02>S<00>||
|f|<03>
S)
N)<05>	optimized<65>eval_ctx<74>volatile<6C>	optimizer<65>visit)<05>self<6C>node<64>frame<6D>kwargsZnew_node)
<01>
f<><00>3/tmp/pip-install-c3kgu56x/Jinja2/jinja2/compiler.py<70>new_func@s




zoptimizeconst.<locals>.new_func)
r)r.r1r/)
r.r0<00>
optimizeconst?s
r2NcCsHt|t
j<02>std
<01>
<01>
|
<01>|
|||||<06>}|<07>|<00>

|dkrD|j<06><07>SdS)z+Generate the python source for a node tree.z Can't compile non template nodesN)<08>
isinstancer<00>Template<74>	TypeErrorZcode_generator_classr)<00>stream<61>getvalue)r+<00>environment<6E>name<6D>filenamer6<00>
defer_initr%<00>	generatorr/r/r0<00>generateJs








r=c
Cs<>|d
ks|tks|t
krdSt|<00>
ttttttft	kr<dSt|<00>
t
ttt
fkrnx|D]}
t|
<01>
sVdSqVWdSt|<00>
tkr<>x,t|<00>
D] \}}t|<02>
s<>dSt|<00>
s<>dSq<>WdSdS)z)Does the node have a safe representation?NTF)<11>NotImplemented<65>Ellipsis<69>type<70>bool<6F>int<6E>float<61>complexrrr<00>tuple<6C>list<73>set<65>	frozenset<65>
has_safe_repr<70>dictr)<03>value<75>item<65>keyr/r/r0rIWs"
















rIcCs@t|
<01>
}yx|D]}|<02>
|<03>

qWWntk
r8


YnX|jS)
z<>Check if the names passed are accessed undeclared.  The return value
    is a set of all the undeclared names from the sequence of names found.
    )<04>UndeclaredNameVisitorr)<00>VisitorExit<69>
undeclared)r<00>names<65>visitorr+r/r/r0<00>find_undeclaredls






rSc@seZ
dZd
d<02>ZdS)<04>MacroRefcCs|
|_d
|_
d
|_d
|_dS)NF)r+<00>accesses_caller<65>accesses_kwargs<67>accesses_varargs)r*r+r/r/r0<00>__init__{s



zMacroRef.__init__N)<04>__name__<5F>
__module__<EFBFBD>__qualname__rXr/r/r/r0rTysrTc@s8eZ
dZd
Zddd<04>
Zdd<06>Zd
dd	<09>
Zd
d<0B>ZeZdS)<0E>Framez&Holds compile time information for us.NcCsf|
|_t
|r|jpd|d
<01>|_d|_d|_|o2|j|_d|_|rF|jpHd|_||_|dk	rb|j|_dS)N)
<01>levelF)	r&r<00>symbols<6C>toplevel<65>	rootlevel<65>require_output_check<63>buffer<65>block<63>parent)r*r&rdr]r/r/r0rX<00>s




zFrame.__init__c
Cs*t<00>
|j<02>
}
|
j<03>|j<03>

|j<05><06>|
_|
S)
z!Create a copy of the current one.)<07>object<63>__new__<5F>	__class__<5F>__dict__<5F>updater^<00>copy)r*<00>rvr/r/r0rj<00>s


z
Frame.copyFcCs&|
rt|j
|jjd
d<02>St|j
|<00>S)zReturn an inner frame.<2E>
)
r])r\r&r^r])r*<00>isolatedr/r/r0<00>inner<65>s

zFrame.innerc
Cs|<00><00>}
d
|
_
|
S)a
Return a soft frame.  A soft frame may not be modified as
        standalone thing as it shares the resources with the frame it
        was created of, but it's not a rootlevel frame any longer.

        This is only used to implement if-statements.
        F)rjr`)r*rkr/r/r0<00>soft<66>s

z
Frame.soft)NN)
F)	rYrZr[<00>__doc__rXrjrnro<00>__copy__r/r/r/r0r\<00>s

 
r\c
@seZ
dZd
ZdS)rOz?Exception used by the `UndeclaredNameVisitor` to signal a stop.N)rYrZr[rpr/r/r/r0rO<00>s
rOc@s0eZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zdd	<09>Zd
S)<0B>DependencyFinderVisitorz.A visitor that collects filter and test calls.c

Cst<00>|_
t<00>|_dS)
N)rG<00>filters<72>tests)
r*r/r/r0rX<00>s

z DependencyFinderVisitor.__init__cCs|<00>|
<01>

|j
<01>|
j<03>

dS)
N)<04>
generic_visitrs<00>addr9)r*r+r/r/r0<00>visit_Filter<65>s


z$DependencyFinderVisitor.visit_FiltercCs|<00>|
<01>

|j
<01>|
j<03>

dS)
N)rurtrvr9)r*r+r/r/r0<00>
visit_Test<EFBFBD>s


z"DependencyFinderVisitor.visit_Testc
Csd
S)zStop visiting at blocks.Nr/)r*r+r/r/r0<00>visit_Block<63>s
z#DependencyFinderVisitor.visit_BlockN)rYrZr[rprXrwrxryr/r/r/r0rr<00>s

rrc@s(eZ
dZd
Zdd<03>Zdd<05>Zdd<07>ZdS)	rNz<>A visitor that checks if a name is accessed without being
    declared.  This is different from the frame visitor as it will
    not stop at closure frames.
    cCst|
<01>
|_
t<00>|_dS)
N)rGrQrP)r*rQr/r/r0rX<00>s


zUndeclaredNameVisitor.__init__cCsJ|
jd
kr8|
j
|jkr8|j<03>|
j
<01>

|j|jkrFt<05><00>
n|j<02>|
j
<01>

dS)N<>load)<07>ctxr9rQrPrvrO<00>discard)r*r+r/r/r0<00>
visit_Name<EFBFBD>s




z UndeclaredNameVisitor.visit_Namec
Csd
S)zStop visiting a blocks.Nr/)r*r+r/r/r0ry<00>s
z!UndeclaredNameVisitor.visit_BlockN)rYrZr[rprXr}ryr/r/r/r0rN<00>srNc
@seZ
dZd
ZdS)<03>CompilerExitz<74>Raised if the compiler encountered a situation where it just
    doesn't make sense to further process the code.  Any block that
    raises such an exception is not further processed.
    N)rYrZr[rpr/r/r/r0r~<00>sr~c@sVeZ
dZd<>dd<05>
Zdd<07>Zdd	<09>Zd
d<0B>Zd<>dd
<0A>
Zdd<0F>Zd<>dd<12>
Z	d<>dd<14>
Z
dd<16>Zd<>dd<18>
Zdd<1A>Z
dd<1C>Zd<>dd<1F>
Zd<>d d!<21>
Zd<>d"d#<23>
Zd$d%<25>Zd&d'<27>Zd<>d(d)<29>
Zd*d+<2B>Zd,d-<2D>Zd.d/<2F>Zd0d1<64>Zd2d3<64>Zd4d5<64>Zd6d7<64>Zd8d9<64>Zd:d;<3B>Zd<d=<3D>Zd>d?<3F>Zd@dA<64>Z dBdC<64>Z!dDdE<64>Z"dFdG<64>Z#dHdI<64>Z$dJdK<64>Z%d<>dLdM<64>
Z&dNdO<64>Z'dPdQ<64>Z(dRdS<64>Z)dTdU<64>Z*dVdW<64>Z+dXdY<64>Z,dZd[<5B>Z-d\d]<5D>Z.d^d_<64>Z/d`da<64>Z0dbdc<64>Z1ddde<64>Z2dfdg<64>Z3dhdi<64>Z4djdk<64>Z5dldm<64>Z6dndo<64>Z7dpdq<64>Z8drds<64>Z9dtdu<64>Z:dvdw<64>Z;dxdy<64>Z<d<>dzd{<7B>
Z=d<>d|d}<7D>
Z>e=d~<7E>
Z?e=d<64>
Z@e=d<><64>
ZAe=d<><64>
ZBe=d<><64>
ZCe=d<><64>
ZDe=d<><64>
ZEe=d<>dd<><64>ZFe=d<>dd<><64>ZGe>d~<7E>
ZHe>d<64>
ZIe>d<>dd<><64>ZJ[=[>eKd<4B>d<EFBFBD><64><00>
ZLeKd<4B>d<EFBFBD><64><00>
ZMd<4D>d<EFBFBD><64>ZNeKd<4B>d<EFBFBD><64><00>
ZOeKd<4B>d<EFBFBD><64><00>
ZPd<50>d<EFBFBD><64>ZQeKd<4B>d<EFBFBD><64><00>
ZReKd<4B>d<EFBFBD><64><00>
ZSeKd<4B>d<EFBFBD><64><00>
ZTeKd<4B>d<EFBFBD>d<EFBFBD><64>
<01>
ZUd<55>d<EFBFBD><64>ZVd<56>d<EFBFBD><64>ZWd<57>d<EFBFBD><64>ZXd<58>d<EFBFBD><64>ZYd<59>d<EFBFBD><64>ZZd<5A>d<EFBFBD><64>Z[d<>d<EFBFBD><64>Z\d<>d<EFBFBD><64>Z]d<>d<EFBFBD><64>Z^d<>d<EFBFBD><64>Z_d<5F>d<EFBFBD><64>Z`d<>d<EFBFBD><64>Zad<61>d<EFBFBD><64>Zbd<62>d<EFBFBD><64>Zcd
S)<29><>
CodeGeneratorNFTcCs<>|dkrt<00>}|
|_
||_||_||_d
|_||_||_|rFt|
<01>
|_	i|_
i|_d|_d
|_
d|_i|_i|_g|_d|_d|_d|_d|_d|_d|_g|_g|_dg
|_dS)NFr
rlT<>context)rr8r9r:r6Zcreated_block_contextr;r%r	r(<00>import_aliases<65>blocks<6B>extends_so_far<61>has_known_extends<64>code_linenortrs<00>
debug_info<EFBFBD>_write_debug_info<66>
_new_lines<EFBFBD>
_last_line<EFBFBD>_first_write<74>_last_identifier<65>_indentation<6F>
_assign_stack<63>_param_def_block<63>_context_reference_stack)r*r8r9r:r6r;r%r/r/r0rX<00>s8












zCodeGenerator.__init__cCst|
||j
|j<02><04>
d
S)z*Fail with a :exc:`TemplateAssertionError`.N)r
r9r:)r*<00>msg<73>linenor/r/r0<00>fail9
szCodeGenerator.failc

Cs|jd
7_d|jS)zGet a new unique identifier.rlzt_%d)
r<>)
r*r/r/r0<00>temporary_identifier=
s
z"CodeGenerator.temporary_identifiercCs|<00><00>|
_
|<00>d
|
j
<00>

dS)z7Enable buffering for the frame from that point onwards.z%s = []N)r<>rb<00>	writeline)r*r,r/r/r0rbB
s

zCodeGenerator.buffercCs<>|s<>|
jj
rd|<00>d
<01>

|<00><03>
|<00>d|
j<00>

|<00><05>
|<00>d<03>

|<00><03>
|<00>d|
j<00>

|<00><05>
dS|
jjr<>|<00>d|
j<00>

dS|<00>d|
j<00>

dS)z(Return the buffer contents of the frame.zif context.eval_ctx.autoescape:zreturn Markup(concat(%s))zelse:zreturn concat(%s)N)r&r'r<><00>indentrb<00>outdent<6E>
autoescape)r*r,<00>force_unescapedr/r/r0<00>return_buffer_contentsG
s















z$CodeGenerator.return_buffer_contentsc

Cs|jd
7_dS)zIndent by one.rlN)
r<>)
r*r/r/r0r<>Y
szCodeGenerator.indentrlcCs|j|
8_d
S)zOutdent by step.N)
r<>)r*<00>stepr/r/r0r<>]
szCodeGenerator.outdentcCs.|
jd
kr|<00>
d|<02>
n|<00>
d|
j|<02>
d
S)z%Yield or write into the frame buffer.Nzyield z
%s.append()rbr<>)r*r,r+r/r/r0<00>start_writea
s

zCodeGenerator.start_writecCs|
jd
k	r|<00>
d<02>

d
S)z1End the writing process started by `start_write`.N<>
))rb<00>write)r*r,r/r/r0<00>	end_writeh
s

zCodeGenerator.end_writecCs$|<00>||<03>
|<00>
|
<01>

|<00>|<02>

d
S)z4Simple shortcut for start_write + write + end_write.N)r<>r<>r<>)r*<00>
sr,r+r/r/r0<00>simple_writem
s


zCodeGenerator.simple_writecCsBy(|<00>d
<01>

x|
D]}|<00>
||<02>
qWWntk
r<


YnXdS)z<>Visit a list of nodes as block in a frame.  If the current frame
        is no buffer a dummy ``if 0: yield None`` is written automatically.
        <20>passN)r<>r)r~)r*rr,r+r/r/r0<00>
blockvisits
s






zCodeGenerator.blockvisitcCs<>|jrp|j
sR|j<02>d
|j<00>

|j|j7_|jdk	rR|j<06>|j|jf<02>

d|_d|_
|j<02>d|j<00>

d|_|j<02>|
<01>

dS)z&Write a string into the output stream.<2E>

NFz    r
)	r<>r<>r6r<>r<>r<>r<><00>appendr<64>)r*<00>
xr/r/r0r<>~
s













zCodeGenerator.writer
cCs|<00>||<03>
|<00>
|
<01>

d
S)z!Combination of newline and write.N)<02>newliner<65>)r*r<>r+<00>extrar/r/r0r<><00>
s
zCodeGenerator.writelinecCs:t|j
d
|<00>|_
|
dk	r6|
j|jkr6|
j|_|
j|_dS)z/Add one or more newlines before the next write.rlN)<05>maxr<78>r<>r<>r<>)r*r+r<>r/r/r0r<><00>
s


zCodeGenerator.newlinec	Cs<>
d
}x0tdd<03>|
j
D<00>
|pd<04>D]}t|<05>
r d}Pq Wx$|
jD]}|<00>d<06>

|<00>||<02>
q>W|s<>x$|
j
D]}|<00>d<06>

|<00>||<02>
qhW|dk	r<>x&t|<03>
D]\}}|<00>d||f<00>

q<>W|
jr<>|<00>d	<09>

|<00>|
j|<02>
|<04>
r<>|
jdk	r<>|<00>d
<EFBFBD>

n
|<00>d<0B>

x8|
j
D].}|<00>d|j	<00>

|<00>|j
|<02>
|<00>d<06>

<00>
qW|dk	<09>
rhx(t|<03>
D]\}}|<00>d
||f<00>

<00>
qHW|
jdk	<09>
r<>|<00>d<0E>

|<00>|
j|<02>
|<00>d<0F>

n
|<00>d<10>

n$|
jdk	<09>
r<>|<00>d<11>

|<00>|
j|<02>
dS)a,
Writes a function call to the stream for the current node.
        A leading comma is added automatically.  The extra keyword
        arguments may not include python keywords otherwise a syntax
        error could occour.  The extra keyword arguments should be given
        as python dict.
        Fc
ss|]}
|
jV
qdS)
N)
rM)<02>.0r<EFBFBD>r/r/r0<00>	<genexpr><3E>
sz*CodeGenerator.signature.<locals>.<genexpr>r/Tz, Nz, %s=%sz, *z
, **dict({z, **{z%r: z%r: %s, z}, **r<><00>
}z, **)rr-<00>is_python_keyword<72>argsr<73>r)rZdyn_argsZ
dyn_kwargsrMrK)	r*r+r,<00>extra_kwargsZkwarg_workaround<6E>kwarg<72>argrMrKr/r/r0<00>	signature<72>
sJ	
 




































zCodeGenerator.signaturecCszt<00>}x|
D]}|<02>
|<03>

qWxVd
D]N}t||<04>}x>t||<04>D]0}||krV|<00><03>||<|<00>d||||f<00>

q>Wq$WdS)zPull all the dependencies.)rsrtz%s = environment.%s[%r]N)rrr)<00>getattrr<72>r<>)r*rrRr+<00>
dependency<EFBFBD>mappingr9r/r/r0<00>pull_dependencies<65>
s











zCodeGenerator.pull_dependenciescCs<>g}x<>t|
j
j<02>
D]p\}\}}|tkr(q|tkrJ|<00>d
||<00><06>|f<00>

q|tkrf|<00>d||f<00>

q|tkrz|<02>	|<03>

qt
d<03>
<01>
qW|r<>|<00>dd<05>|<02>
<00>

dS)Nz%s = %s(%r)z%s = %szunknown load instructionz%s = missingz = )rr^<00>loadsrrr<><00>get_resolve_funcrrr<><00>NotImplementedError<6F>join)r*r,<00>undefs<66>target<65>action<6F>paramr/r/r0<00>enter_frame<6D>
s












zCodeGenerator.enter_framecCsH|sDg}x"t|
j
j<02>
D]\}}|<03>|<04>

qW|rD|<00>d
d<02>|<03>
<00>

dS)Nz%s = missingz = )rr^r<>r<>r<>r<>)r*r,<00>with_python_scoper<65>r<><00>
_r/r/r0<00>leave_frame<6D>
s





zCodeGenerator.leave_framecCs|jj
rd
|
Sd|
S)Nzasync def %szdef %s)r8<00>is_async)r*r9r/r/r0<00>func<6E>
s


zCodeGenerator.funcc
Cs<>|<02><00>}|j
<01>|
<01>

t|
<01>
}d
}t<04>}g}xNt|
j<06>
D]@\}}|jdkrL|}|jdkrb|<05>|j<07>

|<06>	|j
<01>
|j<07>
<01>

q6Wt|
jd<04>}	d|	kr<>|d
k	r<>y|
j
|t|
j<06>

Wq<>tk
r<EFBFBD>


|<00>d|
j<11>
Yq<>Xn|<06>	|j
<01>d<02>
<01>

d|_d|	k<06>
rd|k<07>
r|<06>	|j
<01>d<07>
<01>

d|_d|	k<06>
rDd|k<07>
rD|<06>	|j
<01>d<08>
<01>

d|_d	|_|j
<01>|
<01>

|<00>d
|<00>d<0B>
d<0C>|<06>
f|
<01>
|<00><1A>
|<00>|<02>

|<00>|<02>

|<00>|<02>

x<>t|
j<06>
D]<5D>\}}|j
<01>
|j<07>
}
|<00>d
|
<00>

|<00><1A>
y|
j
|t|
j<06>
}Wn2tk
<EFBFBD>r


|<00>d|
d|j|jf<00>

YnX|<00>d|
<00>

|<00>||<02>
|<00>|
<EFBFBD>

|<00> <20>
<00>
q<>W|<00>!<21>
|<00>"|
j|<02>
|j#|dd<11>
|j$|dd<12>
|<00> <20>
||fS)z/Dump the function def of a macro or call block.N<>caller)r-<00>varargs)r<>r-r<>zhWhen defining macros or call blocks the special "caller" argument must be omitted or be given a default.Tr-r<>Fz%s(%s):<3A>macroz, zif %s is missing:z%s = undefined(%r, name=%r)zparameter %r was not providedz%s = )
r<>)
r<>)%rnr^<00>analyze_noderTrG<00>	enumerater<65>r9rvr<><00>refrS<00>body<64>defaults<74>len<65>
IndexErrorr<EFBFBD>r<><00>declare_parameterrUrVrWrar<>r<>r<>r<>rbr<><00>push_parameter_definitionsr)<00>mark_parameter_storedr<64><00>pop_parameter_definitionsr<73>r<>r<>)r*r+r,<00>	macro_refZexplicit_callerZskip_special_paramsr<73><00>idxr<78>rPr<><00>defaultr/r/r0<00>
macro_body<EFBFBD>
sp
























 























zCodeGenerator.macro_bodycCs`d
<01>dd<03>|
j
jD<00>
<01>
}t|
j
dd<05>}t|
j
j<02>
dkr>|d7}|<00>d|||
j|
j|
jf<00>

dS)	z<Dump the macro definition for the def created by macro_body.z, c
ss|]}
t|
j
<01>
V
qdS)
N)<02>reprr9)r<>r<>r/r/r0r<>Hsz*CodeGenerator.macro_def.<locals>.<genexpr>r9Nrl<00>
,zLMacro(environment, macro, %r, (%s), %r, %r, %r, context.eval_ctx.autoescape))	r<>r+r<>r<>r<>r<>rVrWrU)r*r<>r,Z	arg_tupler9r/r/r0<00>	macro_defFs




zCodeGenerator.macro_defcCs*d
|
j}|j
dk	r&|dt|j
<01>
7}|S)z.Return a human readable position for the node.zline %dNz in )r<>r9r<>)r*r+rkr/r/r0<00>positionQs




zCodeGenerator.positioncCs"d
d<02>dd<04>t
|
j<02><03><00>
D<00>
<01>
S)Nz{%s}z, c
ss|]\}
}d|
|fV
qd
S)z%r: %sNr/)r<>r9r<>r/r/r0r<>Zsz3CodeGenerator.dump_local_context.<locals>.<genexpr>)r<>rr^Zdump_stores)r*r,r/r/r0<00>dump_local_contextXs


z CodeGenerator.dump_local_contextc

Cs"|<00>d
<01>

|<00>d<02>

|<00>d<03>

dS)z<>Writes a common preamble that is used by root and block functions.
        Primarily this sets up common local helpers and enforces a generator
        through a dead branch.
        z$resolve = context.resolve_or_missingz!undefined = environment.undefinedzif 0: yield NoneN)
r<>)
r*r/r/r0<00>
write_commons]s



zCodeGenerator.write_commonscCs|j<00>
|
j<02><03><00>

d
S)aQ
Pushes all parameter targets from the given frame into a local
        stack that permits tracking of yet to be assigned parameters.  In
        particular this enables the optimization from `visit_Name` to skip
        undefined expressions for parameters in macros as macros can reference
        otherwise unbound parameters.
        N)r<>r<>r^Zdump_param_targets)r*r,r/r/r0r<>fsz(CodeGenerator.push_parameter_definitionsc

Cs|j<00>
<01>
d
S)z+Pops the current parameter definitions set.N)r<><00>pop)
r*r/r/r0r<>osz'CodeGenerator.pop_parameter_definitionscCs|jr|jd
<00>
|
<01>

dS)z<>Marks a parameter in the current parameter definitions as stored.
        This will skip the enforced undefined checks.
        <20><><EFBFBD><EFBFBD><EFBFBD>N)r<>r|)r*r<>r/r/r0r<>ss
z#CodeGenerator.mark_parameter_storedcCs|j<00>
|
<01>

dS)
N)r<>r<>)r*r<>r/r/r0<00>push_context_referencezs
z$CodeGenerator.push_context_referencec

Cs|j<00>
<01>
dS)
N)r<>r<>)
r*r/r/r0<00>pop_context_reference}s
z#CodeGenerator.pop_context_referencec

Cs
|jd
S)Nr<4E>)
r<>)
r*r/r/r0<00>get_context_ref<65>s
zCodeGenerator.get_context_refc
Cs|jd
}
|
dkrdSd|
S)Nr<4E>r<><00>resolvez
%s.resolve)
r<>)r*r<>r/r/r0r<><00>s




zCodeGenerator.get_resolve_funccCsd
|<00><00>|<00>
|
<01>
fS)Nz%s.derived(%s))r<>r<>)r*r,r/r/r0<00>derive_context<78>s


zCodeGenerator.derive_contextcCs|js
d
S|
|jdkS)z4Checks if a given target is an undeclared parameter.Fr<46>)
r<>)r*r<>r/r/r0<00>parameter_is_undeclared<65>s

z%CodeGenerator.parameter_is_undeclaredc

Cs|j<00>
t<02><00>

d
S)z+Pushes a new layer for assignment tracking.N)r<>r<>rG)
r*r/r/r0<00>push_assign_tracking<6E>sz"CodeGenerator.push_assign_trackingcCs<>|j<00>
<01>}|
jr|sd
Sdd<03>|D<00>
}t|<02>
dkr^tt|<02>
<01>
}|
j<06>|<04>
}|<00>d||f<00>

nV|<00>d<06>

x@t	|<02>
D]4\}}|r<>|<00>
d<07>

|
j<06>|<04>
}|<00>
d||f<00>

qrW|<00>
d	<09>

|r<>t|<03>
dkr<>|<00>d
|d<00>

n|<00>dd<07>tt
|<03><02>
<00>

d
S)
zoPops the topmost level for assignment tracking and updates the
        context variables if necessary.
        Nc
Ss g|]}
|
dd
<01>dkr|
<01>qS)Nrlr<>r/)r<>r<>r/r/r0<00>
<listcomp><3E>sz5CodeGenerator.pop_assign_tracking.<locals>.<listcomp>rlzcontext.vars[%r] = %szcontext.vars.update({z, z%r: %sz})zcontext.exported_vars.add(%r)r
z"context.exported_vars.update((%s)))r<>r<>r_r<><00>next<78>iterr^r<>r<>r<>r<>r<>rr<>)r*r,<00>varsZpublic_namesr9r<>r<>r/r/r0<00>pop_assign_tracking<6E>s*






















z!CodeGenerator.pop_assign_trackingcCs<>|dkstd
<01>
<01>
t
|j|j<03>}ddlm}
|<00>dd<05>t<08>
<00>

|<00>dd<05>|<04>
<00>

|jj	rd|<00>d<07>

|j
rpdprd	}|
<01>tj
<0A>
dk	}x@|
<01>tj<0F>
D]0}|j|jkr<>|<00>d
|j|j<12>
||j|j<q<>Wxz|
<01>tj<13>
D]j}|j|jkr<>|j}	|<00><16>|j|	<}
d|	k<06>
r,|	<09>dd<0C>\}}|<00>d
|||
f<00>

q<>|<00>d|	|
f<00>

q<>W|<00>d|j<00>

|jd|<00>d<11>
|fdd<12>
|<00><19>
|<00><1A>
t|<03>
}dt|
jd<14>k<06>
r<>|j<1E>d<13>
}
|<00>d|
<00>

|j<1E> |
<01>

d|_!|_"|<06>
o<>|j#|_$|<06>
r<>|<00>d<17>

|<00>%|<02>

|<00>&|
j<1D>

|<00>'|
j|<02>
|j(|dd<18>
|<00>)<29>
|<06>r<>|j#<23>sD|<00><19>
|<00>d<19>

|<00><19>
t*<2A>rh|jj	<09>sh|<00>d<1A>

n8|<00>d|jj	<09>r~d<1C>p<>d	<00>

|<00><19>
|<00>d<1D>

|<00>)<29>
|<00>)d|j#<00>

x<>t+|j<10>
D]<5D>\}}|<00>d|<00>d|<00>
|f|d<0C>
|<00><19>
|<00><1A>
t|<03>
}t|jd<1F>}d|k<06>r.|j<1E>d<13>
}
|<00>d|
<00>

d |k<06>rX|j<1E>d <20>
}
|<00>d!|
||f<00>

|j<1E> |<07>

||_,|<00>%|<0F>

|<00>&|j<1D>

|<00>'|j|<0F>
|j(|dd<18>
|<00>)<29>
<00>q<>W|jd"d<05>d#d$<24>|jD<00>
<01>
dd<12>
|<00>d%d&<26>d'd$<24>|j-D<00>
<01>
<00>

dS)(Nzno root frame allowedr
)
<01>__all__zfrom __future__ import %sz, zfrom jinja2.runtime import zOfrom jinja2.asyncsupport import auto_await, auto_aiter, make_async_loop_contextz, environment=environment<6E>zblock %r defined twice<63>
.rlzfrom %s import %s as %szimport %s as %sz	name = %rz%s(context, missing=missing%s):<3A>root)
r<>r*)
r*z%s = TemplateReference(context)Tzparent_template = None)
r<>zif parent_template is not None:z4yield from parent_template.root_render_func(context)z9%sfor event in parent_template.root_render_func(context):zasync zyield eventZblock_)r*<00>superr<72>z %s = context.super(%r, block_%s)z
blocks = {%s}c
ss|]}
d|
|
fV
qd
S)z%r: block_%sNr/)r<>r<>r/r/r0r<>#s
z/CodeGenerator.visit_Template.<locals>.<genexpr>zdebug_info = %r<>
&c
ss|]}
d|
V
qd
S)z%s=%sNr/)r<>r<>r/r/r0r<>(s).<2E>AssertionErrorrr8r9Zjinja2.runtimer<65>r<>r<><00>
code_featuresr<73>r;<00>findrZExtends<64>find_allZBlockr<6B>r<>r<>ZImportedName<6D>
importnamer<EFBFBD>r<><00>rsplitr<74>r<>r<>r\rSr<>r^r<>r<>r_r`r<>rar<>r<>r<>r<>r<><00>supports_yield_fromrrcr<>)r*r+r,r&ZexportedZenvenvZhave_extendsrc<00>import_<74>imp<6D>alias<61>module<6C>objr<6A>r9<00>block_framerPr/r/r0<00>visit_Template<74>s<>








































































zCodeGenerator.visit_TemplatecCs<>d
}|jr8|j
rdS|jd
kr8|<00>d<03>

|<00><04>
|d7}|
jrJ|<00>|<02>
}n|<00><07>}tr<>|j	j
s<EFBFBD>|jdkr<>|<00>d|
j|f|
<01>
nD|j	j
r<EFBFBD>dp<>d}|<00>d||
j|f|
<01>
|<00><04>
|<00>
d	|<02>
|<00><0E>
|<00>|<03>

dS)
z.Call a block and register it for the template.r
Nzif parent_template is None:rlz$yield from context.blocks[%r][0](%s)z	async for<6F>forz&%s event in context.blocks[%r][0](%s):<3A>event)r_r<>r<>r<>r<><00>scopedr<64>r<>r<>r8r<>rbr9r<>r<>)r*r+r,r]r<><00>loopr/r/r0ry+s,

















zCodeGenerator.visit_BlockcCs<>|js|<00>
d
|
j<02>
|jdkrZ|js6|<00>d<03>

|<00><06>
|<00>dd<00>

|jrRt<07><00>
n|<00><08>
|<00>d|
<01>
|<00>	|
j
|<02>
|<00>d|j<00>

|<00>dt
<00>

|<00><06>
|<00>d	<09>

|<00><08>
|jr<>d
|_|jd7_dS)
zCalls the extender.z,cannot use extend from a non top-level scoper
zif parent_template is not None:zraise TemplateRuntimeError(%r)zextended multiple timesz+parent_template = environment.get_template(z, %r)z6for name, parent_block in parent_template.blocks.%s():z8context.blocks.setdefault(name, []).append(parent_block)TrlN)r_r<>r<>r<>r<>r<>r<>r~r<>r)<00>templater<65>r9<00>dict_item_iterr`)r*r+r,r/r/r0<00>
visit_ExtendsKs.
















zCodeGenerator.visit_ExtendscCs<>
|
jr|<00>
d
<01>

|<00><02>
d}t|
jtj<06>rVt|
jjt<08>r>d}qnt|
jjt	t
f<02>rnd}nt|
jtjtjf<02>rnd}|<00>
d||
<01>
|<00>
|
j|<02>
|<00>d|j<00>

|
jr<>|<00><10>
|<00>
d<07>

|<00><02>
|<00>
d<08>

|<00><10>
|<00>
d	<09>

|<00><02>
d
}|
j<11>
r|jjr<>dp<>d}|<00>
d
||<00>|<02>
f<00>

n6|jj<13>
r,|<00>
d<0E>

n t<15>
rB|<00>
d<0F>

d}n
|<00>
d<11>

|<04>
sn|<00><02>
|<00>d|<02>
|<00><10>
|
j<00>
r~|<00><10>
dS)zHandles includes.ztry:Zget_or_select_templateZget_templateZselect_templateztemplate = environment.%s(z, %r)zexcept TemplateNotFound:r<>zelse:Fz	async forr<72>zY%s event in template.root_render_func(template.new_context(context.get_all(), True, %s)):zGfor event in (await template._get_default_module_async())._body_stream:z6yield from template._get_default_module()._body_streamTz9for event in template._get_default_module()._body_stream:r<>N)Zignore_missingr<67>r<>r3r
rZConstrKrrErFZTupleZListr)r<>r9r<><00>with_contextr8r<>r<>r<>r<>)r*r+r,<00>	func_nameZskip_event_yieldr

r/r/r0<00>
visit_IncludezsN



































zCodeGenerator.visit_IncludecCs<>|<00>d
|j
<01>|
j<03>
|
<01>
|jr0|<00>d|
j<00>

|jjrB|<00>d<03>

|<00>d<04>

|<00>|
j	|<02>
|<00>d|j
<00>

|
jr<>|<00>d|jjr<>dp<>d|<00>|<02>
f<00>

n|jjr<>|<00>d	<09>

n
|<00>d
<EFBFBD>

|jr<>|
j<03>
d<0B>
s<>|<00>d|
j<00>

d
S)zVisit regular imports.z%s = zcontext.vars[%r] = zawait zenvironment.get_template(z, %r).z*make_module%s(context.get_all(), True, %s)<29>_asyncr<63>z_get_default_module_async()z_get_default_module()r<>z!context.exported_vars.discard(%r)N)r<>r^r<>r<>r_r<>r8r<>r)r
r9r
r<><00>
startswith)r*r+r,r/r/r0<00>visit_Import<72>s"

















zCodeGenerator.visit_Importc	s<>
|<00>|
<01>

|<00>
d
|jjrdpd<00>

|<00>|
j<05><00>
|<00>
d|j<00>

|
jrn|<00>
d|jjrZdp\d|<00><08><00>
f<00>

n|jjr<>|<00>
d<07>

n
|<00>
d<08>

g}g}x<>|
j	D]<5D>}t
|t<0B>r<>|\}}n|}|<00>d	<09>j
<0A>|<06>
|f<00>

|<00>d
<EFBFBD>j
<0A>|<06>
<00>

|<00><0F>
|<00>d<0B>j
<0A>|<06>
d|<00>|
<01>
t|<05>
f|f<00>

|<00><12>
<00>jr<>|<03>|<06>

|<06>d
<0A>
s<>|<04>|<06>

q<>W|<03>
r<>t|<03>
dk<02>
r<>|d}|<00>d|<05>j
<0A>|<05>
f<00>

n"|<00>dd<12><17>f
dd<14>|D<00>
<01>
<00>

|<04>
r<>t|<04>
dk<02>
r<>|<00>d|d<00>

n|<00>dd<12>tt|<04><02>
<00>

dS)zVisit named imports.z/included_template = %senvironment.get_template(zawait r<>z, %r).z*make_module%s(context.get_all(), True, %s)r
z_get_default_module_async()z_get_default_module()z,%s = getattr(included_template, %r, missing)zif %s is missing:z9%s = undefined(%r %% included_template.__name__, name=%r)zGthe template %%r (imported on %s) does not export the requested name %sr<73>rlr
zcontext.vars[%r] = %szcontext.vars.update({%s})z, c
3s"|]}
d|
<01>j<00>
|
<01>
fV
qd
S)z%r: %sN)r^r<>)r<>r9)
r,r/r0r<><00>sz1CodeGenerator.visit_FromImport.<locals>.<genexpr>z!context.exported_vars.discard(%r)z-context.exported_vars.difference_update((%s))N)r<>r<>r8r<>r)r
r9r
r<>rQr3rEr<>r^r<>r<>r<>r<>r<>r_r<>r	
r<>r<>r)r*r+r,Z	var_namesZdiscarded_namesr9r<>r/)
r,r0<00>visit_FromImport<72>s\













































zCodeGenerator.visit_FromImportcCsR|<02><00>}|<02><00>}|<02><00>}|
j
p2d
t|
jdd<03>
d<04>k}d}|rH|j<04>d
<01>
}|jj|
dd<06>
|
jrn|jj|
dd<06>
|
j<08>
rl|<00>	<09>}|jj|
dd<06>
|<00>
d	|<00>|<08>
|
j<08>
|<00><0C>
|<00>
|<04>

|<00>
|jjr<>d
p<EFBFBD>d<0B>

|<00>|
j|<03>
|<00>d<0C>

|<00>|jjr<>d
p<>d<0E>

|<00>d<0F>

|<00><0C>
|<00>
d|
j<08>
|<00>|
j|<04>
|<00>d<0F>

|<00><0C>
|<00>
d<11>

|<00>|
j|<03>
|<00>d<12>

|j|dd<14>
|
j
<01>
r<>|<00>
d|<00>d
<01>
|
<01>
|<00><0C>
|<00>|<03>

|j|_|<06>
r<>|<00>
d|<00>

x<|
<01>tj<18>
D],}	|	jdk<02>
r<>|	jd
k<02>
r<>|<00>d|	j<1C>
<00>
q<>W|
j<07>r|<00>	<09>}
|<00>
d|
<00>

|<00>
|jj<0F>r(d
<EFBFBD>p*d|
<01>
|<00>|
j|<03>
|<06>rn|jj<0F>r^|<00>d|<00>

n|<00>d|<00>

n
|<00>d<0C>

|
j<08>r<>|<00>d|<00>

|
j
<01>r<>|<00>d<1D>

nB|jj<0F>r<>|<06>s<>|<00>d<1E>

|<00>|
j|<02>
|jj<0F>r<>|<06>s<>|<00>d<1F>

|
j<08>r<>|<00>d<1F>

|
j
<01>r
|<00>d <20>

n|<00>|<06>rd!<21>pd<0F>

|<00><0C>
|<00>
|<03>

|<00>|
j|<03>
|
j<07>rV|<00>
d"|
<00>

|<00><13>
|j||
j
<01>or|
jd<14>
|
j<07>r<>|<00>
d#|
<00>

|<00><0C>
|<00>
|<05>

|<00>|
j|<05>
|<00>|<05>

|<00><13>
|
j
<01>rN|<00> |<03>

|<00><13>
|<00>!||
<01>
|jj<0F>r<>|<00>d$<24>

|<00>d%<25>

|jj<0F>r|<00>d<1E>

|<00>|
j|<02>
|jj<0F>r:|<00>d<1F>

|<00>d&<26>

|<00>"|<02>

dS)'Nr

)
r<>)
<01>only)
r

r<>)
Z
for_branch<EFBFBD>else<73>testz
%s(fiter):z
async for zfor z in zauto_aiter(fiter)Zfiter<65>
:zif zyield <20>T)
r<>z'%s(reciter, loop_render_func, depth=0):z%s = missing<6E>storez8Can't assign to special loop variable in for-loop targetz%s = 1z&, %s in await make_async_loop_context(z, %s in LoopContext(z%s(Zreciterzauto_aiter(r<>z&, undefined, loop_render_func, depth):z
, undefined):z%s = 0zif %s:zawait zloop(z, loop))#rn<00>	recursiverSZiter_child_nodesr^r<>r<><00>else_r
r<>r<>r<>r<>r<>r8r<>r)r<>r<>r<>r<>rbr<>r<00>Namer{r9r<>r<>r<>r<>r<>r<>r<>r<>)r*r+r,Z
loop_frameZ
test_frameZ
else_frameZ
extended_loopZloop_refZloop_filter_funcr9Ziteration_indicatorr/r/r0<00>	visit_Fors<>




































































































zCodeGenerator.visit_ForcCs<>|<02><00>}|<00>
d
|
<01>
|<00>|
j|<03>
|<00>d<02>

|<00><05>
|<00>|
j|<03>
|<00><08>
xP|
j	D]F}|<00>
d|<04>
|<00>|j|<03>
|<00>d<02>

|<00><05>
|<00>|j|<03>
|<00><08>
qRW|
j
r<EFBFBD>|<00>
d<04>

|<00><05>
|<00>|
j
|<03>
|<00><08>
dS)Nzif r
zelif zelse:)ror<>r)r
r<>r<>r<>r<>r<><00>elif_r
)r*r+r,Zif_framer
r/r/r0<00>visit_If<49>s&





















zCodeGenerator.visit_IfcCs<>|<00>|
|<02>\}}|<00>
<01>
|jrX|
j<03>d
<01>
s:|<00>d|
j<00>

|j<06>|
j<03>
}|<00>d|
j<00>

|<00>d|j<06>|
j<03>
<00>

|<00>	||<03>
dS)Nr<4E>zcontext.exported_vars.add(%r)zcontext.vars[%r] = z%s = )
r<EFBFBD>r<>r_r9r	
r<>r^r<>r<>r<>)r*r+r,Zmacro_framer<65>r<>r/r/r0<00>visit_Macro<72>s








zCodeGenerator.visit_MacrocCsR|<00>|
|<02>\}}|<00>
d
<01>

|<00>||<03>
|<00>||
<01>
|j|
j|dd<03>
|<00>|<02>

dS)Nz	caller = T)
<01>forward_caller)r<>r<>r<>r<><00>
visit_Call<EFBFBD>callr<6C>)r*r+r,Z
call_framer<EFBFBD>r/r/r0<00>visit_CallBlock<63>s






zCodeGenerator.visit_CallBlockcCsh|<02><00>}|j
<01>|
<01>

|<00>|<03>

|<00>|<03>

|<00>|
j|<03>
|<00>||
<01>
|<00>|
j	|<03>
|<00>
|<02>

|<00>|<03>

dS)
N)rnr^r<>r<>rbr<>r<>r<>rw<00>filterr<72>r<>)r*r+r,Zfilter_framer/r/r0<00>visit_FilterBlock<63>s











zCodeGenerator.visit_FilterBlockcCs<>|<02><00>}|j
<01>|
<01>

|<00>|<03>

xLtt|
j|
j<07><02>
D]6\}\}}|<00><08>
|<00>	||<03>
|<00>
d
<01>

|<00>	||<02>
q2W|<00>|
j|<03>
|<00>
|<03>

dS)Nz = )rnr^r<>r<>r<>r<00>targets<74>valuesr<73>r)r<>r<>r<>r<>)r*r+r,Z
with_framer<EFBFBD>r<><00>exprr/r/r0<00>
visit_With<EFBFBD>s




 






zCodeGenerator.visit_WithcCs|<00>|
<01>

|<00>
|
j|<02>
dS)
N)r<>r)r+)r*r+r,r/r/r0<00>visit_ExprStmt<6D>s


zCodeGenerator.visit_ExprStmtc	s<><00>jr|j
rdSd
}<03>jjrj<72>jj}t|dd<03>s<t|dd<03>rBd}qnt|dd<03>r\<5C>f
dd<07>}qn<71>f
dd<07>}nt}d}|j
r<><72><00>d	<09>

<00><00><07>
d
}g}x<>|
jD]<5D>}y|s<>t<08>	<09><00>
|<08>
|j<0B>
}	Wn"tj	k
r<EFBFBD>


|<07>|<08>

w<>YnXy2|jj
<0A>
rt|	d
<EFBFBD>r<>|	<09><0F>}	nt|	<09>
}	||	<09>
}	Wn"tk
<EFBFBD>
r2


|<07>|<08>

w<>YnX|<07>
rZt|dt<13><02>
rZ|d<00>|	<09>

q<>|<07>|	g
<01>

q<>Wt|<07>
dk<00>
s<>|jdk	<09>r |jdk	<09>
r<>t|<07>
d
k<02>
r<><72><00>d|j<00>

n<10><00>d|j<00>

<00><00><07>
<00>
x|D<00>
]}
t|
t<13><02>rtt|
<EFBFBD>
<01>
}|jdk<08>r
<EFBFBD><00>d|<00>

n<0E><00>|d<00>

n<>|jdk<08>r4<72><00>d|
<EFBFBD>
n
<EFBFBD><00>|
<EFBFBD>

d
}|jj<19>rX<72><00>d<12>

n |jj
<0A>rn<72><00>d<13>

n
<EFBFBD><00>d<14>

<00>jjdk	<09>r<><72><00>d<15>

t<04>jjdd<03><03>r<><72><00>d<16>

|d
7}<0C><00>|
|<02>
<00><00>d|<00>

|jdk	<09>
rЈ<00>d<11>

<00>
q<>W|jdk	<09>r<><72><00><1C>
<00><00>t|<07>
d
k<02>rd<17>pd<18>

<00>
nxg}
g}xF|D]>}
t|
t<13><02>rV|
<0A>t|
<EFBFBD>
<01>dd<1A><02>

n|
<0A>d<1B>

|<0E>|
<EFBFBD>

<00>q.W<00><00>d<10>

<00><00>tt|
<0A>
<01>
d<00>

<00><00><07>
x<>|D]<5D>}<0F><00>|<0F>

d}|jj<19>rΈ<00>d<12>

|d
7}n|jj
<0A>r<><72><00>d<13>

|d
7}<0C>jjdk	<09>rb<72><00>d<15>

t<04>jjdd<03><03>r <20><00>d<16>

n:t<04>jjdd<03><03>r><3E><00>d<1E>

nt<04>jjdd<03><03>rZ<72><00>d<1F>

|d
7}<0C><00>||<02>
<00><00>d|d <00>

<00>q<>W<00><00><1C>
<00><00>d<17>

|<06>r<><72><00><1C>
dS)!NTZcontextfunctionFZevalcontextfunctionZenvironmentfunctionc

st<00>j
<01><02>j
|<00><02>
S)
N)rr8<00>finalize)
r<>)
r*r/r0<00><lambda><3E>s
z,CodeGenerator.visit_Output.<locals>.<lambda>c

st<00>j
<01>|<00>
<01>
S)
N)rr8r$
)
r<>)
r*r/r0r%
<00><00>zif parent_template is None:<3A>__html__r<5F>r
rlz
%s.append(z%s.extend((zyield r<>z7(escape if context.eval_ctx.autoescape else to_string)(zescape(z
to_string(zenvironment.finalize(z	context, r<>z))<29>
%z%%z%sz % (r
zcontext.eval_ctx, z
environment, z, )r<>rar8r$
r<>rr<>r<>r<00>
Impossible<EFBFBD>as_constr&r<>r<><00>hasattrr'
r
<00>	Exceptionr3rFr<>rbr<>rr<>r'r<>r)r<><00>replace)r*r+r,Zallow_constant_finalizer<65>r$
Z
outdent_laterr<72><00>child<6C>constrL<00>val<61>close<73>format<61>	arguments<74>argumentr/)
r*r0<00>visit_Output<75>s<>

































































"
















































zCodeGenerator.visit_OutputcCsF|<00><00>
|<00>
|
<01>

|<00>|
j|<02>
|<00>d
<01>

|<00>|
j|<02>
|<00>|<02>

dS)Nz = )r<>r<>r)r<>r<>r+r<>)r*r+r,r/r/r0<00>visit_AssignVs







zCodeGenerator.visit_AssigncCs<>|<00><00>
|<02>
<01>}d
|_|j<03>|
<01>

|<00>|<03>

|<00>|<03>

|<00>|
j|<03>
|<00>	|
<01>

|<00>
|
j|<02>
|<00>d<02>

|
j
dk	r<>|<00>|
j
|<03>
n|<00>d|j<00>

|<00>d<04>

|<00>|<02>

|<00>|<03>

dS)NFz9 = (Markup if context.eval_ctx.autoescape else identity)(z
concat(%s)r<>)r<>rnrar^r<>r<>rbr<>r<>r<>r)r<>r<>r
rwr<>r<>)r*r+r,r<>r/r/r0<00>visit_AssignBlock^s 



















zCodeGenerator.visit_AssignBlockcCs<>|
jd
kr(|j
r(|jr(|jd<00>|
j<04>

|j<05>|
j<04>
}|
jdkr<>|j<05>|<03>
}|dk	rj|dtkrj|<00>	|<03>
r<>|<00>
d|
j||f<00>

dS|<00>
|<03>

dS)Nr
r<>rzr
z-(undefined(name=%r) if %s is missing else %s))r{r_r<>rvr9r^r<>Z	find_loadrr<>r<>)r*r+r,r<>rzr/r/r0r}ws











zCodeGenerator.visit_NamecCsR|j<00>
|
j<02>
}|<00>d
|<00>

|<00><04>
|<00>dd<00>

|<00><05>
|<00>d||
jf<00>

dS)Nz!if not isinstance(%s, Namespace):zraise TemplateRuntimeError(%r)z/cannot assign attribute on non-namespace objectz%s[%r])r^r<>r9r<>r<>r<><00>attr)r*r+r,r<>r/r/r0<00>visit_NSRef<65>s





zCodeGenerator.visit_NSRefcCs8|
<01>|j
<01>
}t|t<03>r&|<00>t|<03>
<01>

n|<00>t|<03>
<01>

dS)
N)r*
r&r3rCr<><00>strr<72>)r*r+r,r0
r/r/r0<00>visit_Const<73>s



zCodeGenerator.visit_ConstcCsFy|<00>t
|
<01>|j<03>
<01>
<01>

Wn&tjk
r@


|<00>d
|
j<00>

YnXdS)Nz9(Markup if context.eval_ctx.autoescape else identity)(%r))r<>r<>r*
r&rr)
<00>data)r*r+r,r/r/r0<00>visit_TemplateData<74>s





z CodeGenerator.visit_TemplateDatacCsZ|<00>d
<01>

d}x0t
|
j<02>
D]"\}}|r0|<00>d<03>

|<00>||<02>
qW|<00>|dkrPdpRd<06>

dS)N<>
(r<>z, r
z,)r<>)r<>r<>r"r))r*r+r,r<>rLr/r/r0<00>visit_Tuple<6C>s








zCodeGenerator.visit_TuplecCsJ|<00>d
<01>

x0t
|
j<02>
D]"\}}|r,|<00>d<02>

|<00>||<02>
qW|<00>d<03>

dS)N<>
[z, <20>
])r<>r<>r"r))r*r+r,r<>rLr/r/r0<00>
visit_List<EFBFBD>s







zCodeGenerator.visit_ListcCsd|<00>d
<01>

xJt
|
j<02>
D]<\}}|r,|<00>d<02>

|<00>|j|<02>
|<00>d<03>

|<00>|j|<02>
qW|<00>d<04>

dS)N<>
{z, z: r<>)r<>r<>r"r)rMrK)r*r+r,r<>rLr/r/r0<00>
visit_Dict<EFBFBD>s










zCodeGenerator.visit_Dictcst<00>f
d
d<02><08>
}|S)Ncs<>|jj
rJ<72>|jjkrJ|<00>d
<01><00>

|<00>|
j|<02>
|<00>d<02>

|<00>|
j|<02>
n4|<00>d<03>

|<00>|
j|<02>
|<00>d<04><00>

|<00>|
j|<02>
|<00>d<05>

dS)Nz$environment.call_binop(context, %r, z, r>
z %s r<>)r8<00>	sandboxedZintercepted_binopsr<73>r)<00>left<66>right)r*r+r,)
<01>operatorr/r0rR<00>s










z$CodeGenerator.binop.<locals>.visitor)
r2)rH
<00>
interceptablerRr/)
rH
r0<00>binop<6F>s
zCodeGenerator.binopcst<00>f
d
d<02><08>
}|S)Ncs\|jj
r2<72>|jjkr2|<00>d
<01><00>

|<00>|
j|<02>
n|<00>d<02><00>

|<00>|
j|<02>
|<00>d<03>

dS)Nz#environment.call_unop(context, %r, r>
r<>)r8rE
Zintercepted_unopsr<73>r)r+)r*r+r,)
rH
r/r0rR<00>s




z#CodeGenerator.uaop.<locals>.visitor)
r2)rH
rI
rRr/)
rH
r0<00>uaop<6F>s

zCodeGenerator.uaop<6F>
+<2B>
-<2D>
*<2A>
/z//z**r(
<00>and)
rI
<00>orznot cCsb|jj
rd
}n|jjrd}nd}|<00>d|<00>

x$|
jD]}|<00>||<02>
|<00>d<05>

q6W|<00>d<06>

dS)Nz;(context.eval_ctx.volatile and markup_join or unicode_join)Zmarkup_joinZunicode_joinz%s((z, z)))r&r'r<>r<>rr))r*r+r,r
r<>r/r/r0<00>visit_Concat<61>s






zCodeGenerator.visit_ConcatcCs.|<00>|
j
|<02>
x|
jD]}|<00>||<02>
qWdS)
N)r)r!
<00>ops)r*r+r,<00>opr/r/r0<00>
visit_Compare<72>s

zCodeGenerator.visit_ComparecCs&|<00>d
t
|
j<00>

|<00>|
j|<02>
dS)Nz %s )r<><00>	operatorsrT
r)r!
)r*r+r,r/r/r0<00>
visit_Operands

zCodeGenerator.visit_OperandcCs,|<00>d
<01>

|<00>
|
j|<02>
|<00>d|
j<00>

dS)Nzenvironment.getattr(z, %r))r<>r)r+r8
)r*r+r,r/r/r0<00>
visit_Getattrs


zCodeGenerator.visit_GetattrcCs~t|
j
tj<03>r@|<00>|
j|<02>
|<00>d
<01>

|<00>|
j
|<02>
|<00>d<02>

n:|<00>d<03>

|<00>|
j|<02>
|<00>d<04>

|<00>|
j
|<02>
|<00>d<05>

dS)Nr@
rA
zenvironment.getitem(z, r<>)r3r<>rZSlicer)r+r<>)r*r+r,r/r/r0<00>
visit_Getitem
s










zCodeGenerator.visit_GetitemcCs`|
jdk	r|<00>
|
j|<02>
|<00>d
<01>

|
jdk	r:|<00>
|
j|<02>
|
jdk	r\|<00>d
<01>

|<00>
|
j|<02>
dS)Nr
)<05>startr)r<><00>stopr<70>)r*r+r,r/r/r0<00>visit_Slices












zCodeGenerator.visit_SlicecCs,
|jj
r|<00>d
<01>

|<00>|j|
jd<00>

|jj<03>|
j<04>
}|dkrT|<00>d|
j|
j<07>
t|dd<05>rl|<00>d<06>

n.t|dd<05>r<>|<00>d<08>

nt|d	d<05>r<>|<00>d
<EFBFBD>

|
j	dk	r<>|<00>
|
j	|<02>
nJ|jjr<>|<00>d|j
|j
f<00>

n*|jjr<>|<00>d|j
<00>

n|<00>d
|j
<00>

|<00>|
|<02>
|<00>d<0E>

|jj
<01>
r(|<00>d<0E>

dS)Nzawait auto_await(r>
zno filter named %rZ
contextfilterFz	context, Zevalcontextfilterzcontext.eval_ctx, Zenvironmentfilterz
environment, zB(context.eval_ctx.autoescape and Markup(concat(%s)) or concat(%s))zMarkup(concat(%s))z
concat(%s)r<>)r8r<>r<>rsr9<00>getr<74>r<>r<>r+r)r&r'rbr<>r<>)r*r+r,r<>r/r/r0rw#s0
























zCodeGenerator.visit_FiltercCs`|<00>|j
|
jd
<00>

|
j|jj
kr8|<00>d|
j|
j<05>
|<00>|
j|<02>
|<00>|
|<02>
|<00>d<03>

dS)Nr>
zno test named %rr<72>)	r<>rtr9r8r<>r<>r)r+r<>)r*r+r,r/r/r0rxCs




zCodeGenerator.visit_Testcs^<00><00>
<01>fd
d<02>}<03><02>d<03>

<00><02>
<01>
j<02><00>
<00><02>d<04>

<00><02>
<01>
j<03><00>
<00><02>d<05>

|<03>
<00><02>d<06>

dS)Ncs4<00>
jdk	r<18><02>
<01>
j<00><00>S<00><02>d
d<02><02><03>
<01>
<00>

dS)Nz
undefined(%r)zRthe inline if-expression on %s evaluated to false and no else section was defined.)Zexpr2r)r<>r<>r/)r,r+r*r/r0<00>write_expr2Ns



z1CodeGenerator.visit_CondExpr.<locals>.write_expr2r>
z if z else r<>)r<>r)<00>expr1r
)r*r+r,r^
r/)r,r+r*r0<00>visit_CondExprLs








zCodeGenerator.visit_CondExprcCs||jj
r|<00>d
<01>

|jjr&|<00>d<02>

n
|<00>d<03>

|<00>|
j|<02>
|rJddi
pLd}|<00>|
||<04>
|<00>d<05>

|jj
rx|<00>d<05>

dS)Nzawait auto_await(zenvironment.call(context, z
context.call(r<>r<>)r8r<>r<>rE
r)r+r<>)r*r+r,r
r<>r/r/r0r
]s











zCodeGenerator.visit_CallcCs"|<00>|
j
d
<00>

|<00>|
j|<02>
dS)N<>
=)r<>rMr)rK)r*r+r,r/r/r0<00>
visit_Keywordls

zCodeGenerator.visit_KeywordcCs&|<00>d
<01>

|<00>
|
j|<02>
|<00>d<02>

dS)NzMarkup(r<>)r<>r)r!
)r*r+r,r/r/r0<00>visit_MarkSafers



zCodeGenerator.visit_MarkSafecCs&|<00>d
<01>

|<00>
|
j|<02>
|<00>d<02>

dS)Nz5(context.eval_ctx.autoescape and Markup or identity)(r<>)r<>r)r!
)r*r+r,r/r/r0<00>visit_MarkSafeIfAutoescapews



z(CodeGenerator.visit_MarkSafeIfAutoescapecCs|<00>d
|
j
<00>

dS)Nzenvironment.)r<>r9)r*r+r,r/r/r0<00>visit_EnvironmentAttribute|s
z(CodeGenerator.visit_EnvironmentAttributecCs|<00>d
|
j
|
jf<00>

dS)Nzenvironment.extensions[%r].%s)r<><00>
identifierr9)r*r+r,r/r/r0<00>visit_ExtensionAttributes
z&CodeGenerator.visit_ExtensionAttributecCs|<00>|j
|
j<00>

dS)
N)r<>r<>r<>)r*r+r,r/r/r0<00>visit_ImportedName<6D>s
z CodeGenerator.visit_ImportedNamecCs|<00>|
j
<01>

dS)
N)r<>r9)r*r+r,r/r/r0<00>visit_InternalName<6D>s
z CodeGenerator.visit_InternalNamecCs|<00>d
<01>

dS)Nr<4E>)
r<>)r*r+r,r/r/r0<00>visit_ContextReference<63>s
z$CodeGenerator.visit_ContextReferencecCs|<00>d
|
<01>
dS)N<>continue)
r<>)r*r+r,r/r/r0<00>visit_Continue<75>s
zCodeGenerator.visit_ContinuecCs|<00>d
|
<01>
dS)N<>break)
r<>)r*r+r,r/r/r0<00>visit_Break<61>s
zCodeGenerator.visit_BreakcCs:|<02><00>}|j
<01>|
<01>

|<00>|<03>

|<00>|
j|<03>
|<00>|<03>

dS)
N)rnr^r<>r<>r<>r<>r<>)r*r+r,<00>scope_framer/r/r0<00>visit_Scope<70>s






zCodeGenerator.visit_ScopecCs<>|<00><00>}|<00>
d
||<00>|<02>
f<00>

|<00>
d|<00>

|<00>|
j|<02>
|<00>|<03>

|jdd<04>
}|j<07>|
<01>

|<00>	|<04>

|<00>
|
j|<04>
|<00>|<04>

|<00>
<0A>
dS)Nz%s = %sz
%s.vars = T)
rm)r<>r<>r<>r)r<>r<>rnr^r<>r<>r<>r<>r<>r<>)r*r+r,r{ro
r/r/r0<00>visit_OverlayScope<70>s












z CodeGenerator.visit_OverlayScopec	Cstxn|
jD]d}|<00>
d
|j<00>

|<00>|j|<02>
y|j<04>|j<06>
}Wntjk
rZ


d|j_	YqXt
|j|j|<04>
qWdS)Nzcontext.eval_ctx.%s = T)<0B>optionsr<73>rMr)rKr*
r&rr)
r'<00>setattr)r*r+r,<00>keywordr0
r/r/r0<00>visit_EvalContextModifier<65>s






z'CodeGenerator.visit_EvalContextModifiercCsf|<00><00>}|j
<01><02>}|<00>d
|<00>

|<00>|
|<02>
x|
jD]}|<00>||<02>
q4W|j
<01>|<04>

|<00>d|<00>

dS)Nz%s = context.eval_ctx.save()zcontext.eval_ctx.revert(%s))r<>r&<00>saver<65>ru
r<>r)<00>revert)r*r+r,Zold_ctx_nameZ	saved_ctxr.
r/r/r0<00>visit_ScopedEvalContextModifier<65>s








z-CodeGenerator.visit_ScopedEvalContextModifier)NFT)
F)
rl)
N)
N)Nr
)Nr
)
N)
F)
N)
T)
T)
F)drYrZr[rXr<>r<>rbr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>ryr
r
r

r
r
r
r
r
r
r"
r#
r5
r6
r7
r}r9
r;
r=
r?
rB
rD
rJ
rK
Z	visit_AddZ	visit_SubZ	visit_MulZ	visit_DivZvisit_FloorDivZ	visit_PowZ	visit_ModZ	visit_AndZvisit_OrZ	visit_PosZ	visit_NegZ	visit_Notr2rR
rU
rW
rX
rY
r\
rwrxr`
r
rb
rc
rd
re
rg
rh
ri
rj
rl
rn
rp
rq
ru
rx
r/r/r/r0r<00>s<>

B






5

M		
t /6;	
















 	
r)NFT)=rp<00>	itertoolsrrjrrt
rr<><00>	functoolsrZjinja2rZjinja2.nodesrZjinja2.visitorrZjinja2.optimizerr	Zjinja2.exceptionsr
Zjinja2.utilsrrr
Zjinja2._compatrrrrrrrZjinja2.idtrackingrrrrrrV
r+
rJr
r<><00>execr<63><00>SyntaxErrorr<72>r2r=rIrSrerTr\<00>RuntimeErrorrOrrrNr,
r~rr/r/r/r0<00><module>
s\










$



















	>