<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: C++ Algorithms: next_permutation()</title>
	<atom:link href="http://marknelson.us/2002/03/01/next-permutation/feed/" rel="self" type="application/rss+xml" />
	<link>http://marknelson.us/2002/03/01/next-permutation/</link>
	<description>Programming, mostly.</description>
	<lastBuildDate>Tue, 07 Feb 2012 16:05:51 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.2.1</generator>
	<item>
		<title>By: Prashant</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-435046</link>
		<dc:creator>Prashant</dc:creator>
		<pubDate>Mon, 26 Dec 2011 17:20:48 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-435046</guid>
		<description>Superb...I just loved it...:)
Was looking for a similar stuff for a few days. I have implemented a recursive version but for distinct values, was trying to get it adapted for repeated values. But this algorithm is really awesome...thanks...:)</description>
		<content:encoded><![CDATA[<p>Superb&#8230;I just loved it&#8230;:)<br />
Was looking for a similar stuff for a few days. I have implemented a recursive version but for distinct values, was trying to get it adapted for repeated values. But this algorithm is really awesome&#8230;thanks&#8230;:)</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Refrences &#171; Belbesy M. Adel</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-401259</link>
		<dc:creator>Refrences &#171; Belbesy M. Adel</dc:creator>
		<pubDate>Wed, 16 Nov 2011 13:43:36 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-401259</guid>
		<description>[...] Generator &#124; next_permutation() &#124; next_permutation() 2 &#124; Algorithms Questions       GA_googleAddAttr(&quot;AdOpt&quot;, &quot;1&quot;); GA_googleAddAttr(&quot;Origin&quot;, &quot;other&quot;); [...]</description>
		<content:encoded><![CDATA[<p>[...] Generator | next_permutation() | next_permutation() 2 | Algorithms Questions       GA_googleAddAttr(&quot;AdOpt&quot;, &quot;1&quot;); GA_googleAddAttr(&quot;Origin&quot;, &quot;other&quot;); [...]</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: SPEEDY</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-399917</link>
		<dc:creator>SPEEDY</dc:creator>
		<pubDate>Mon, 14 Nov 2011 15:41:59 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-399917</guid>
		<description>1. The lazybone method: Just store all permutations generated in a map that is a hash table, and check for the first time generated or not by a hash or so called a dictionary !

2. If there&#039;s no handy hash, just generate an ordered list of numbers somewhat like an odometer with input chars ordered in ASCII is fine!</description>
		<content:encoded><![CDATA[<p>1. The lazybone method: Just store all permutations generated in a map that is a hash table, and check for the first time generated or not by a hash or so called a dictionary !</p>
<p>2. If there&#8217;s no handy hash, just generate an ordered list of numbers somewhat like an odometer with input chars ordered in ASCII is fine!</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: SPEEDY</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-375292</link>
		<dc:creator>SPEEDY</dc:creator>
		<pubDate>Sat, 17 Sep 2011 14:29:06 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-375292</guid>
		<description>I love to play with variants of this kind of problems.
I am thinking if the program is required not to produce duplicate output strings when there might be some repeated characters in the input string. For example, &quot;good_dog&quot; is fed into the program!</description>
		<content:encoded><![CDATA[<p>I love to play with variants of this kind of problems.<br />
I am thinking if the program is required not to produce duplicate output strings when there might be some repeated characters in the input string. For example, &#8220;good_dog&#8221; is fed into the program!</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Mark Nelson</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-371577</link>
		<dc:creator>Mark Nelson</dc:creator>
		<pubDate>Sun, 14 Aug 2011 18:06:49 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-371577</guid>
		<description>@Thomas:

Nice approach. On problems like this I have a tendency to go for the brute force first. A more elegant solution like yours is always more satisfying though.

- Mark</description>
		<content:encoded><![CDATA[<p>@Thomas:</p>
<p>Nice approach. On problems like this I have a tendency to go for the brute force first. A more elegant solution like yours is always more satisfying though.</p>
<p>- Mark</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Thomas Nygreen</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-371471</link>
		<dc:creator>Thomas Nygreen</dc:creator>
		<pubDate>Sat, 13 Aug 2011 16:19:55 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-371471</guid>
		<description>Nice article!

The original problem can be solved by first listing the seven possible combinations of numbers in the range 1–9 such that no numbers are repeated and the sum is 17:
[code]
i:   {1, 7, 9}
ii:  {2, 6, 9}
iii: {2, 7, 8}
iv:  {3, 5, 9}
v:   {3, 6, 8}
vi:  {4, 5, 8}
vii: {4, 6, 7}
[/code]

Exactly five of these must be included in the solution. Let&#039;s label the positions a–i, as Hugo did, and start with the diagonal c-e-g. Note that both c and g must occur in three different combinations, the candidates being 6, 7, 8 and 9. Using the fact that the figure is symmetric, let c &lt; g. Then we have c = 6 or c = 7.

As there are no combinations containing both 5 and 6 or both 5 and 7, the only positions left for 5 are d and h. Again we use symmetry, and let d = 5. This in turn means a must be 3 or 4, and g must be 8 or 9.

There is only one combination containing 1, so 1 cannot be in any corner, and there are no combinations with both 8 and 9, so h and i cannot be 9. That leaves only e and h as possible positions for 1. Now if we were to let e = 1, we would get c = 7, g = 9, a = 3, and b would need to be 7, which is already taken by c. Therefore h = 1.

Then follows g = 9, i = 7, a = 3, c = 6, b = 8, f = 4 and e = 2.</description>
		<content:encoded><![CDATA[<p>Nice article!</p>
<p>The original problem can be solved by first listing the seven possible combinations of numbers in the range 1–9 such that no numbers are repeated and the sum is 17:</p>
<div class="igBar"><span id="lcode-1"><a href="#" onclick="javascript:showPlainTxt('code-1'); return false;">PLAIN TEXT</a></span></div>
<div class="syntax_hilite"><span class="langName">CODE:</span>
<div id="code-1">
<div class="code">
<ol>
<li class="li1">
<div class="de1">i:&nbsp; &nbsp;<span class="br0">&#123;</span><span class="nu0">1</span>, <span class="nu0">7</span>, <span class="nu0">9</span><span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">ii:&nbsp; <span class="br0">&#123;</span><span class="nu0">2</span>, <span class="nu0">6</span>, <span class="nu0">9</span><span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">iii: <span class="br0">&#123;</span><span class="nu0">2</span>, <span class="nu0">7</span>, <span class="nu0">8</span><span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">iv:&nbsp; <span class="br0">&#123;</span><span class="nu0">3</span>, <span class="nu0">5</span>, <span class="nu0">9</span><span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">v:&nbsp; &nbsp;<span class="br0">&#123;</span><span class="nu0">3</span>, <span class="nu0">6</span>, <span class="nu0">8</span><span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">vi:&nbsp; <span class="br0">&#123;</span><span class="nu0">4</span>, <span class="nu0">5</span>, <span class="nu0">8</span><span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">vii: <span class="br0">&#123;</span><span class="nu0">4</span>, <span class="nu0">6</span>, <span class="nu0">7</span><span class="br0">&#125;</span> </div>
</li>
</ol>
</div>
</div>
</div>
<p></p>
<p>Exactly five of these must be included in the solution. Let's label the positions a–i, as Hugo did, and start with the diagonal c-e-g. Note that both c and g must occur in three different combinations, the candidates being 6, 7, 8 and 9. Using the fact that the figure is symmetric, let c &lt; g. Then we have c = 6 or c = 7.</p>
<p>As there are no combinations containing both 5 and 6 or both 5 and 7, the only positions left for 5 are d and h. Again we use symmetry, and let d = 5. This in turn means a must be 3 or 4, and g must be 8 or 9.</p>
<p>There is only one combination containing 1, so 1 cannot be in any corner, and there are no combinations with both 8 and 9, so h and i cannot be 9. That leaves only e and h as possible positions for 1. Now if we were to let e = 1, we would get c = 7, g = 9, a = 3, and b would need to be 7, which is already taken by c. Therefore h = 1.</p>
<p>Then follows g = 9, i = 7, a = 3, c = 6, b = 8, f = 4 and e = 2.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Quick Facts</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-335444</link>
		<dc:creator>Quick Facts</dc:creator>
		<pubDate>Fri, 29 Oct 2010 22:33:51 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-335444</guid>
		<description>You you could change the webpage subject title C++ Algorithms: next_permutation()   to  more catching for your content you create. I enjoyed the the writing still.</description>
		<content:encoded><![CDATA[<p>You you could change the webpage subject title C++ Algorithms: next_permutation()   to  more catching for your content you create. I enjoyed the the writing still.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Sven Forstmann</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-324522</link>
		<dc:creator>Sven Forstmann</dc:creator>
		<pubDate>Thu, 08 Apr 2010 14:05:17 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-324522</guid>
		<description>Well, lets say you have 120 permutations and you want permutation number 60. Using STL you woule have to walk through all of them step by step - wont you ?

So I&#039;ve written an implementation that gives you any permutation immideately, without recursion:

[c]
#include &lt;string&gt;

int main(int,char**)
{
    std::string default_str = &quot;12345&quot;;

    int perm=1, digits=default_str.size();
    for (int i=1;i&lt;=digits;perm*=i++);
    for (int a=0;a&lt;perm;a++)
    {
        std::string avail=default_str;

        for (int b=digits,div=perm;b&gt;0; b--)
        {
            div/=b;
            int index = (a/div)%b;
            printf(&quot;%c&quot;, avail[index] );
            avail.erase(index,1) ;
        }
        printf(&quot;\n&quot;);
    }
    printf(&quot;permutations:%d\n&quot;,perm);
    while(1);
}
[/c]

(c) Sven Forstmann</description>
		<content:encoded><![CDATA[<p>Well, lets say you have 120 permutations and you want permutation number 60. Using STL you woule have to walk through all of them step by step - wont you ?</p>
<p>So I've written an implementation that gives you any permutation immideately, without recursion:</p>
<div class="igBar"><span id="lc-2"><a href="#" onclick="javascript:showPlainTxt('c-2'); return false;">PLAIN TEXT</a></span></div>
<div class="syntax_hilite"><span class="langName">C:</span>
<div id="c-2">
<div class="c">
<ol>
<li class="li1">
<div class="de1"><span class="co2">#include &lt;string&gt;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp;</div>
</li>
<li class="li1">
<div class="de1"><span class="kw4">int</span> main<span class="br0">&#40;</span><span class="kw4">int</span>,<span class="kw4">char</span>**<span class="br0">&#41;</span></div>
</li>
<li class="li2">
<div class="de2"><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; std::<span class="kw4">string</span> default_str = <span class="st0">"12345"</span>;</div>
</li>
<li class="li2">
<div class="de2">&nbsp;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw4">int</span> perm=<span class="nu0">1</span>, digits=default_str.<span class="me1">size</span><span class="br0">&#40;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; <span class="kw1">for</span> <span class="br0">&#40;</span><span class="kw4">int</span> i=<span class="nu0">1</span>;i&lt;=digits;perm*=i++<span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">for</span> <span class="br0">&#40;</span><span class="kw4">int</span> a=<span class="nu0">0</span>;a&lt;perm;a++<span class="br0">&#41;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; <span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; std::<span class="kw4">string</span> avail=default_str;</div>
</li>
<li class="li2">
<div class="de2">&nbsp;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="kw1">for</span> <span class="br0">&#40;</span><span class="kw4">int</span> b=digits,div=perm;b&gt;<span class="nu0">0</span>; b--<span class="br0">&#41;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; div/=b;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="kw4">int</span> index = <span class="br0">&#40;</span>a/div<span class="br0">&#41;</span>%b;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html"><span class="kw3">printf</span></a><span class="br0">&#40;</span><span class="st0">"%c"</span>, avail<span class="br0">&#91;</span>index<span class="br0">&#93;</span> <span class="br0">&#41;</span>;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; avail.<span class="me1">erase</span><span class="br0">&#40;</span>index,<span class="nu0">1</span><span class="br0">&#41;</span> ;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html"><span class="kw3">printf</span></a><span class="br0">&#40;</span><span class="st0">"<span class="es0">\n</span>"</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; <a href="http://www.opengroup.org/onlinepubs/009695399/functions/printf.html"><span class="kw3">printf</span></a><span class="br0">&#40;</span><span class="st0">"permutations:%d<span class="es0">\n</span>"</span>,perm<span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">while</span><span class="br0">&#40;</span><span class="nu0">1</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li2">
<div class="de2"><span class="br0">&#125;</span> </div>
</li>
</ol>
</div>
</div>
</div>
<p></p>
<p>(c) Sven Forstmann</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: gaston770</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-314728</link>
		<dc:creator>gaston770</dc:creator>
		<pubDate>Sun, 13 Sep 2009 05:13:26 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-314728</guid>
		<description>http://code.google.com/codejam/contest/dashboard?c=186264#s=p1

This Google Code Jam 2009 problem solves in less than 30 lines with next_permutation.. I love it :D, Great post dear Mark. ;)

[c]
int main (void) {
    int T;
    string N;
    cin &gt;&gt; T;
    for (int count = 1; count &lt;= T; count++) {
        cin &gt;&gt; N;
        if (!next_permutation (N.begin(), N.end())) {
            int xx = 0;
            while (N[xx++] == &#039;0&#039;);
            swap (N[--xx],N[0]);
            N.insert (N.begin(),&#039;0&#039;);
            swap (N[0], N[1]);
        }
        cout &lt;&lt; &quot;Case #&quot; &lt;&lt; count &lt;&lt;  &quot;: &quot;&lt;&lt; N &lt;&lt; endl;
    }
    return 0;
[/c]</description>
		<content:encoded><![CDATA[<p><a href="http://code.google.com/codejam/contest/dashboard?c=186264#s=p1" rel="nofollow">http://code.google.com/codejam/contest/dashboard?c=186264#s=p1</a></p>
<p>This Google Code Jam 2009 problem solves in less than 30 lines with next_permutation.. I love it :D, Great post dear Mark. ;)</p>
<div class="igBar"><span id="lc-3"><a href="#" onclick="javascript:showPlainTxt('c-3'); return false;">PLAIN TEXT</a></span></div>
<div class="syntax_hilite"><span class="langName">C:</span>
<div id="c-3">
<div class="c">
<ol>
<li class="li1">
<div class="de1"><span class="kw4">int</span> main <span class="br0">&#40;</span><span class="kw4">void</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; <span class="kw4">int</span> T;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw4">string</span> N;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; cin&gt;&gt; T;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">for</span> <span class="br0">&#40;</span><span class="kw4">int</span> count = <span class="nu0">1</span>; count &lt;= T; count++<span class="br0">&#41;</span> <span class="br0">&#123;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; cin&gt;&gt; N;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="kw1">if</span> <span class="br0">&#40;</span>!next_permutation <span class="br0">&#40;</span>N.<span class="me1">begin</span><span class="br0">&#40;</span><span class="br0">&#41;</span>, N.<span class="me1">end</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#41;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="kw4">int</span> xx = <span class="nu0">0</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="kw1">while</span> <span class="br0">&#40;</span>N<span class="br0">&#91;</span>xx++<span class="br0">&#93;</span> == <span class="st0">'0'</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; swap <span class="br0">&#40;</span>N<span class="br0">&#91;</span>--xx<span class="br0">&#93;</span>,N<span class="br0">&#91;</span><span class="nu0">0</span><span class="br0">&#93;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; N.<span class="me1">insert</span> <span class="br0">&#40;</span>N.<span class="me1">begin</span><span class="br0">&#40;</span><span class="br0">&#41;</span>,<span class="st0">'0'</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; swap <span class="br0">&#40;</span>N<span class="br0">&#91;</span><span class="nu0">0</span><span class="br0">&#93;</span>, N<span class="br0">&#91;</span><span class="nu0">1</span><span class="br0">&#93;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; <a href="http://www.opengroup.org/onlinepubs/009695399/functions/cout.html"><span class="kw3">cout</span></a> &lt;&lt;<span class="st0">"Case #"</span> &lt;&lt;count &lt;&lt; <span class="st0">": "</span>&lt;&lt;N &lt;&lt;endl;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li2">
<div class="de2">&nbsp; &nbsp; <span class="kw1">return</span> <span class="nu0">0</span>; </div>
</li>
</ol>
</div>
</div>
</div>
<p></p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Mark Nelson</title>
		<link>http://marknelson.us/2002/03/01/next-permutation/comment-page-1/#comment-310890</link>
		<dc:creator>Mark Nelson</dc:creator>
		<pubDate>Sun, 26 Jul 2009 18:55:07 +0000</pubDate>
		<guid isPermaLink="false">/2002/03/01/next-permutation/#comment-310890</guid>
		<description>@lzzy88:

I don&#039;t know where the algorithm came from, but you can pretty much figure out next_permutation by examining the source code. A recursive version of a permutation function is trivial, the iterative version is not quite as obvious and requires a little bit of work.

- Mark</description>
		<content:encoded><![CDATA[<p>@lzzy88:</p>
<p>I don't know where the algorithm came from, but you can pretty much figure out next_permutation by examining the source code. A recursive version of a permutation function is trivial, the iterative version is not quite as obvious and requires a little bit of work.</p>
<p>- Mark</p>
]]></content:encoded>
	</item>
</channel>
</rss>

