<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">% \iffalse meta-comment
%
%  Copyright (C) 1994-2004   Peter Williams &lt;pwil3058@bigpond.net.au&gt;
%  Copyright (C) 2005-2009   Rogério Brito &lt;rbrito@ime.usp.br&gt;
%
% This document file is free software; you can redistribute it and/or
% modify it under the terms of the GNU Lesser General Public License as
% published by the Free Software Foundation; either version 2 of the
% License, or (at your option) any later version.
%
% This document file is distributed in the hope that it will be useful, but
% WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
% General Public License for more details.
%
% You should have received a copy of the GNU Lesser General Public License
% along with this document file; if not, write to the Free Software
% Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
% USA.
%
% \fi
%
% \iffalse
%&lt;algorithm&gt;\NeedsTeXFormat{LaTeX2e}[1999/12/01]
%&lt;algorithm&gt;\ProvidesPackage{algorithm}
%&lt;algorithm&gt;   [2009/08/24 v0.1 Document Style `algorithm' - floating environment]
%
%&lt;algorithmic&gt;\NeedsTeXFormat{LaTeX2e}[1999/12/01]
%&lt;algorithmic&gt;\ProvidesPackage{algorithmic}
%&lt;algorithmic&gt;   [2009/08/24 v0.1 Document Style `algorithmic']
%
%
%&lt;*driver&gt;
\documentclass{ltxdoc}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[sc]{mathpazo}
\usepackage[pdfstartview={FitH}]{hyperref}
\usepackage{algorithm}
\usepackage{algorithmic}
\usepackage{multicol}
\EnableCrossrefs
\CodelineIndex
\RecordChanges
\begin{document}
  \DocInput{algorithms.dtx}
\end{document}
%&lt;/driver&gt;
% \fi
%
%\CheckSum{0}
% \CharacterTable
% {Upper-case     \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
%   Lower-case    \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
%   Digits        \0\1\2\3\4\5\6\7\8\9
%   Exclamation   \!     Double quote  \"     Hash (number) \#
%   Dollar        \$     Percent       \%     Ampersand     \&amp;
%   Acute accent  \'     Left paren    \(     Right paren   \)
%   Asterisk      \*     Plus          \+     Comma         \,
%   Minus         \-     Point         \.     Solidus       \/
%   Colon         \:     Semicolon     \;     Less than     \&lt;
%   Equals        \=     Greater than  \&gt;     Question mark \?
%   Commercial at \@     Left bracket  \[     Backslash     \\
%   Right bracket \]     Circumflex    \^     Underscore    \_
%   Grave accent  \`     Left brace    \{     Vertical bar  \|
%   Right brace   \}     Tilde         \~}
%
% \changes{v0.1}{2009/08/24}{Migrated the package to .ins and .dtx format}
%
% \GetFileInfo{algorithm.sty}
% \GetFileInfo{algorithmic.sty}
% \DoNotIndex{\#,\$,\%,\&amp;,\@,\\,\{,\},\^,\_,\~,\ }
% \DoNotIndex{\@ne}
% \DoNotIndex{\advance,\begingroup,\catcode,\closein}
% \DoNotIndex{\closeout,\day,\def,\edef,\else,\empty,\endgroup}
%
% \title{The \textsf{algorithms} bundle\thanks{This document
%     corresponds to \textsf{algorithms}~\fileversion,
%     dated~\filedate.}}
% \author{Rogério Brito\\ \href{mailto:rbrito@ime.usp.br}{\texttt{rbrito@ime.usp.br}}}
%
% \newcommand{\keyword}[1]{\texttt{#1}}
% \newcommand{\nameoffile}[1]{\texttt{#1}}
%
% \setcounter{tocdepth}{2}
%
% \addtocontents{toc}{\protect\begin{multicols}{2}}
% \maketitle
% \tableofcontents
% \listofalgorithms
%
% % \newtheorem{warning}{Warning}
% \renewcommand{\thewarning}{}
%
% \section{Introduction}
%
% This package provides two environments, \keyword{algorithmic} and
% \keyword{algorithm}, which are designed to be used together but may,
% depending on the necessities of the user, be used separately.
%
% The \keyword{algorithmic} environment provides an environment for
% describing algorithms and the \keyword{algorithm} environment provides
% a ``float'' wrapper for algorithms (implemented using
% \keyword{algorithmic} or some other method at the users's option).
% The reason for two environments being provided is to allow the user
% maximum flexibility.
%
% This work may be distributed and/or modified under the conditions of
% the GNU Lesser General Public License, either version 2 of the
% License, or (at your option) any later version, as published by the
% Free Software Foundation. See the file \nameoffile{COPYING} included
% in this package for further details.
%
% Currently, this package consists of the following files:
% \begin{itemize}
%   \item \nameoffile{algorithms.ins}: the driver file
%   \item \nameoffile{algorithms.dtx}: the source file
%   \item \nameoffile{COPYING}: the license file
%   \item \nameoffile{README}: remarks about the package
%   \item \nameoffile{THANKS}: mentions of thanks for contributors to
%   the package
% \end{itemize}
%
% Starting with with the 2009-08-24 release, the package is now
% versioned and this document corresponds to version~\fileversion.
%
% If you use this package, the author would kindly appreciate if you
% mentioned it in your documents, so as to let the package be better
% known and have more contributors, to make it better for the community
% itself.  This is \emph{not} required by the license: it's just a
% friendly request.
%
%\section{Installation}
%
% The installation procedure of \textsf{algorithms} follows the usual
% practice of packages shipped with a pair of
% \nameoffile{.ins}/\nameoffile{.dtx}---simply type the comand:
% \begin{quote}
% \texttt{latex algorithms.ins}
% \end{quote}
% and the \nameoffile{.sty} files will be generated. Copy them to a
% place that is referenced by your \LaTeX{} distribution. To generate
% the documentation, type:
% \begin{quote}
% \texttt{latex algorithms.dtx}
% \end{quote}
%
% \section[Environment: \keyword{algorithmic}]%
% {The \keyword{algorithmic} Environment}
% \label{sec:algorithmic-envir}
% Within an \keyword{algorithmic} a number of commands for typesetting
% popular algorithmic constructs are available.  In general, the
% commands provided can be arbitrarily nested to describe quite complex
% algorithms.  An optional argument to the \verb+\begin{algorithmic}+
% statement can be used to turn on line numbering by giving a positive
% integer indicating the required frequency of line numbering.  For
% example, \verb+\begin{algorithmic}[5]+ would cause every fifth line
% to be numbered.
%
% \subsection{The Simple Statement}
%
% The simple statement takes the form
% \begin{verbatim}
%   \STATE &lt;text&gt;
% \end{verbatim}
% and is used for simple statements. For example,
% \begin{verbatim}
% \begin{algorithmic}
%   \STATE $S \leftarrow 0$
% \end{algorithmic}
% \end{verbatim}
% would produce
% \begin{algorithmic}
%   \STATE $S \leftarrow 0$
% \end{algorithmic}
% With line numbering selected for every line, using,
% \begin{verbatim}
% \begin{algorithmic}[1]
%   \STATE $S \leftarrow 0$
% \end{algorithmic}
% \end{verbatim}
% we would get
% \begin{algorithmic}[1]
%   \STATE $S \leftarrow 0$
% \end{algorithmic}
%
% \begin{warning}
%   For users of earlier versions of \keyword{algorithmic} this
%   construct is a cause of an incompatibility.  In the earlier version,
%   instead of starting simple statements with the \verb+\STATE+
%   command, simple statements were entered as free text and terminated
%   with \verb+\\+ command.  Unfortunately, this simpler method failed
%   to survive the modifications necessary for statement numbering.
%   However, the \verb+\\+ command can still be used to force a line
%   break within a simple statement.
% \end{warning}
%
%\subsection{The \emph{if-then-else} Statement}
%
% The \emph{if-then-else} construct takes the forms:
% \begin{verbatim}
% \IF{&lt;condition&gt;} &lt;text&gt; \ENDIF
% \IF{&lt;condition&gt;} &lt;text1&gt; \ELSE &lt;text2&gt; \ENDIF
% \IF{&lt;condition1&gt;} &lt;text1&gt; \ELSIF{&lt;condition2&gt;} &lt;text2&gt; \ELSE &lt;text3&gt; \ENDIF
% \end{verbatim}
%
% In the third of these forms there is no limit placed on the number of
% \verb+\ELSIF{&lt;condition&gt;}+ that may be used.  For example,
% \begin{verbatim}
% \begin{algorithmic}
% \IF{some condition is true}
% \STATE do some processing
% \ELSIF{some other condition is true}
% \STATE do some different processing
% \ELSIF{some even more bizarre condition is met}
% \STATE do something else
% \ELSE
% \STATE do the default actions
% \ENDIF
% \end{algorithmic}
% \end{verbatim}
% would produce
% \begin{algorithmic}
%   \IF{some condition is true}
%     \STATE do some processing
%   \ELSIF{some other condition is true}
%     \STATE do some different processing
%   \ELSIF{some even more bizarre condition is met}
%     \STATE do something else
%   \ELSE
%     \STATE do the default actions
%   \ENDIF
% \end{algorithmic}
% with appropriate indentations.
%
% \subsection{The \emph{for} Loop}
%
% The \emph{for} loop takes two forms. Namely:
% \begin{verbatim}
% \FOR{&lt;condition&gt;} &lt;text&gt; \ENDFOR
% \FORALL{&lt;condition&gt;} &lt;text&gt; \ENDFOR
% \end{verbatim}
%
% \noindent For example,
% \begin{verbatim}
% \begin{algorithmic}
% \FOR{$i=0$ to $10$}
% \STATE carry out some processing 
% \ENDFOR
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \FOR{$i=0$ to $10$}
%     \STATE carry out some processing 
%   \ENDFOR
% \end{algorithmic}
% and
% \begin{verbatim}
% \begin{algorithmic}[1]
% \FORALL{$i$ such that $0\leq i\leq 10$}
% \STATE carry out some processing 
% \ENDFOR
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}[1]
%   \FORALL{$i$ such that $0\leq i\leq 10$}
%     \STATE carry out some processing 
%   \ENDFOR
% \end{algorithmic}
%
% \subsubsection{The \emph{to} Connective}
% As may be clear from the usage of loops above, we usually want to
% specify ranges over which a variable will assume values. To help make
% this typographically distinct, the \keyword{algorithmic} package now
% supports the \algorithmicto{} connective, which can be used like:
% \begin{verbatim}
% \begin{algorithmic}
% \FOR{$i=0$ \TO $10$}
% \STATE carry out some processing 
% \ENDFOR
% \end{algorithmic}
% \end{verbatim}
% to produce the output
% \begin{algorithmic}
%   \FOR{$i=0$ \TO $10$}
%     \STATE carry out some processing 
%   \ENDFOR
% \end{algorithmic}
%
% \subsection{The \emph{while} Loop}
%
% The \emph{while} loop takes the form
% \begin{verbatim}
% \WHILE{&lt;condition&gt;} &lt;text&gt; \ENDWHILE
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \WHILE{some condition holds}
% \STATE carry out some processing 
% \ENDWHILE
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \WHILE{some condition holds}
%     \STATE carry out some processing 
%   \ENDWHILE
% \end{algorithmic}
%
% \subsection{The \emph{repeat-until} Loop}
%
% The \emph{repeat-until} loop takes the form.
% \begin{verbatim}
% \REPEAT &lt;text&gt; \UNTIL{&lt;condition&gt;}
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \REPEAT
% \STATE carry out some processing 
% \UNTIL{some condition is met}
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \REPEAT
%     \STATE carry out some processing 
%   \UNTIL{some condition is met}
% \end{algorithmic}
%
% \subsection{The Infinite Loop}
%
% The infinite loop takes the form.
% \begin{verbatim}
% \LOOP &lt;text&gt; \ENDLOOP
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \LOOP
% \STATE this processing will be repeated forever
% \ENDLOOP
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \LOOP
%     \STATE this processing will be repeated forever
%   \ENDLOOP
% \end{algorithmic}
%
% \subsection{The Logical Connectives}
%
% The connectives \algorithmicand, \algorithmicor, \algorithmicxor{} and
% \algorithmicnot{} can be used in boolean expressions in the familiar,
% expected way:
% \begin{verbatim}
% &lt;expression&gt; \AND &lt;expression&gt;
% &lt;expression&gt; \OR &lt;expression&gt;
% &lt;expression&gt; \XOR &lt;expression&gt;
% \NOT &lt;expression&gt;
% \end{verbatim}
% according to their arity.\footnote{But there is nothing that prevents
%   the user from violating the arity, from a syntatic point of view.}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \IF{\NOT ($year \bmod 400$ \XOR $year \bmod 100$ \XOR $year \bmod 4$)}
% \STATE $year$ does not represent a leap year.
% \ENDIF
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
% \IF{\NOT ($year \bmod 400$ \XOR $year \bmod 100$ \XOR $year \bmod 4$)}
% \STATE $year$ does not represent a leap year.
% \ENDIF
% \end{algorithmic}
%
% \subsection{The Precondition}
%
% The precondition (that must be met if an algorithm is to correctly
% execute) takes the form:
% \begin{verbatim}
% \REQUIRE &lt;text&gt;
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \REQUIRE $x \neq 0$ and $n \geq 0$
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \REQUIRE $x \neq 0$ and $n \geq 0$
% \end{algorithmic}
%
% \subsection{The Postcondition}
%
% The postcondition (that must be met after an algorithm has correctly
% executed) takes the form:
% \begin{verbatim}
% \ENSURE &lt;text&gt;
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \ENSURE $x \neq 0$ and $n \geq 0$
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \ENSURE $x \neq 0$ and $n \geq 0$
% \end{algorithmic}
%
% \subsection{Returning Values}
%
% The \keyword{algorithmic} environment offers a special statement for
% explicitly returning values in algorithms. It has the syntax:
% \begin{verbatim}
% \RETURN &lt;text&gt;
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \RETURN $(x+y)/2$
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \RETURN $(x+y)/2$
% \end{algorithmic}
%
%
% \subsubsection{The ``true'' and ``false'' Values}
%
% Since many algorithms have the necessity of returning \emph{true} or
% \emph{false} values, \keyword{algorithms}, starting with version
% 2006-06-02, includes the keywords \verb+\TRUE+ and \verb+\FALSE+,
% which are intented to print the values in a standard fashion, like the
% following snippet of an algorithm to decide if an integer $n$ is even or
% odd:
% \begin{verbatim}
% \begin{algorithmic}
%   \IF{$n$ is odd}
%      \RETURN \TRUE
%   \ELSE
%      \RETURN \FALSE
%   \ENDIF
% \end{algorithmic}
% \end{verbatim}
% The code above produces the following output:
% \begin{algorithmic}
%   \IF{$n$ is odd}
%      \RETURN \TRUE
%   \ELSE
%      \RETURN \FALSE
%   \ENDIF
% \end{algorithmic}
%
% \subsection{Printing Messages}
%
% Another feature of the \keyword{algorithmic} environment is that it
% currently provides a standard way of printing values (which is an
% operation used enough to merit its own keyword). It has the syntax:
% \begin{verbatim}
% \PRINT &lt;text&gt;
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \PRINT \texttt{``Hello, World!''}
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \PRINT \texttt{``Hello, World!''}
% \end{algorithmic}
%
% \subsection{Comments}
%
% Comments may be inserted at most points in an algorithm using the form:
% \begin{verbatim}
% \COMMENT{&lt;text&gt;}
% \end{verbatim}
% For example,
% \begin{verbatim}
% \begin{algorithmic}
% \STATE do something \COMMENT{this is a comment}
% \end{algorithmic}
% \end{verbatim}
% produces
% \begin{algorithmic}
%   \STATE do something \COMMENT{this is a comment}
% \end{algorithmic}
% Because the mechanisms used to build the various algorithmic structures
% make it difficult to use the above mechanism for placing comments at the
% end of the first line of a construct, the commands \verb+\IF+,
% \verb+\ELSIF+, \verb+\ELSE+, \verb+\WHILE+, \verb+\FOR+, \verb+\FORALL+,
% \verb+\REPEAT+ and \verb+\LOOP+ all take an optional argument which will
% be treated as a comment to be placed at the end of the line on which
% they appear.  For example,
% \begin{algorithmic}
%   \REPEAT[this is comment number one]
%     \IF[this is comment number two]{condition one is met}
%   \STATE do something
%     \ELSIF[this is comment number three]{condition two is met}
%   \STATE do something else
%     \ELSE[this is comment number four]
%   \STATE do nothing
%     \ENDIF
%   \UNTIL{hell freezes over}
% \end{algorithmic}
%
% \subsection{An Example}
%
% The following example demonstrates the use of the \keyword{algorithmic}
% environment to describe a complete algorithm.  The following input
% \begin{verbatim}
% \begin{algorithmic}
% \REQUIRE $n \geq 0$
% \ENSURE $y = x^n$
% \STATE $y \leftarrow 1$
% \STATE $X \leftarrow x$
% \STATE $N \leftarrow n$
% \WHILE{$N \neq 0$}
% \IF{$N$ is even}
% \STATE $X \leftarrow X \times X$
% \STATE $N \leftarrow N / 2$
% \ELSE[$N$ is odd]
% \STATE $y \leftarrow y \times X$
% \STATE $N \leftarrow N - 1$
% \ENDIF
% \ENDWHILE
% \end{algorithmic}
% \end{verbatim}
% will produce
% \begin{algorithmic}
%   \REQUIRE $n \geq 0$
%   \ENSURE $y = x^n$
%
%   \STATE $y \leftarrow 1$
%   \STATE $X \leftarrow x$
%   \STATE $N \leftarrow n$
%   \WHILE{$N \neq 0$}
%     \IF{$N$ is even}
%       \STATE $X \leftarrow X \times X$
%       \STATE $N \leftarrow N / 2$
%     \ELSE[$N$ is odd]
%       \STATE $y \leftarrow y \times X$
%       \STATE $N \leftarrow N - 1$
%     \ENDIF
%   \ENDWHILE
% \end{algorithmic}
% which is an algorithm for finding the value of a number taken to a
% non-negative power.
%
% \subsection[Options/Customization]%
% {Options and Customization}
%
% There is a single option, \keyword{noend}\label{kwd:noend} that may be
% invoked when the \texttt{algorithmic} package is loaded.  With this
% option invoked the \emph{end} statements are omitted in the output.
% This allows space to be saved in the output document when this is an
% issue.
%
% \subsubsection{Changing Indentation}
% \label{sec:changing-indentation}
% In the spirit of saving vertical space (which is especially important
% when submitting a paper for a journal, where space is frequently limited
% for authors), the \keyword{algorithmic} environment offers, beginning
% with the version released in 2005-05-08, a way to control the amount of
% indentation that is used by a given algorithm.
%
% The amount of indentation to be used is given by the command
% \begin{verbatim}
% \algsetup{indent=lenght}
% \end{verbatim}
% where \emph{length} is any valid length used by \TeX. The default value
% of the indentation used by the \keyword{algorithmic} environment is $1$
% em (for ``backward compatibility reasons''), but a value of $2$ em or
% more is recommended, depending on the publication. For example, the
% snippet
% \begin{verbatim}
% \algsetup{indent=2em}
% \begin{algorithmic}[1]
%   \STATE $a \leftarrow 1$
%   \IF{$a$ is even}
%   \PRINT ``$a$ is even''
%   \ELSE
%   \PRINT ``$a$ is odd''
% \end{algorithmic}
% \end{verbatim}
% produces
% \algsetup{indent=2em}
% \begin{algorithmic}[1]
%   \STATE $a \leftarrow 1$
%   \IF{$a$ is even}
%     \PRINT ``$a$ is even''
%   \ELSE
%     \PRINT ``$a$ is odd''
%   \ENDIF
% \end{algorithmic}
% while
% \begin{verbatim}
% \algsetup{indent=5em}
% \begin{algorithmic}[1]
%   \STATE $a \leftarrow 1$
%   \IF{$a$ is even}
%   \PRINT ``$a$ is even''
%   \ELSE
%   \PRINT ``$a$ is odd''
% \end{algorithmic}
% \end{verbatim}
% would produce
% \algsetup{indent=5em}
% \begin{algorithmic}[1]
%   \STATE $a \leftarrow 1$
%   \IF{$a$ is even}
%     \PRINT ``$a$ is even''
%   \ELSE
%     \PRINT ``$a$ is odd''
%   \ENDIF
% \end{algorithmic}
% \algsetup{indent=1em}
%
% The intended use of this option is to allow the author to omit the
% \emph{end} (see Section~\ref{kwd:noend} for details) statements without
% loosing readability, by increasing the amount of indentation to a
% suitable level.
%
% \subsubsection{Changing Line Numbering}
%
% As mentioned in Section~\ref{sec:algorithmic-envir} and illustrated in
% Section~\ref{sec:changing-indentation}, \keyword{algorithms} already
% provides you with the possibility of numbering lines.
%
% Starting with the version released in 2005-07-05, you can now change two
% aspects of line numbering: the size of the line numbers (which, by
% default, is \verb+\footnotesize+) and the delimiter used to separate the
% line number from the code (which, by default, is \verb+:+, i.e., a
% colon).
%
% You can change the size of the line numbers using the command:
% \begin{verbatim}
% \algsetup{linenosize=size}
% \end{verbatim}
% where \emph{size} is any of the various commands provided by \LaTeX\ to
% change the size of the font to be used. Among others, useful values are
% \verb+\tiny+, \verb+\scriptsize+, \verb+\footnotesize+ and
% \verb+\small+.  Please see the complete list of sizes in your \LaTeX\
% documentation.
%
% As another frequently requested feature, you can change the delimiter
% used with the line numbers by issuing the command:
% \begin{verbatim}
% \algsetup{linenodelimiter=delimiter}
% \end{verbatim}
% where \emph{delimiter} is any ``well-formed'' string, including the
% empty string. With this command, you can change the colon to a period
% (\verb+.+) by issuing the command
% \begin{verbatim}
% \algsetup{linenodelimiter=.}
% \end{verbatim}
% or even omit the delimiter, by specifying the empty string or a space
% (\verb+\ +), whatever seems best for your document.
%
% As an example of such commands, the code produced by
% \begin{verbatim}
% \algsetup{
%    linenosize=\small,
%    linenodelimiter=.
% }
% \begin{algorithmic}[1]
%    \STATE $i \leftarrow 10$
%    \RETURN $i$ 
% \end{algorithmic}
% \end{verbatim}
% would be something like
%
% \algsetup{
%   linenosize=\small,
%   linenodelimiter=.
% }
% \begin{algorithmic}[1]
%    \STATE $i \leftarrow 10$
%    \RETURN $i$
% \end{algorithmic}
% \algsetup{linenosize=\footnotesize,
%           linenodelimiter=:}
%
% \subsubsection{Customization}
%
% In order to facilitate the use of this package with foreign languages,
% all of the words in the output are produced via redefinable macro
% commands.  The default definitions of these macros are:
% \begin{verbatim}
% \newcommand{\algorithmicrequire}{\textbf{Require:}}
% \newcommand{\algorithmicensure}{\textbf{Ensure:}}
% \newcommand{\algorithmicend}{\textbf{end}}
% \newcommand{\algorithmicif}{\textbf{if}}
% \newcommand{\algorithmicthen}{\textbf{then}}
% \newcommand{\algorithmicelse}{\textbf{else}}
% \newcommand{\algorithmicelsif}{\algorithmicelse\ \algorithmicif}
% \newcommand{\algorithmicendif}{\algorithmicend\ \algorithmicif}
% \newcommand{\algorithmicfor}{\textbf{for}}
% \newcommand{\algorithmicforall}{\textbf{for all}}
% \newcommand{\algorithmicdo}{\textbf{do}}
% \newcommand{\algorithmicendfor}{\algorithmicend\ \algorithmicfor}
% \newcommand{\algorithmicwhile}{\textbf{while}}
% \newcommand{\algorithmicendwhile}{\algorithmicend\ \algorithmicwhile}
% \newcommand{\algorithmicloop}{\textbf{loop}}
% \newcommand{\algorithmicendloop}{\algorithmicend\ \algorithmicloop}
% \newcommand{\algorithmicrepeat}{\textbf{repeat}}
% \newcommand{\algorithmicuntil}{\textbf{until}}
% \newcommand{\algorithmicprint}{\textbf{print}}
% \newcommand{\algorithmicreturn}{\textbf{return}}
% \newcommand{\algorithmictrue}{\textbf{true}}
% \newcommand{\algorithmicfalse}{\textbf{false}}
% \end{verbatim}
%
% If you would like to change the definition of these commands to another
% content, then you should use, in your own document, the standard
% \LaTeX{} command \keyword{renewcommand}, with an usage like this:
% \begin{verbatim}
% \renewcommand{\algorithmicrequire}{\textbf{Input:}}
% \renewcommand{\algorithmicensure}{\textbf{Output:}}
% \end{verbatim}
%
% \paragraph{About the Way Comments Are Formatted}
%
% The formatting of comments is implemented via a single argument command
% macro which may also be redefined.  The default definition is
% \begin{verbatim}
% \newcommand{\algorithmiccomment}[1]{\{#1\}}
% \end{verbatim}
% and another option that may be interesting for users familiar with
% C-like languages is to redefine the comments to be
% \begin{verbatim}
% \renewcommand{\algorithmiccomment}[1]{// #1}
% \end{verbatim}
% Comments produced this way would be like this:
% \renewcommand{\algorithmiccomment}[1]{// #1}
% \begin{algorithmic}
%   \STATE $i \leftarrow i + 1$ \COMMENT{Increments $i$}
% \end{algorithmic}
% This second way to present comments may become the default in a future
% version of this package.
%
% \section[Environment: \keyword{algorithm}]%
% {The \keyword{algorithm} Environment}
%
% \subsection{General}
%
% When placed within the text without being encapsulated in a floating
% environment \texttt{algorithmic} environments may be split over a page
% boundary, greatly detracting from their appearance.\footnote{This is the
%   expected behaviour for floats in \LaTeX. If you don't care about
%   having your algorithm split between pages, then one option that you
%   have is to ignore the \texttt{algorithm} environment.} In addition, it
% is useful to have algorithms numbered for reference and for lists of
% algorithms to be appended to the list of contents.  The
% \texttt{algorithm} environment is meant to address these concerns by
% providing a floating environment for algorithms.
%
% \subsection{An Example}
% To illustrate the use of the \texttt{algorithm} environment, the
% following text
% \begin{verbatim}
% \begin{algorithm}
% \caption{Calculate $y = x^n$}
% \label{alg1}
% \begin{algorithmic}
% \REQUIRE $n \geq 0 \vee x \neq 0$
% \ENSURE $y = x^n$
% \STATE $y \leftarrow 1$
% \IF{$n &lt; 0$}
% \STATE $X \leftarrow 1 / x$
% \STATE $N \leftarrow -n$
% \ELSE
% \STATE $X \leftarrow x$
% \STATE $N \leftarrow n$
% \ENDIF
% \WHILE{$N \neq 0$}
% \IF{$N$ is even}
% \STATE $X \leftarrow X \times X$
% \STATE $N \leftarrow N / 2$
% \ELSE[$N$ is odd]
% \STATE $y \leftarrow y \times X$
% \STATE $N \leftarrow N - 1$
% \ENDIF
% \ENDWHILE
% \end{algorithmic}
% \end{algorithm}
% \end{verbatim}
% produces Algorithm~\ref{alg1} which is a slightly modified version of
% the earlier algorithm for determining the value of a number taken to an
% integer power.  In this case, provided the power may be negative
% provided the number is not zero.
%
% \begin{algorithm}[H]
%   \caption{Calculate $y = x^n$}
%   \label{alg1}
%   \begin{algorithmic}
%     \REQUIRE $n \geq 0 \vee x \neq 0$
%     \ENSURE $y = x^n$
%
%     \STATE $y \leftarrow 1$
%     \IF{$n &lt; 0$}
%        \STATE $X \leftarrow 1 / x$
%        \STATE $N \leftarrow -n$
%     \ELSE
%        \STATE $X \leftarrow x$
%        \STATE $N \leftarrow n$
%     \ENDIF
%
%     \WHILE{$N \neq 0$}
%       \IF{$N$ is even}
%         \STATE $X \leftarrow X \times X$
%         \STATE $N \leftarrow N / 2$
%       \ELSE[$N$ is odd]
%         \STATE $y \leftarrow y \times X$
%         \STATE $N \leftarrow N - 1$
%       \ENDIF
%     \ENDWHILE
%   \end{algorithmic}
% \end{algorithm}
%
% The command \verb+\listofalgorithms+ may be used to produce a list of
% algorithms as part of the table contents as shown at the beginning of
% this document.  An auxiliary file with a suffix of \texttt{.loa} is
% produced when this feature is used.
%
% \subsection{Options}
%
% The appearance of the typeset algorithm may be changed by use of the
% options: \texttt{plain}, \texttt{boxed} or \texttt{ruled} during the
% loading of the \texttt{algorithm} package.  The default option is
% \texttt{ruled}.
%
% The numbering of algorithms can be influenced by providing the name of
% the document component within which numbering should be recommenced.
% The legal values for this option are: \texttt{part}, \texttt{chapter},
% \texttt{section}, \texttt{subsection}, \texttt{subsubsection} or
% \texttt{nothing}.  The default value is \texttt{nothing} which causes
% algorithms to be numbered sequentially throughout the document.
%
% \subsection{Customization}
%
% In order to facilitate the use of this package with foreign languages,
% methods have been provided to facilitate the necessary modifications.
%
% The title used in the caption within \texttt{algorithm} environment can
% be set by use of the standard \verb+\floatname+ command which is
% provided as part of the \texttt{float} package which was used to
% implement this package.  For example,
% \begin{verbatim}
% \floatname{algorithm}{Procedure}
% \end{verbatim}
% would cause \textbf{Procedure} to be used instead of \textbf{Algorithm}
% within the caption of algorithms.
%
% In a manner analogous to that available for the built in floating
% environments, the heading used for the list of algorithms may be changed
% by redefining the command \verb+listalgorithmname+.  The default
% definition for this command is
% \begin{verbatim}
% \newcommand{\listalgorithmname}{List of Algorithms}
% \end{verbatim}
%
% \subsubsection{Placement of Algorithms}
%
% One important fact that many users may not have noticed is that the
% \texttt{algorithm} environment is actually built with the \texttt{float}
% package and \texttt{float}, in turn, uses David Carlisle's \textsf{here}
% style option. This means that the floats generated by the
% \texttt{algorithm} environment accept a special option, namely,
% \textbf{[H]}, with a capital `H', instead of the usual `h' offered by
% plain \LaTeX.
%
% This option works as a stronger request of ``please put the float
% here'': instead of just a suggestion for \LaTeX, it actually means ``put
% this float HERE'', which is something desired by many. The two
% algorithms typeset in this document use this option.
%
% \medskip
% \begin{warning}
%   You \emph{can't} use the `H' positioning option together with the
%   usual `h' (for ``here''), `b' (for ``bottom'') etc. This is a
%   limitation (as far as I know) of the \texttt{float.sty} package.
% \end{warning}
%
% \section[References in Algorithms]%
% {Labels and References in Algorithms}
%
% With the release of 2005-07-05, now \keyword{algorithmic} accepts labels
% and references to specific lines of a given algorithm, so you don't have
% to hardcode the line numbers yourself when trying to explain what the
% code does in your texts.  Thanks to Arnaud Legrand for the suggestion
% and patch for this highly missed feature.
%
% An example of its use is shown in Algorithm~\ref{alg2}.
% \begin{algorithm}[H]
%   \caption{Calculate $y = x^n$}
%   \label{alg2}
%   \begin{algorithmic}[1]
%     \REQUIRE $n \geq 0 \vee x \neq 0$
%     \ENSURE $y = x^n$
%     \STATE $y \leftarrow 1$
%     \IF{$n &lt; 0$}
%     \STATE $X \leftarrow 1 / x$
%     \STATE $N \leftarrow -n$
%     \ELSE
%     \STATE $X \leftarrow x$
%     \STATE $N \leftarrow n$
%     \ENDIF
%     \WHILE{$N \neq 0$}
%     \IF{$N$ is even}\label{alg:n-is-even}
%     \STATE $X \leftarrow X \times X$
%     \STATE $N \leftarrow N / 2$
%     \ELSE\label{alg:n-is-odd}
%     \STATE $y \leftarrow y \times X$
%     \STATE $N \leftarrow N - 1$
%     \ENDIF
%     \ENDWHILE
%   \end{algorithmic}
% \end{algorithm}
% See that, in line~\ref{alg:n-is-even}, we deal with the case of $N$
% being even, while, in line~\ref{alg:n-is-odd}, we give treatment to the
% case of $N$ being odd. The numbers you see on this document were
% generated automatically from the source document.
%
%
% \section[Known Issues]{Issues Between \texttt{algorithms} and
%   \href{http://www.ctan.org/tex-archive/help/Catalogue/entries/tocbibind.html}{\texttt{tocbibind}}
%   or \href{http://www.ctan.org/tex-archive/help/Catalogue/entries/memoir.html}{\texttt{memoir}}}
%
% It
% \href{http://groups.google.com/group/comp.text.tex/browse_thread/thread/4094e0c4f4fbd83e/a80a3f4666c794f0?fwc=1}{has
%   been discussed} in late 2005 that \texttt{algorithms} may have bad
% interactions with the
% \href{http://www.ctan.org/tex-archive/help/Catalogue/entries/tocbibind.html}{\texttt{tocbibind}}
% or the
% \href{http://www.ctan.org/tex-archive/help/Catalogue/entries/memoir.html}{\texttt{memoir}}
% package (which includes \texttt{tocbibind}).
%
% A workaround has been suggested for the problem. After including
% something like
% \begin{verbatim}
% \usepackage[nottoc]{tocbibind}
% \end{verbatim}
% in the preamble of your document, you can put, after
% \verb+\begin{document}+, the following snippet of code:
% \begin{verbatim}
% \renewcommand{\listofalgorithms}{\begingroup
%   \tocfile{List of Algorithms}{loa}
% \endgroup}
%
% \makeatletter
% \let\l@algorithm\l@figure
% \makeatother
% \end{verbatim}
% which should make the command \verb+\listofalgorithms+ work as expected.
%
% \section[General Hints]{Hints for Typesetting Algorithms}
%
% Here are some short hints on typesetting algorithms:
% \begin{itemize}
%   \item Don't overcomment your pseudo-code. If you feel that you need to
%   comment too much, then you are probably doing something wrong: you should
%   probably detail the inner workings of the algorithm in regular text
%   rather than in the pseudo-code;
%   \item Similarly, don't regard pseudo-code as a low-level programming
%   language: \emph{don't pollute your algorithms} with punctuation marks
%   like semi-colons, which are necessary in C, C++ and Java, but not in
%   pseudo-code. Remember: your readers \emph{are not} compilers;
%   \item Always document what the algorithm receives as an input and what it
%   returns as a solution. Don't care to say in the \verb+\REQUIRE+ or in the
%   \verb+\ENSURE+ commands \emph{how} the algorithm does what it does. Put
%   this in the regular text of your book/paper/lecture notes;
%   \item If you feel that your pseudo-code is getting too big, just break it
%   into sub-algorithms, perhaps abstracting some tasks. Your readers will
%   probably thank you.
% \end{itemize}
%
% Of course, you should follow those hints with common sense. Well, anything
% should be done with common sense.
%
% \addtocontents{toc}{\protect\end{multicols}}
% \end{document}
%
%\StopEventually{}
%&lt;algorithm&gt;\RequirePackage{float}
%&lt;algorithm&gt;\RequirePackage{ifthen}
%&lt;algorithm&gt;\newcommand{\ALG@within}{nothing}
%&lt;algorithm&gt;\newboolean{ALG@within}
%&lt;algorithm&gt;\setboolean{ALG@within}{false}
%&lt;algorithm&gt;\newcommand{\ALG@floatstyle}{ruled}
%&lt;algorithm&gt;\newcommand{\ALG@name}{Algorithm}
%&lt;algorithm&gt;\newcommand{\listalgorithmname}{List of \ALG@name s}
%
%&lt;algorithm&gt;% Declare Options:
%&lt;algorithm&gt;% * first: appearance
%&lt;algorithm&gt;\DeclareOption{plain}{
%&lt;algorithm&gt;  \renewcommand{\ALG@floatstyle}{plain}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{ruled}{
%&lt;algorithm&gt;  \renewcommand{\ALG@floatstyle}{ruled}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{boxed}{
%&lt;algorithm&gt;  \renewcommand{\ALG@floatstyle}{boxed}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;% * then: numbering convention
%&lt;algorithm&gt;\DeclareOption{part}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{part}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{chapter}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{chapter}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{section}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{section}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{subsection}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{subsection}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{subsubsection}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{subsubsection}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption{nothing}{
%&lt;algorithm&gt;  \renewcommand{\ALG@within}{nothing}
%&lt;algorithm&gt;  \setboolean{ALG@within}{true}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\DeclareOption*{\edef\ALG@name{\CurrentOption}}
%
%&lt;algorithm&gt;% ALGORITHM
%&lt;algorithm&gt;%
%&lt;algorithm&gt;\ProcessOptions
%&lt;algorithm&gt;\floatstyle{\ALG@floatstyle}
%&lt;algorithm&gt;\ifthenelse{\boolean{ALG@within}}{
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{part}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}[part]}{}
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{chapter}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}[chapter]}{}
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{section}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}[section]}{}
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{subsection}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}[subsection]}{}
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{subsubsection}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}[subsubsection]}{}
%&lt;algorithm&gt;  \ifthenelse{\equal{\ALG@within}{nothing}}
%&lt;algorithm&gt;     {\newfloat{algorithm}{htbp}{loa}}{}
%&lt;algorithm&gt;}{
%&lt;algorithm&gt;  \newfloat{algorithm}{htbp}{loa}
%&lt;algorithm&gt;}
%&lt;algorithm&gt;\floatname{algorithm}{\ALG@name}
%
%&lt;algorithm&gt;\newcommand{\listofalgorithms}{\listof{algorithm}{\listalgorithmname}}
%
%
%&lt;algorithmic&gt;% The algorithmic.sty package:
%
%&lt;algorithmic&gt;\RequirePackage{ifthen}
%&lt;algorithmic&gt;\RequirePackage{keyval}
%&lt;algorithmic&gt;\newboolean{ALC@noend}
%&lt;algorithmic&gt;\setboolean{ALC@noend}{false}
%&lt;algorithmic&gt;\newcounter{ALC@unique}    % new counter to make lines numbers be internally
%&lt;algorithmic&gt;\setcounter{ALC@unique}{0} % different in different algorithms
%&lt;algorithmic&gt;\newcounter{ALC@line}      % counter for current line
%&lt;algorithmic&gt;\newcounter{ALC@rem}       % counter for lines not printed
%&lt;algorithmic&gt;\newcounter{ALC@depth}
%&lt;algorithmic&gt;\newlength{\ALC@tlm}
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;\DeclareOption{noend}{\setboolean{ALC@noend}{true}}
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;\ProcessOptions
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;% For keyval-style options
%&lt;algorithmic&gt;\def\algsetup{\setkeys{ALG}}
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;% For indentation of algorithms
%&lt;algorithmic&gt;\newlength{\algorithmicindent}
%&lt;algorithmic&gt;\setlength{\algorithmicindent}{0pt}
%&lt;algorithmic&gt;\define@key{ALG}{indent}{\setlength{\algorithmicindent}{#1}}
%&lt;algorithmic&gt;\ifthenelse{\lengthtest{\algorithmicindent=0pt}}%
%&lt;algorithmic&gt;        {\setlength{\algorithmicindent}{1em}}{}
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;% For line numbers' delimiters
%&lt;algorithmic&gt;\newcommand{\ALC@linenodelimiter}{:}
%&lt;algorithmic&gt;\define@key{ALG}{linenodelimiter}{\renewcommand{\ALC@linenodelimiter}{#1}}
%
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;% For line numbers' size
%&lt;algorithmic&gt;\newcommand{\ALC@linenosize}{\footnotesize}
%&lt;algorithmic&gt;\define@key{ALG}{linenosize}{\renewcommand{\ALC@linenosize}{#1}}
%
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;% ALGORITHMIC
%&lt;algorithmic&gt;\newcommand{\algorithmicrequire}{\textbf{Require:}}
%&lt;algorithmic&gt;\newcommand{\algorithmicensure}{\textbf{Ensure:}}
%&lt;algorithmic&gt;\newcommand{\algorithmiccomment}[1]{\{#1\}}
%&lt;algorithmic&gt;\newcommand{\algorithmicend}{\textbf{end}}
%&lt;algorithmic&gt;\newcommand{\algorithmicif}{\textbf{if}}
%&lt;algorithmic&gt;\newcommand{\algorithmicthen}{\textbf{then}}
%&lt;algorithmic&gt;\newcommand{\algorithmicelse}{\textbf{else}}
%&lt;algorithmic&gt;\newcommand{\algorithmicelsif}{\algorithmicelse\ \algorithmicif}
%&lt;algorithmic&gt;\newcommand{\algorithmicendif}{\algorithmicend\ \algorithmicif}
%&lt;algorithmic&gt;\newcommand{\algorithmicfor}{\textbf{for}}
%&lt;algorithmic&gt;\newcommand{\algorithmicforall}{\textbf{for all}}
%&lt;algorithmic&gt;\newcommand{\algorithmicdo}{\textbf{do}}
%&lt;algorithmic&gt;\newcommand{\algorithmicendfor}{\algorithmicend\ \algorithmicfor}
%&lt;algorithmic&gt;\newcommand{\algorithmicwhile}{\textbf{while}}
%&lt;algorithmic&gt;\newcommand{\algorithmicendwhile}{\algorithmicend\ \algorithmicwhile}
%&lt;algorithmic&gt;\newcommand{\algorithmicloop}{\textbf{loop}}
%&lt;algorithmic&gt;\newcommand{\algorithmicendloop}{\algorithmicend\ \algorithmicloop}
%&lt;algorithmic&gt;\newcommand{\algorithmicrepeat}{\textbf{repeat}}
%&lt;algorithmic&gt;\newcommand{\algorithmicuntil}{\textbf{until}}
%&lt;algorithmic&gt;\newcommand{\algorithmicprint}{\textbf{print}}
%&lt;algorithmic&gt;\newcommand{\algorithmicreturn}{\textbf{return}}
%&lt;algorithmic&gt;\newcommand{\algorithmicand}{\textbf{and}}
%&lt;algorithmic&gt;\newcommand{\algorithmicor}{\textbf{or}}
%&lt;algorithmic&gt;\newcommand{\algorithmicxor}{\textbf{xor}}
%&lt;algorithmic&gt;\newcommand{\algorithmicnot}{\textbf{not}}
%&lt;algorithmic&gt;\newcommand{\algorithmicto}{\textbf{to}}
%&lt;algorithmic&gt;\newcommand{\algorithmicinputs}{\textbf{inputs}}
%&lt;algorithmic&gt;\newcommand{\algorithmicoutputs}{\textbf{outputs}}
%&lt;algorithmic&gt;\newcommand{\algorithmicglobals}{\textbf{globals}}
%&lt;algorithmic&gt;\newcommand{\algorithmicbody}{\textbf{do}}
%&lt;algorithmic&gt;\newcommand{\algorithmictrue}{\textbf{true}}
%&lt;algorithmic&gt;\newcommand{\algorithmicfalse}{\textbf{false}}
%&lt;algorithmic&gt;\def\ALC@item[#1]{%
%&lt;algorithmic&gt;\if@noparitem \@donoparitem
%&lt;algorithmic&gt;  \else \if@inlabel \indent \par \fi
%&lt;algorithmic&gt;         \ifhmode \unskip\unskip \par \fi
%&lt;algorithmic&gt;         \if@newlist \if@nobreak \@nbitem \else
%&lt;algorithmic&gt;                        \addpenalty\@beginparpenalty
%&lt;algorithmic&gt;                        \addvspace\@topsep \addvspace{-\parskip}\fi
%&lt;algorithmic&gt;           \else \addpenalty\@itempenalty \addvspace\itemsep
%&lt;algorithmic&gt;          \fi
%&lt;algorithmic&gt;    \global\@inlabeltrue
%&lt;algorithmic&gt;\fi
%&lt;algorithmic&gt;\everypar{\global\@minipagefalse\global\@newlistfalse
%&lt;algorithmic&gt;          \if@inlabel\global\@inlabelfalse \hskip -\parindent \box\@labels
%&lt;algorithmic&gt;             \penalty\z@ \fi
%&lt;algorithmic&gt;          \everypar{}}\global\@nobreakfalse
%&lt;algorithmic&gt;\if@noitemarg \@noitemargfalse \if@nmbrlist \refstepcounter{\@listctr}\fi \fi
%&lt;algorithmic&gt;\sbox\@tempboxa{\makelabel{#1}}%
%&lt;algorithmic&gt;\global\setbox\@labels
%&lt;algorithmic&gt; \hbox{\unhbox\@labels \hskip \itemindent
%&lt;algorithmic&gt;       \hskip -\labelwidth \hskip -\ALC@tlm
%&lt;algorithmic&gt;       \ifdim \wd\@tempboxa &gt;\labelwidth
%&lt;algorithmic&gt;                \box\@tempboxa
%&lt;algorithmic&gt;          \else \hbox to\labelwidth {\unhbox\@tempboxa}\fi
%&lt;algorithmic&gt;       \hskip \ALC@tlm}\ignorespaces}
%&lt;algorithmic&gt;%
%&lt;algorithmic&gt;\newenvironment{algorithmic}[1][0]{
%&lt;algorithmic&gt;\setcounter{ALC@depth}{\@listdepth}%
%&lt;algorithmic&gt;\let\@listdepth\c@ALC@depth%
%&lt;algorithmic&gt;\let\@item\ALC@item%
%&lt;algorithmic&gt;  \newcommand{\ALC@lno}{%
%&lt;algorithmic&gt;\ifthenelse{\equal{\arabic{ALC@rem}}{0}}
%&lt;algorithmic&gt;{{\ALC@linenosize \arabic{ALC@line}\ALC@linenodelimiter}}{}%
%&lt;algorithmic&gt;}
%&lt;algorithmic&gt;\let\@listii\@listi
%&lt;algorithmic&gt;\let\@listiii\@listi
%&lt;algorithmic&gt;\let\@listiv\@listi
%&lt;algorithmic&gt;\let\@listv\@listi
%&lt;algorithmic&gt;\let\@listvi\@listi
%&lt;algorithmic&gt;\let\@listvii\@listi
%&lt;algorithmic&gt;  \newenvironment{ALC@g}{
%&lt;algorithmic&gt;    \begin{list}{\ALC@lno}{ \itemsep\z@ \itemindent\z@
%&lt;algorithmic&gt;    \listparindent\z@ \rightmargin\z@ 
%&lt;algorithmic&gt;    \topsep\z@ \partopsep\z@ \parskip\z@\parsep\z@
%&lt;algorithmic&gt;    \leftmargin \algorithmicindent%1em
%&lt;algorithmic&gt;    \addtolength{\ALC@tlm}{\leftmargin}
%&lt;algorithmic&gt;    }
%&lt;algorithmic&gt;  }
%&lt;algorithmic&gt;  {\end{list}}
%&lt;algorithmic&gt;  \newcommand{\ALC@it}{%
%&lt;algorithmic&gt;    \stepcounter{ALC@rem}%
%&lt;algorithmic&gt;    \ifthenelse{\equal{\arabic{ALC@rem}}{#1}}{\setcounter{ALC@rem}{0}}{}%
%&lt;algorithmic&gt;    \stepcounter{ALC@line}%
%&lt;algorithmic&gt;    \refstepcounter{ALC@unique}%
%&lt;algorithmic&gt;    \item\def\@currentlabel{\theALC@line}%
%&lt;algorithmic&gt;  }
%&lt;algorithmic&gt;  \newcommand{\ALC@com}[1]{\ifthenelse{\equal{##1}{default}}%
%&lt;algorithmic&gt;{}{\ \algorithmiccomment{##1}}}
%&lt;algorithmic&gt;  \newcommand{\REQUIRE}{\item[\algorithmicrequire]}
%&lt;algorithmic&gt;  \newcommand{\ENSURE}{\item[\algorithmicensure]}
%&lt;algorithmic&gt;  \newcommand{\PRINT}{\ALC@it\algorithmicprint{} \ }
%&lt;algorithmic&gt;  \newcommand{\RETURN}{\ALC@it\algorithmicreturn{} \ }
%&lt;algorithmic&gt;  \newcommand{\TRUE}{\algorithmictrue{}}
%&lt;algorithmic&gt;  \newcommand{\FALSE}{\algorithmicfalse{}}
%&lt;algorithmic&gt;  \newcommand{\AND}{\algorithmicand{} }
%&lt;algorithmic&gt;  \newcommand{\OR}{\algorithmicor{} }
%&lt;algorithmic&gt;  \newcommand{\XOR}{\algorithmicxor{} }
%&lt;algorithmic&gt;  \newcommand{\NOT}{\algorithmicnot{} }
%&lt;algorithmic&gt;  \newcommand{\TO}{\algorithmicto{} }
%&lt;algorithmic&gt;  \newcommand{\STATE}{\ALC@it}
%&lt;algorithmic&gt;  \newcommand{\STMT}{\ALC@it}
%&lt;algorithmic&gt;  \newcommand{\COMMENT}[1]{\algorithmiccomment{##1}}
%&lt;algorithmic&gt;  \newenvironment{ALC@inputs}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@outputs}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@globals}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@body}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@if}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@for}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@whl}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@loop}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \newenvironment{ALC@rpt}{\begin{ALC@g}}{\end{ALC@g}}
%&lt;algorithmic&gt;  \renewcommand{\\}{\@centercr}
%&lt;algorithmic&gt;  \newcommand{\INPUTS}[1][default]{\ALC@it\algorithmicinputs\ \ALC@com{##1}\begin{ALC@inputs}}
%&lt;algorithmic&gt;  \newcommand{\ENDINPUTS}{\end{ALC@inputs}}
%&lt;algorithmic&gt;  \newcommand{\OUTPUTS}[1][default]{\ALC@it\algorithmicoutputs\ \ALC@com{##1}\begin{ALC@outputs}}
%&lt;algorithmic&gt;  \newcommand{\ENDOUTPUTS}{\end{ALC@outputs}}
%&lt;algorithmic&gt;  \newcommand{\GLOBALS}{\ALC@it\algorithmicglobals\ }
%&lt;algorithmic&gt;  \newcommand{\BODY}[1][default]{\ALC@it\algorithmicbody\ \ALC@com{##1}\begin{ALC@body}}
%&lt;algorithmic&gt;  \newcommand{\ENDBODY}{\end{ALC@body}}
%&lt;algorithmic&gt;  \newcommand{\IF}[2][default]{\ALC@it\algorithmicif\ ##2\ \algorithmicthen%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@if}}
%&lt;algorithmic&gt;  \newcommand{\ELSE}[1][default]{\end{ALC@if}\ALC@it\algorithmicelse%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@if}}
%&lt;algorithmic&gt;  \newcommand{\ELSIF}[2][default]%
%&lt;algorithmic&gt;{\end{ALC@if}\ALC@it\algorithmicelsif\ ##2\ \algorithmicthen%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@if}}
%&lt;algorithmic&gt;  \newcommand{\FOR}[2][default]{\ALC@it\algorithmicfor\ ##2\ \algorithmicdo%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@for}}
%&lt;algorithmic&gt;  \newcommand{\FORALL}[2][default]{\ALC@it\algorithmicforall\ ##2\ %
%&lt;algorithmic&gt;\algorithmicdo%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@for}}
%&lt;algorithmic&gt;  \newcommand{\WHILE}[2][default]{\ALC@it\algorithmicwhile\ ##2\ %
%&lt;algorithmic&gt;\algorithmicdo%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@whl}}
%&lt;algorithmic&gt;  \newcommand{\LOOP}[1][default]{\ALC@it\algorithmicloop%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@loop}}
%&lt;algorithmic&gt;  \newcommand{\REPEAT}[1][default]{\ALC@it\algorithmicrepeat%
%&lt;algorithmic&gt;\ALC@com{##1}\begin{ALC@rpt}}
%&lt;algorithmic&gt;  \newcommand{\UNTIL}[1]{\end{ALC@rpt}\ALC@it\algorithmicuntil\ ##1}
%&lt;algorithmic&gt;  \ifthenelse{\boolean{ALC@noend}}{
%&lt;algorithmic&gt;    \newcommand{\ENDIF}{\end{ALC@if}}
%&lt;algorithmic&gt;    \newcommand{\ENDFOR}{\end{ALC@for}}
%&lt;algorithmic&gt;    \newcommand{\ENDWHILE}{\end{ALC@whl}}
%&lt;algorithmic&gt;    \newcommand{\ENDLOOP}{\end{ALC@loop}}
%&lt;algorithmic&gt;  }{
%&lt;algorithmic&gt;    \newcommand{\ENDIF}{\end{ALC@if}\ALC@it\algorithmicendif}
%&lt;algorithmic&gt;    \newcommand{\ENDFOR}{\end{ALC@for}\ALC@it\algorithmicendfor}
%&lt;algorithmic&gt;    \newcommand{\ENDWHILE}{\end{ALC@whl}\ALC@it\algorithmicendwhile}
%&lt;algorithmic&gt;    \newcommand{\ENDLOOP}{\end{ALC@loop}\ALC@it\algorithmicendloop}
%&lt;algorithmic&gt;  } 
%&lt;algorithmic&gt;  \renewcommand{\@toodeep}{}
%&lt;algorithmic&gt;  \begin{list}{\ALC@lno}{\setcounter{ALC@rem}{0}\setcounter{ALC@line}{0}%
%&lt;algorithmic&gt;    \itemsep\z@ \itemindent\z@ \listparindent\z@%
%&lt;algorithmic&gt;    \partopsep\z@ \parskip\z@ \parsep\z@%
%&lt;algorithmic&gt;    \labelsep 0.5em \topsep 0.2em%
%&lt;algorithmic&gt;\ifthenelse{\equal{#1}{0}}
%&lt;algorithmic&gt;  {\labelwidth 0.5em }
%&lt;algorithmic&gt;  {\labelwidth  1.2em }
%&lt;algorithmic&gt;\leftmargin\labelwidth \addtolength{\leftmargin}{\labelsep}
%&lt;algorithmic&gt;    \ALC@tlm\labelsep
%&lt;algorithmic&gt;  }
%&lt;algorithmic&gt;}
%&lt;algorithmic&gt;{\end{list}}
%\Finale
%\PrintChanges
%\PrintIndex
</pre></body></html>