59 lines
24 KiB
HTML
59 lines
24 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>Base.Cartesian · The Julia Language</title><script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
|
|
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
|
|
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
|
|
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
|
|
|
|
ga('create', 'UA-28835595-6', 'auto');
|
|
ga('send', 'pageview');
|
|
</script><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL=".."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="../assets/documenter.js"></script><script src="../siteinfo.js"></script><script src="../../versions.js"></script><link href="../assets/documenter.css" rel="stylesheet" type="text/css"/><link href="../assets/julia-manual.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><a href="../index.html"><img class="logo" src="../assets/logo.png" alt="The Julia Language logo"/></a><h1>The Julia Language</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="../search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="../index.html">Home</a></li><li><span class="toctext">Manual</span><ul><li><a class="toctext" href="../manual/introduction.html">Introduction</a></li><li><a class="toctext" href="../manual/getting-started.html">Getting Started</a></li><li><a class="toctext" href="../manual/variables.html">Variables</a></li><li><a class="toctext" href="../manual/integers-and-floating-point-numbers.html">Integers and Floating-Point Numbers</a></li><li><a class="toctext" href="../manual/mathematical-operations.html">Mathematical Operations and Elementary Functions</a></li><li><a class="toctext" href="../manual/complex-and-rational-numbers.html">Complex and Rational Numbers</a></li><li><a class="toctext" href="../manual/strings.html">Strings</a></li><li><a class="toctext" href="../manual/functions.html">Functions</a></li><li><a class="toctext" href="../manual/control-flow.html">Control Flow</a></li><li><a class="toctext" href="../manual/variables-and-scoping.html">Scope of Variables</a></li><li><a class="toctext" href="../manual/types.html">Types</a></li><li><a class="toctext" href="../manual/methods.html">Methods</a></li><li><a class="toctext" href="../manual/constructors.html">Constructors</a></li><li><a class="toctext" href="../manual/conversion-and-promotion.html">Conversion and Promotion</a></li><li><a class="toctext" href="../manual/interfaces.html">Interfaces</a></li><li><a class="toctext" href="../manual/modules.html">Modules</a></li><li><a class="toctext" href="../manual/documentation.html">Documentation</a></li><li><a class="toctext" href="../manual/metaprogramming.html">Metaprogramming</a></li><li><a class="toctext" href="../manual/arrays.html">Multi-dimensional Arrays</a></li><li><a class="toctext" href="../manual/linear-algebra.html">Linear algebra</a></li><li><a class="toctext" href="../manual/networking-and-streams.html">Networking and Streams</a></li><li><a class="toctext" href="../manual/parallel-computing.html">Parallel Computing</a></li><li><a class="toctext" href="../manual/dates.html">Date and DateTime</a></li><li><a class="toctext" href="../manual/interacting-with-julia.html">Interacting With Julia</a></li><li><a class="toctext" href="../manual/running-external-programs.html">Running External Programs</a></li><li><a class="toctext" href="../manual/calling-c-and-fortran-code.html">Calling C and Fortran Code</a></li><li><a class="toctext" href="../manual/handling-operating-system-variation.html">Handling Operating System Variation</a></li><li><a class="toctext" href="../manual/environment-variables.html">Environment Variables</a></li><li><a class="toctext" href="../manual/embedding.html">Embedding Julia</a></li><li><a class="toctext" href="../manual/packages.html">Packages</a></li><li><a class="toctext" href="../manual/profile.html">Profiling</a></li><li><a class="toctext" href="../manual/stacktraces.html">Stack Traces</a></li><li><a class="toctext" href="../manual/performance-tips.html">Performance Tips</a></li><li><a class="toctext" href="../manual/workflow-tips.html">Workflow Tips</a></li><li><a class="toctext" href="../manual/style-guide.html">Style Guide</a></li><li><a class="toctext" href="../manual/faq.html">Frequently Asked Questions</a></li><li><a class="toctext" href="../manual/noteworthy-differences.html">Noteworthy Differences from other Languages</a></li><li><a class="toctext" href="../manual/unicode-input.html">Unicode Input</a></li></ul></li><li><span class="toctext">Standard Library</span><ul><li><a class="toctext" href="../stdlib/base.html">Essentials</a></li><li><a class="toctext" href="../stdlib/collections.html">Collections and Data Structures</a></li><li><a class="toctext" href="../stdlib/math.html">Mathematics</a></li><li><a class="toctext" href="../stdlib/numbers.html">Numbers</a></li><li><a class="toctext" href="../stdlib/strings.html">Strings</a></li><li><a class="toctext" href="../stdlib/arrays.html">Arrays</a></li><li><a class="toctext" href="../stdlib/parallel.html">Tasks and Parallel Computing</a></li><li><a class="toctext" href="../stdlib/linalg.html">Linear Algebra</a></li><li><a class="toctext" href="../stdlib/constants.html">Constants</a></li><li><a class="toctext" href="../stdlib/file.html">Filesystem</a></li><li><a class="toctext" href="../stdlib/io-network.html">I/O and Network</a></li><li><a class="toctext" href="../stdlib/punctuation.html">Punctuation</a></li><li><a class="toctext" href="../stdlib/sort.html">Sorting and Related Functions</a></li><li><a class="toctext" href="../stdlib/pkg.html">Package Manager Functions</a></li><li><a class="toctext" href="../stdlib/dates.html">Dates and Time</a></li><li><a class="toctext" href="../stdlib/iterators.html">Iteration utilities</a></li><li><a class="toctext" href="../stdlib/test.html">Unit Testing</a></li><li><a class="toctext" href="../stdlib/c.html">C Interface</a></li><li><a class="toctext" href="../stdlib/libc.html">C Standard Library</a></li><li><a class="toctext" href="../stdlib/libdl.html">Dynamic Linker</a></li><li><a class="toctext" href="../stdlib/profile.html">Profiling</a></li><li><a class="toctext" href="../stdlib/stacktraces.html">StackTraces</a></li><li><a class="toctext" href="../stdlib/simd-types.html">SIMD Support</a></li></ul></li><li><span class="toctext">Developer Documentation</span><ul><li><a class="toctext" href="reflection.html">Reflection and introspection</a></li><li><span class="toctext">Documentation of Julia's Internals</span><ul><li><a class="toctext" href="init.html">Initialization of the Julia runtime</a></li><li><a class="toctext" href="ast.html">Julia ASTs</a></li><li><a class="toctext" href="types.html">More about types</a></li><li><a class="toctext" href="object.html">Memory layout of Julia Objects</a></li><li><a class="toctext" href="eval.html">Eval of Julia code</a></li><li><a class="toctext" href="callconv.html">Calling Conventions</a></li><li><a class="toctext" href="compiler.html">High-level Overview of the Native-Code Generation Process</a></li><li><a class="toctext" href="functions.html">Julia Functions</a></li><li class="current"><a class="toctext" href="cartesian.html">Base.Cartesian</a><ul class="internal"><li><a class="toctext" href="#Principles-of-usage-1">Principles of usage</a></li><li><a class="toctext" href="#Basic-syntax-1">Basic syntax</a></li></ul></li><li><a class="toctext" href="meta.html">Talking to the compiler (the <code>:meta</code> mechanism)</a></li><li><a class="toctext" href="subarrays.html">SubArrays</a></li><li><a class="toctext" href="sysimg.html">System Image Building</a></li><li><a class="toctext" href="llvm.html">Working with LLVM</a></li><li><a class="toctext" href="stdio.html">printf() and stdio in the Julia runtime</a></li><li><a class="toctext" href="boundscheck.html">Bounds checking</a></li><li><a class="toctext" href="locks.html">Proper maintenance and care of multi-threading locks</a></li><li><a class="toctext" href="offset-arrays.html">Arrays with custom indices</a></li><li><a class="toctext" href="libgit2.html">Base.LibGit2</a></li><li><a class="toctext" href="require.html">Module loading</a></li></ul></li><li><span class="toctext">Developing/debugging Julia's C code</span><ul><li><a class="toctext" href="backtraces.html">Reporting and analyzing crashes (segfaults)</a></li><li><a class="toctext" href="debuggingtips.html">gdb debugging tips</a></li><li><a class="toctext" href="valgrind.html">Using Valgrind with Julia</a></li><li><a class="toctext" href="sanitizers.html">Sanitizer support</a></li></ul></li></ul></li></ul></nav><article id="docs"><header><nav><ul><li>Developer Documentation</li><li>Documentation of Julia's Internals</li><li><a href="cartesian.html">Base.Cartesian</a></li></ul><a class="edit-page" href="https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/cartesian.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>Base.Cartesian</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Base.Cartesian-1" href="#Base.Cartesian-1">Base.Cartesian</a></h1><p>The (non-exported) Cartesian module provides macros that facilitate writing multidimensional algorithms. It is hoped that Cartesian will not, in the long term, be necessary; however, at present it is one of the few ways to write compact and performant multidimensional code.</p><h2><a class="nav-anchor" id="Principles-of-usage-1" href="#Principles-of-usage-1">Principles of usage</a></h2><p>A simple example of usage is:</p><pre><code class="language-julia">@nloops 3 i A begin
|
|
s += @nref 3 A i
|
|
end</code></pre><p>which generates the following code:</p><pre><code class="language-julia">for i_3 = 1:size(A,3)
|
|
for i_2 = 1:size(A,2)
|
|
for i_1 = 1:size(A,1)
|
|
s += A[i_1,i_2,i_3]
|
|
end
|
|
end
|
|
end</code></pre><p>In general, Cartesian allows you to write generic code that contains repetitive elements, like the nested loops in this example. Other applications include repeated expressions (e.g., loop unwinding) or creating function calls with variable numbers of arguments without using the "splat" construct (<code>i...</code>).</p><h2><a class="nav-anchor" id="Basic-syntax-1" href="#Basic-syntax-1">Basic syntax</a></h2><p>The (basic) syntax of <code>@nloops</code> is as follows:</p><ul><li><p>The first argument must be an integer (<em>not</em> a variable) specifying the number of loops.</p></li><li><p>The second argument is the symbol-prefix used for the iterator variable. Here we used <code>i</code>, and variables <code>i_1, i_2, i_3</code> were generated.</p></li><li><p>The third argument specifies the range for each iterator variable. If you use a variable (symbol) here, it's taken as <code>1:size(A,dim)</code>. More flexibly, you can use the anonymous-function expression syntax described below.</p></li><li><p>The last argument is the body of the loop. Here, that's what appears between the <code>begin...end</code>.</p></li></ul><p>There are some additional features of <code>@nloops</code> described in the <a href="cartesian.html#dev-cartesian-reference-1">reference section</a>.</p><p><code>@nref</code> follows a similar pattern, generating <code>A[i_1,i_2,i_3]</code> from <code>@nref 3 A i</code>. The general practice is to read from left to right, which is why <code>@nloops</code> is <code>@nloops 3 i A expr</code> (as in <code>for i_2 = 1:size(A,2)</code>, where <code>i_2</code> is to the left and the range is to the right) whereas <code>@nref</code> is <code>@nref 3 A i</code> (as in <code>A[i_1,i_2,i_3]</code>, where the array comes first).</p><p>If you're developing code with Cartesian, you may find that debugging is easier when you examine the generated code, using <code>macroexpand</code>:</p><pre><code class="language-julia-repl">julia> macroexpand(:(@nref 2 A i))
|
|
:(A[i_1, i_2])</code></pre><h3><a class="nav-anchor" id="Supplying-the-number-of-expressions-1" href="#Supplying-the-number-of-expressions-1">Supplying the number of expressions</a></h3><p>The first argument to both of these macros is the number of expressions, which must be an integer. When you're writing a function that you intend to work in multiple dimensions, this may not be something you want to hard-code. If you're writing code that you need to work with older Julia versions, currently you should use the <code>@ngenerate</code> macro described in <a href="https://docs.julialang.org/en/release-0.3/devdocs/cartesian/#supplying-the-number-of-expressions">an older version of this documentation</a>.</p><p>Starting in Julia 0.4-pre, the recommended approach is to use a <code>@generated function</code>. Here's an example:</p><pre><code class="language-julia">@generated function mysum(A::Array{T,N}) where {T,N}
|
|
quote
|
|
s = zero(T)
|
|
@nloops $N i A begin
|
|
s += @nref $N A i
|
|
end
|
|
s
|
|
end
|
|
end</code></pre><p>Naturally, you can also prepare expressions or perform calculations before the <code>quote</code> block.</p><h3><a class="nav-anchor" id="Anonymous-function-expressions-as-macro-arguments-1" href="#Anonymous-function-expressions-as-macro-arguments-1">Anonymous-function expressions as macro arguments</a></h3><p>Perhaps the single most powerful feature in <code>Cartesian</code> is the ability to supply anonymous-function expressions that get evaluated at parsing time. Let's consider a simple example:</p><pre><code class="language-julia">@nexprs 2 j->(i_j = 1)</code></pre><p><code>@nexprs</code> generates <code>n</code> expressions that follow a pattern. This code would generate the following statements:</p><pre><code class="language-julia">i_1 = 1
|
|
i_2 = 1</code></pre><p>In each generated statement, an "isolated" <code>j</code> (the variable of the anonymous function) gets replaced by values in the range <code>1:2</code>. Generally speaking, Cartesian employs a LaTeX-like syntax. This allows you to do math on the index <code>j</code>. Here's an example computing the strides of an array:</p><pre><code class="language-julia">s_1 = 1
|
|
@nexprs 3 j->(s_{j+1} = s_j * size(A, j))</code></pre><p>would generate expressions</p><pre><code class="language-julia">s_1 = 1
|
|
s_2 = s_1 * size(A, 1)
|
|
s_3 = s_2 * size(A, 2)
|
|
s_4 = s_3 * size(A, 3)</code></pre><p>Anonymous-function expressions have many uses in practice.</p><h4><a class="nav-anchor" id="dev-cartesian-reference-1" href="#dev-cartesian-reference-1">Macro reference</a></h4><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nloops" href="#Base.Cartesian.@nloops"><code>Base.Cartesian.@nloops</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nloops N itersym rangeexpr bodyexpr
|
|
@nloops N itersym rangeexpr preexpr bodyexpr
|
|
@nloops N itersym rangeexpr preexpr postexpr bodyexpr</code></pre><p>Generate <code>N</code> nested loops, using <code>itersym</code> as the prefix for the iteration variables. <code>rangeexpr</code> may be an anonymous-function expression, or a simple symbol <code>var</code> in which case the range is <code>indices(var, d)</code> for dimension <code>d</code>.</p><p>Optionally, you can provide "pre" and "post" expressions. These get executed first and last, respectively, in the body of each loop. For example:</p><pre><code class="language-none">@nloops 2 i A d -> j_d = min(i_d, 5) begin
|
|
s += @nref 2 A j
|
|
end</code></pre><p>would generate:</p><pre><code class="language-none">for i_2 = indices(A, 2)
|
|
j_2 = min(i_2, 5)
|
|
for i_1 = indices(A, 1)
|
|
j_1 = min(i_1, 5)
|
|
s += A[j_1, j_2]
|
|
end
|
|
end</code></pre><p>If you want just a post-expression, supply <code>nothing</code> for the pre-expression. Using parentheses and semicolons, you can supply multi-statement expressions.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L9-L37">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nref" href="#Base.Cartesian.@nref"><code>Base.Cartesian.@nref</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nref N A indexexpr</code></pre><p>Generate expressions like <code>A[i_1, i_2, ...]</code>. <code>indexexpr</code> can either be an iteration-symbol prefix, or an anonymous-function expression.</p><pre><code class="language-julia-repl">julia> @macroexpand Base.Cartesian.@nref 3 A i
|
|
:(A[i_1, i_2, i_3])</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L72-L82">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nextract" href="#Base.Cartesian.@nextract"><code>Base.Cartesian.@nextract</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nextract N esym isym</code></pre><p>Generate <code>N</code> variables <code>esym_1</code>, <code>esym_2</code>, ..., <code>esym_N</code> to extract values from <code>isym</code>. <code>isym</code> can be either a <code>Symbol</code> or anonymous-function expression.</p><p><code>@nextract 2 x y</code> would generate</p><pre><code class="language-none">x_1 = y[1]
|
|
x_2 = y[2]</code></pre><p>while <code>@nextract 3 x d->y[2d-1]</code> yields</p><pre><code class="language-none">x_1 = y[1]
|
|
x_2 = y[3]
|
|
x_3 = y[5]</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L142-L159">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nexprs" href="#Base.Cartesian.@nexprs"><code>Base.Cartesian.@nexprs</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nexprs N expr</code></pre><p>Generate <code>N</code> expressions. <code>expr</code> should be an anonymous-function expression.</p><pre><code class="language-julia-repl">julia> @macroexpand Base.Cartesian.@nexprs 4 i -> y[i] = A[i+j]
|
|
quote
|
|
y[1] = A[1 + j]
|
|
y[2] = A[2 + j]
|
|
y[3] = A[3 + j]
|
|
y[4] = A[4 + j]
|
|
end</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L118-L132">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@ncall" href="#Base.Cartesian.@ncall"><code>Base.Cartesian.@ncall</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@ncall N f sym...</code></pre><p>Generate a function call expression. <code>sym</code> represents any number of function arguments, the last of which may be an anonymous-function expression and is expanded into <code>N</code> arguments.</p><p>For example <code>@ncall 3 func a</code> generates</p><pre><code class="language-none">func(a_1, a_2, a_3)</code></pre><p>while <code>@ncall 2 func a b i->c[i]</code> yields</p><pre><code class="language-none">func(a, b, c[1], c[2])</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L92-L106">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@ntuple" href="#Base.Cartesian.@ntuple"><code>Base.Cartesian.@ntuple</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@ntuple N expr</code></pre><p>Generates an <code>N</code>-tuple. <code>@ntuple 2 i</code> would generate <code>(i_1, i_2)</code>, and <code>@ntuple 2 k->k+1</code> would generate <code>(2,3)</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L215-L220">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nall" href="#Base.Cartesian.@nall"><code>Base.Cartesian.@nall</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nall N expr</code></pre><p>Check whether all of the expressions generated by the anonymous-function expression <code>expr</code> evaluate to <code>true</code>.</p><p><code>@nall 3 d->(i_d > 1)</code> would generate the expression <code>(i_1 > 1 && i_2 > 1 && i_3 > 1)</code>. This can be convenient for bounds-checking.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L174-L182">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nany" href="#Base.Cartesian.@nany"><code>Base.Cartesian.@nany</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nany N expr</code></pre><p>Check whether any of the expressions generated by the anonymous-function expression <code>expr</code> evaluate to <code>true</code>.</p><p><code>@nany 3 d->(i_d > 1)</code> would generate the expression <code>(i_1 > 1 || i_2 > 1 || i_3 > 1)</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L195-L202">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Cartesian.@nif" href="#Base.Cartesian.@nif"><code>Base.Cartesian.@nif</code></a> — <span class="docstring-category">Macro</span>.</div><div><pre><code class="language-none">@nif N conditionexpr expr
|
|
@nif N conditionexpr expr elseexpr</code></pre><p>Generates a sequence of <code>if ... elseif ... else ... end</code> statements. For example:</p><pre><code class="language-none">@nif 3 d->(i_d >= size(A,d)) d->(error("Dimension ", d, " too big")) d->println("All OK")</code></pre><p>would generate:</p><pre><code class="language-none">if i_1 > size(A, 1)
|
|
error("Dimension ", 1, " too big")
|
|
elseif i_2 > size(A, 2)
|
|
error("Dimension ", 2, " too big")
|
|
else
|
|
println("All OK")
|
|
end</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/cartesian.jl#L230-L247">source</a></section><footer><hr/><a class="previous" href="functions.html"><span class="direction">Previous</span><span class="title">Julia Functions</span></a><a class="next" href="meta.html"><span class="direction">Next</span><span class="title">Talking to the compiler (the <code>:meta</code> mechanism)</span></a></footer></article></body></html>
|