<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title>Mako Documentation - Defs</title>
<link rel="stylesheet" href="docs.css"></link>
<link rel="stylesheet" href="highlight.css"></link>
</head>
<body>
<div id="topanchor"><a name="top"> </a></div>
<div id="pagecontrol"><a href="index.html">Multiple Pages</a> | <a href="documentation.html">One Page</a></div>
<h1>Mako Documentation</h1>
<div class="versionheader">Version: 0.2.4 Last Updated: 12/22/08 22:46:37</div>
<A name=""></a>
<div class="topnav">
<div class="toolbar">
<div class="prevnext">
Previous: <a href="syntax.html">Syntax</a>
|
Next: <a href="runtime.html">The Mako Runtime Environment</a>
</div>
<h3><a href="index.html">Table of Contents</a></h3>
</div>
<br/>
<a href="#defs">Defs</a>
<ul>
<li><A style="" href="defs.html#defs_remotedefs">Calling defs from Other Files</a></li>
<ul>
</ul>
<li><A style="" href="defs.html#defs_programmatic">Calling defs programmatically</a></li>
<ul>
</ul>
<li><A style="" href="defs.html#defs_nesteddefs">Defs within Defs</a></li>
<ul>
</ul>
<li><A style="" href="defs.html#defs_defswithcontent">Calling a def with embedded content and/or other defs</a></li>
<ul>
</ul>
</ul>
</div>
<A name="defs"></a>
<div class="section">
<h3>Defs</h3>
<p>The def is the single tag used to demarcate any block of text and/or code. It exists within generated Python as a callable function.
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"hello()"</span><span class="cp">></span>
hello world
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>They are normally called as expressions.
</p>
<div class="code">
<div class="highlight"><pre>the def: <span class="cp">${</span><span class="n">hello</span><span class="p">()</span><span class="cp">}</span>
</pre></div>
</div>
<p>If the <code><%def></code> is not nested inside of another <code><%def></code>, its known as a <strong>top level def</strong> and can be accessed anywhere in the template, including above where it was defined.
</p>
<p>All defs, top level or not, have access to the current contextual namespace in exactly the same way their containing template does. Suppose the template below is executed with the variables <code>username</code> and <code>accountdata</code> inside the context:
</p>
<div class="code">
<div class="highlight"><pre>Hello there <span class="cp">${</span><span class="n">username</span><span class="cp">}</span>, how are ya. Lets see what your account says:
<span class="cp">${</span><span class="n">account</span><span class="p">()</span><span class="cp">}</span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"account()"</span><span class="cp">></span>
Account for <span class="cp">${</span><span class="n">username</span><span class="cp">}</span>:<span class="nt"><br/></span>
<span class="cp">%</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">accountdata</span><span class="p">:</span>
Value: <span class="cp">${</span><span class="n">row</span><span class="cp">}</span><span class="nt"><br/></span>
<span class="cp">%</span><span class="k"> endfor</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>The <code>username</code> and <code>accountdata</code> variables are present within the main template body as well as the body of the <code>account()</code> def.
</p>
<p>Since defs are just Python functions, you can define and pass arguments to them as well:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp">${</span><span class="n">account</span><span class="p">(</span><span class="n">accountname</span><span class="o">=</span><span class="s">'john'</span><span class="p">)</span><span class="cp">}</span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"account(accountname, type='regular')"</span><span class="cp">></span>
account name: <span class="cp">${</span><span class="n">accountname</span><span class="cp">}</span>, type <span class="cp">${</span><span class="nb">type</span><span class="cp">}</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>When you declare an argument signature for your def, they are required following normal Python conventions (i.e., all arguments are required except keyword arguments with a default value). This is in contrast to using context-level variables, which evaluate to <code>UNDEFINED</code> if you reference a name that does not exist.
</p>
<A name="defs_remotedefs"></a>
<div class="subsection">
<h3>Calling defs from Other Files</h3>
<p>Top level <code><%defs></code> are <strong>exported</strong> by your template's module, and can be called from the outside; including from other templates, as well as normal Python code. Calling a <code><%def></code> from another template is something like using an <code><%include></code> - except you are calling a specific function within the template, not the whole template.
</p>
<p>The remote <code><%def></code> call is also a little bit like calling functions from other modules in Python. There is an "import" step to pull the names from another template into your own template; then the function or functions are available.
</p>
<p>To import another template, use the <code><%namespace></code> tag:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">namespace</span> <span class="na">name=</span><span class="s">"mystuff"</span> <span class="na">file=</span><span class="s">"mystuff.html"</span><span class="cp">/></span>
</pre></div>
</div>
<p>The above tag adds a local variable "mystuff" to the current scope.
</p>
<p>Then, just call the defs off of <code>mystuff</code>:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp">${</span><span class="n">mystuff</span><span class="o">.</span><span class="n">somedef</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mf">5</span><span class="p">,</span><span class="n">y</span><span class="o">=</span><span class="mf">7</span><span class="p">)</span><span class="cp">}</span>
</pre></div>
</div>
<p>The <code><%namespace></code> tag also supports some of the other semantics of Python's <code>import</code> statement, including pulling names into the local variable space, or using <code>*</code> to represent all names, using the <code>import</code> attribute:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">namespace</span> <span class="na">file=</span><span class="s">"mystuff.html"</span> <span class="na">import=</span><span class="s">"foo, bar"</span><span class="cp">/></span>
</pre></div>
</div>
<p>This is just a quick intro to the concept of a <strong>namespace</strong>, which is a central Mako concept that has its own chapter in these docs. For more detail and examples, see <a href="namespaces.html">Namespaces</a>.
</p>
<a href="#top">back to section top</a>
</div>
<A name="defs_programmatic"></a>
<div class="subsection">
<h3>Calling defs programmatically</h3>
<p>You can call def's programmatically from any <code>Template</code> object using the <code>get_def()</code> method, which returns a <code>DefTemplate</code> object. This is a <code>Template</code> subclass which the parent <code>Template</code> creates, and is usable like any other template:
</p>
<div class="code">
<div class="highlight"><pre><span class="kn">from</span> <span class="nn">mako.template</span> <span class="kn">import</span> <span class="n">Template</span>
<span class="n">template</span> <span class="o">=</span> <span class="n">Template</span><span class="p">(</span><span class="s">"""</span>
<span class="s"> <</span><span class="si">%d</span><span class="s">ef name="hi(name)"></span>
<span class="s"> hi ${name}!</span>
<span class="s"> </</span><span class="si">%d</span><span class="s">ef></span>
<span class="s"> <</span><span class="si">%d</span><span class="s">ef name="bye(name)"></span>
<span class="s"> bye ${name}!</span>
<span class="s"> </</span><span class="si">%d</span><span class="s">ef></span>
<span class="s">"""</span><span class="p">)</span>
<span class="k">print</span> <span class="n">template</span><span class="o">.</span><span class="n">get_def</span><span class="p">(</span><span class="s">"hi"</span><span class="p">)</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"ed"</span><span class="p">)</span>
<span class="k">print</span> <span class="n">template</span><span class="o">.</span><span class="n">get_def</span><span class="p">(</span><span class="s">"bye"</span><span class="p">)</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s">"ed"</span><span class="p">)</span>
</pre></div>
</div>
<a href="#top">back to section top</a>
</div>
<A name="defs_nesteddefs"></a>
<div class="subsection">
<h3>Defs within Defs</h3>
<p>The def model follows regular Python rules for closures. Declaring <code><%def></code> inside another <code><%def></code> declares it within the parent's <strong>enclosing scope</strong>:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"mydef()"</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"subdef()"</span><span class="cp">></span>
a sub def
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
im the def, and the subcomopnent is <span class="cp">${</span><span class="n">subdef</span><span class="p">()</span><span class="cp">}</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>Just like Python, names that exist outside the inner <code><%def></code> exist inside it as well:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span>
<span class="n">x</span> <span class="o">=</span> <span class="mf">12</span>
<span class="cp">%></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"outer()"</span><span class="cp">></span>
<span class="cp"><%</span>
<span class="n">y</span> <span class="o">=</span> <span class="mf">15</span>
<span class="cp">%></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"inner()"</span><span class="cp">></span>
inner, x is <span class="cp">${</span><span class="n">x</span><span class="cp">}</span>, y is <span class="cp">${</span><span class="n">y</span><span class="cp">}</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
outer, x is <span class="cp">${</span><span class="n">x</span><span class="cp">}</span>, y is <span class="cp">${</span><span class="n">y</span><span class="cp">}</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>Assigning to a name inside of a def declares that name as local to the scope of that def (again, like Python itself). This means the following code will raise an error:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span>
<span class="n">x</span> <span class="o">=</span> <span class="mf">10</span>
<span class="cp">%></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"somedef()"</span><span class="cp">></span>
<span class="cp">## error !</span>
somedef, x is <span class="cp">${</span><span class="n">x</span><span class="cp">}</span>
<span class="cp"><%</span>
<span class="n">x</span> <span class="o">=</span> <span class="mf">27</span>
<span class="cp">%></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
</pre></div>
</div>
<p>...because the assignment to <code>x</code> declares x as local to the scope of <code>somedef</code>, rendering the "outer" version unreachable in the expression that tries to render it.
</p>
<a href="#top">back to section top</a>
</div>
<A name="defs_defswithcontent"></a>
<div class="subsection">
<h3>Calling a def with embedded content and/or other defs</h3>
<p>A flip-side to def within def is a def call with content. This is where you call a def, and at the same time declare a block of content (or multiple blocks) that can be used by the def being called. The main point of such a call is to create custom, nestable tags, just like any other template language's custom-tag creation system - where the external tag controls the execution of the nested tags and can communicate state to them. Only with Mako, you don't have to use any external Python modules, you can define arbitrarily nestable tags right in your templates.
</p>
<p>To achieve this, the target def is invoked using the form <code><%namepacename:defname></code> instead of the normal <code>${}</code> syntax. This syntax, introduced in Mako 0.2.3, is functionally equivalent another tag known as <code>call</code>, which takes the form <code><%call expr='namespacename.defname(args)'></code>. While <code>%call</code> is available in all versions of Mako, the newer style is probably more familiar looking. The <code>namespace</code> portion of the call is the name of the <strong>namespace</strong> in which the def is defined - in the most simple cases, this can be <code>local</code> or <code>self</code> to reference the current template's namespace (the difference between <code>local</code> and <code>self</code> is one of inheritance - see <a href="namespaces.html#namespaces_builtin">Built-in Namespaces</a> for details).
</p>
<p>When the target def is invoked, a variable <code>caller</code> is placed in its context which contains another namespace containing the body and other defs defined by the caller. The body itself is referenced by the method <code>body()</code>. Below, we build a <code>%def</code> that operates upon <code>caller.body()</code> to invoke the body of the custom tag:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"buildtable()"</span><span class="cp">></span>
<span class="nt"><table></span>
<span class="nt"><tr><td></span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
<span class="nt"></td></tr></span>
<span class="nt"></table></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">self:buildtable</span><span class="cp">></span>
I am the table body.
<span class="cp"></%</span><span class="nb">self:buildtable</span><span class="cp">></span>
</pre></div>
</div>
<p>This produces the output (whitespace formatted):
</p>
<div class="code">
<div class="highlight"><pre><span class="nt"><table></span>
<span class="nt"><tr><td></span>
I am the table body.
<span class="nt"></td></tr></span>
<span class="nt"></table></span>
</pre></div>
</div>
<p>Using the older <code>%call</code> syntax looks like:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"buildtable()"</span><span class="cp">></span>
<span class="nt"><table></span>
<span class="nt"><tr><td></span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
<span class="nt"></td></tr></span>
<span class="nt"></table></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">call</span> <span class="na">expr=</span><span class="s">"buildtable()"</span><span class="cp">></span>
I am the table body.
<span class="cp"></%</span><span class="nb">call</span><span class="cp">></span>
</pre></div>
</div>
<p>The <code>body()</code> can be executed multiple times or not at all. This means you can use def-call-with-content to build iterators, conditionals, etc:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"lister(count)"</span><span class="cp">></span>
<span class="cp">%</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span><span class="n">count</span><span class="p">):</span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
<span class="cp">%</span><span class="k"> endfor</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">self:lister</span> <span class="na">count=</span><span class="s">"${3}"</span><span class="cp">></span>
hi
<span class="cp"></%</span><span class="nb">self:lister</span><span class="cp">></span>
</pre></div>
</div>
<p>Produces:
</p>
<div class="code">
<div class="highlight"><pre>hi
hi
hi
</pre></div>
</div>
<p>Notice above we pass <code>3</code> as a Python expression, so that it remains as an integer.
</p>
<p>A custom "conditional" tag:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"conditional(expression)"</span><span class="cp">></span>
<span class="cp">%</span> <span class="k">if</span> <span class="n">expression</span><span class="p">:</span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
<span class="cp">%</span><span class="k"> endif</span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">self:conditional</span> <span class="na">expression=</span><span class="s">"${4==4}"</span><span class="cp">></span>
im the result
<span class="cp"></%</span><span class="nb">self:conditional</span><span class="cp">></span>
</pre></div>
</div>
<p>Produces:
</p>
<div class="code">
<div class="highlight"><pre>im the result
</pre></div>
</div>
<p>But that's not all. The <code>body()</code> function also can handle arguments, which will augment the local namespace of the body callable. The caller must define the arguments which it expects to receive from its target def using the <code>args</code> attribute, which is a comma-separated list of argument names. Below, our <code><%def></code> calls the <code>body()</code> of its caller, passing in an element of data from its argument:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"layoutdata(somedata)"</span><span class="cp">></span>
<span class="nt"><table></span>
<span class="cp">%</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">somedata</span><span class="p">:</span>
<span class="nt"><tr></span>
<span class="cp">%</span> <span class="k">for</span> <span class="n">col</span> <span class="ow">in</span> <span class="n">item</span><span class="p">:</span>
<span class="nt"><td></span><span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">(</span><span class="n">col</span><span class="o">=</span><span class="n">col</span><span class="p">)</span><span class="cp">}</span><span class="nt"></td></span>
<span class="cp">%</span><span class="k"> endfor</span>
<span class="nt"></tr></span>
<span class="cp">%</span><span class="k"> endfor</span>
<span class="nt"></table></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">self:layoutdata</span> <span class="na">somedata=</span><span class="s">"${[[1,2,3],[4,5,6],[7,8,9]]}"</span> <span class="na">args=</span><span class="s">"col"</span><span class="cp">></span>\
Body data: <span class="cp">${</span><span class="n">col</span><span class="cp">}</span>\
<span class="cp"></%</span><span class="nb">self:layoutdata</span><span class="cp">></span>
</pre></div>
</div>
<p>Produces:
</p>
<div class="code">
<div class="highlight"><pre><span class="nt"><table></span>
<span class="nt"><tr></span>
<span class="nt"><td></span>Body data: 1<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 2<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 3<span class="nt"></td></span>
<span class="nt"></tr></span>
<span class="nt"><tr></span>
<span class="nt"><td></span>Body data: 4<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 5<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 6<span class="nt"></td></span>
<span class="nt"></tr></span>
<span class="nt"><tr></span>
<span class="nt"><td></span>Body data: 7<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 8<span class="nt"></td></span>
<span class="nt"><td></span>Body data: 9<span class="nt"></td></span>
<span class="nt"></tr></span>
<span class="nt"></table></span>
</pre></div>
</div>
<p>You don't have to stick to calling just the <code>body()</code> function. The caller can define any number of callables, allowing the <code><%call></code> tag to produce whole layouts:
</p>
<div class="code">
<div class="highlight"><pre><span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"layout()"</span><span class="cp">></span>
<span class="cp">## a layout def</span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"mainlayout"</span><span class="nt">></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"header"</span><span class="nt">></span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">header</span><span class="p">()</span><span class="cp">}</span>
<span class="nt"></div></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"sidebar"</span><span class="nt">></span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">sidebar</span><span class="p">()</span><span class="cp">}</span>
<span class="nt"></div></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"content"</span><span class="nt">></span>
<span class="cp">${</span><span class="n">caller</span><span class="o">.</span><span class="n">body</span><span class="p">()</span><span class="cp">}</span>
<span class="nt"></div></span>
<span class="nt"></div></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp">## calls the layout def</span>
<span class="cp"><%</span><span class="nb">self:layout</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"header()"</span><span class="cp">></span>
I am the header
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
<span class="cp"><%</span><span class="nb">def</span> <span class="na">name=</span><span class="s">"sidebar()"</span><span class="cp">></span>
<span class="nt"><ul></span>
<span class="nt"><li></span>sidebar 1<span class="nt"></li></span>
<span class="nt"><li></span>sidebar 2<span class="nt"></li></span>
<span class="nt"></ul></span>
<span class="cp"></%</span><span class="nb">def</span><span class="cp">></span>
this is the body
<span class="cp"></%</span><span class="nb">self:layout</span><span class="cp">></span>
</pre></div>
</div>
<p>The above layout would produce:
</p>
<div class="code">
<div class="highlight"><pre><span class="nt"><div</span> <span class="na">class=</span><span class="s">"mainlayout"</span><span class="nt">></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"header"</span><span class="nt">></span>
I am the header
<span class="nt"></div></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"sidebar"</span><span class="nt">></span>
<span class="nt"><ul></span>
<span class="nt"><li></span>sidebar 1<span class="nt"></li></span>
<span class="nt"><li></span>sidebar 2<span class="nt"></li></span>
<span class="nt"></ul></span>
<span class="nt"></div></span>
<span class="nt"><div</span> <span class="na">class=</span><span class="s">"content"</span><span class="nt">></span>
this is the body
<span class="nt"></div></span>
<span class="nt"></div></span>
</pre></div>
</div>
<p>The number of things you can do with <code><%call></code> and/or the <code><%namespacename:defname></code> calling syntax is enormous. You can create form widget libraries, such as an enclosing <code><FORM></code> tag and nested HTML input elements, or portable wrapping schemes using <code><div></code> or other elements. You can create tags that interpret rows of data, such as from a database, providing the individual columns of each row to a <code>body()</code> callable which lays out the row any way it wants. Basically anything you'd do with a "custom tag" or tag library in some other system, Mako provides via <code><%def></code>s and plain Python callables which are invoked via <code><%namespacename:defname></code> or <code><%call></code>.
</p>
</div>
<a href="#top">back to section top</a>
</div>
</html>
<div class="toolbar">
<div class="prevnext">
Previous: <a href="syntax.html">Syntax</a>
|
Next: <a href="runtime.html">The Mako Runtime Environment</a>
</div>
<h3><a href="index.html">Table of Contents</a></h3>
</div>
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5d5a53cfb1fc82fdbf1e3e9ea3253fa5
>
files
>
85
