[Boost-commit] svn:boost r43474 - in sandbox/committee/concepts: . issues issues/issues

From: dgregor_at_[hidden]
Date: 2008-03-03 11:27:24

Author: dgregor
Date: 2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
New Revision: 43474
URL: http://svn.boost.org/trac/boost/changeset/43474

Log:
Skeletal concepts issues list
Added:
   sandbox/committee/concepts/
   sandbox/committee/concepts/issues/
   sandbox/committee/concepts/issues/Makefile   (contents, props changed)
   sandbox/committee/concepts/issues/date.cpp   (contents, props changed)
   sandbox/committee/concepts/issues/date.h   (contents, props changed)
   sandbox/committee/concepts/issues/issues/
   sandbox/committee/concepts/issues/issues/concepts-issues.xml   (contents, props changed)
   sandbox/committee/concepts/issues/issues/concepts-template.xml   (contents, props changed)
   sandbox/committee/concepts/issues/issues/issue1.xml   (contents, props changed)
   sandbox/committee/concepts/issues/main.cpp   (contents, props changed)
   sandbox/committee/concepts/issues/section.data   (contents, props changed)

Added: sandbox/committee/concepts/issues/Makefile
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/Makefile	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,11 @@
+CXX=g++
+
+html: 
+	make concepts_issues
+	./concepts_issues
+
+concepts_issues: main.cpp date.cpp date.h
+	$(CXX) -o concepts_issues main.cpp date.cpp date.h
+
+clean:
+	rm -f *.html concepts_issues

Added: sandbox/committee/concepts/issues/date.cpp
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/date.cpp	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,348 @@
+// I, Howard Hinnant, hereby place this code in the public domain.
+
+#include "date.h"
+#include <time.h>
+
+namespace gregorian
+{
+
+namespace detail
+{
+
+unsigned spec::id_next = 0;
+
+}  // detail
+
+const unsigned char date::lastDay_s[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+const detail::spec last;
+const detail::spec first;
+
+const week_day sun(0);
+const week_day mon(1);
+const week_day tue(2);
+const week_day wed(3);
+const week_day thu(4);
+const week_day fri(5);
+const week_day sat(6);
+
+const month jan(1);
+const month feb(2);
+const month mar(3);
+const month apr(4);
+const month may(5);
+const month jun(6);
+const month jul(7);
+const month aug(8);
+const month sep(9);
+const month oct(10);
+const month nov(11);
+const month dec(12);
+
+day::day(int d)
+    :   d_((unsigned char)d)
+{
+    if (d < 1 || d > 31)
+        throw bad_date();
+}
+
+week_day::week_day(int d)
+    :   d_(d)
+{
+    if (d < 0 || d > 6)
+        throw bad_date();
+}
+
+date::date()
+{
+    time_t systime;
+    time(&systime);
+    struct tm* now = std::localtime(&systime);
+    year_ = (unsigned short)(now->tm_year+1900);
+    month_ = (unsigned char)(now->tm_mon+1);
+    day_ = (unsigned char)(now->tm_mday);
+    fix_from_ymd();
+}
+
+date::date(detail::day_month_spec dm, gregorian::year y)
+    :   year_((unsigned short)y.value),
+        month_((unsigned char)dm.m_.value),
+        day_(dm.d_.d_)
+{
+    init();
+}
+
+date::date(gregorian::day d, detail::month_year_spec my)
+    :   year_((unsigned short)my.y_.value),
+        month_((unsigned char)my.m_.value),
+        day_(d.d_)
+{
+    init();
+}
+
+void
+date::decode(int& dow, int& n) const
+{
+    if (day_ & 0xE0)
+        dow = ((day_ & 0xE0) >> 5) - 1;
+    else
+        dow = -1;
+    n = month_ >> 4;
+}
+
+void
+date::encode(int dow, int n)
+{
+    day_ &= 0x1F;
+    month_ &= 0x0F;
+    if (dow >= 0)
+        day_ |= (unsigned char)((dow + 1) << 5);
+    month_ |= (unsigned char)(n << 4);
+}
+
+void
+date::init()
+{
+    if (day_ & 0xE0)
+    {
+        int dow = ((day_ & 0xE0) >> 5) - 1;
+        int n = day_ & 0x1F;
+        if (n == 0)
+            n = 6;
+        day_ = 0;
+        encode(dow, n);
+    }
+    else if (day_ == 0)
+        encode(-1, 6);
+    fix_from_ymd();
+}
+
+bool
+date::is_leap() const
+{
+    if (year_ > 1582)
+    {
+        if (year_ % 400 == 0)
+            return true;
+        if (year_ % 100 == 0)
+            return false;
+    }
+    return year_ % 4 == 0;
+}
+
+void
+date::fix_from_ymd()
+{
+    int dow, n, d, m, y;
+    decode(dow, n);
+    d = day();
+    m = month();
+    y = year();
+    if (0 <= dow && dow <= 6)
+    {
+        if (n == 0 || n >  6)
+            throw bad_date();
+        date tmp1 = gregorian::day(1) / m / y;
+        date tmp2 = last / m / y;
+        int wd = tmp1.day_of_week();
+        int delta = 0;
+        if (dow != wd)
+        {
+            if (dow < wd)
+                delta += 7 - (wd - dow);
+            else
+                delta += dow - wd;
+        }
+        delta += (n-1)*7;
+        if (n == 6 && delta >= tmp2.day())
+            delta -= 7 * ((delta - tmp2.day()) / 7 + 1);
+        tmp1 += delta;
+        if (tmp1.month() != m)
+            throw bad_date();
+        *this = tmp1;
+        encode(dow, n);
+        return;
+    }
+    if (dow != -1)
+        throw bad_date();
+    if (n != 0 && n != 6)
+        throw bad_date();
+    if ((d == 0 && n == 0) || m == 0 || m > 12)
+        throw bad_date();
+    if (n == 6)
+        d = 0;
+    unsigned long jdate = 0;
+    bool leap = is_leap();
+    if (leap && m == 2)
+    {
+        if (d > 29)
+            throw bad_date();
+        if (n == 6)
+            d = 29;
+    }
+    else
+    {
+        if (d > lastDay_s[m-1])
+            throw bad_date();
+        if (n == 6)
+            d = lastDay_s[m-1];
+    }
+    if (y == 1582 && m == 10 && d >= 5 && d <= 14)
+        throw bad_date();
+    if (y > 0)
+    {
+        jdate = 365U * y + 1;   // Jan 1, 0 == 1 && y 0 is leap y
+        --y;
+        jdate += y / 4;
+        if (y >= 1700)
+            jdate += -(y-1600) / 100 + (y-1600) / 400;
+        ++y;
+    }
+    for (int i = 0; i < m-1; i++)
+        jdate += lastDay_s[i];
+    if (leap && m > 2)
+        jdate++;
+    jdate += d;
+    //  If date >= 10/15/1582 then subtract 10
+    if (jdate >= 578114)
+        jdate -= 10;
+
+//  if (y >= 1582) {
+//      if (y == 1582) {
+//          if (m >= 10) {
+//              if (m == 10) {
+//                  if (d >= 15) {
+//                      jdate -= 10;
+//                  }
+//              }
+//              else {      // m > 10
+//                  jdate -= 10;
+//              }
+//          }
+//      }
+//      else {      // y > 1582
+//          jdate -= 10;
+//      }
+//  }
+
+    if (jdate <= 0)
+        throw bad_date();
+    jdate_ = jdate;
+    year_ = (unsigned short)y;
+    month_ = (unsigned char)m;
+    day_ = (unsigned char)d;
+    encode(dow, n);
+}
+
+void
+date::fix_from_jdate()
+{
+    if (jdate_ <= 0)
+        throw bad_date();
+    int dow, n;
+    decode(dow, n);
+    year_ = static_cast<unsigned short>(jdate_ / 365.2475);
+    date lower = gregorian::day(1) / 1 / year_;
+    date upper = gregorian::day(31) / 12 / year_;
+    while (true)
+    {
+        if (lower.jdate_ > jdate_)
+            --year_;
+        else if (upper.jdate_ < jdate_)
+            ++year_;
+        else
+            break;
+        lower = gregorian::day(1) / 1 / year_;
+        upper = gregorian::day(31) / 12 / year_;
+    }
+    month_ = static_cast<unsigned char>((jdate_ - lower.jdate_) / 30 + 1);
+    if (month_ > 12)
+        month_ = 12;
+    while (true)
+    {
+        lower = gregorian::day(1) / month_ / year_;
+        upper = gregorian::last / month_ / year_;
+        if (lower.jdate_ > jdate_)
+            --month_;
+        else if (upper.jdate_ < jdate_)
+            ++month_;
+        else
+            break;
+    }
+    day_ = static_cast<unsigned char>(jdate_ - lower.jdate_ + 1);
+    if (year_ == 1582 && month_ == 10 && day_ >= 5)
+        day_ += 10;
+}
+
+day
+operator*(detail::spec s, week_day wd)
+{
+    day d(1);
+    d.d_ = (unsigned char)(wd.d_+1 << 5);
+    if (s == first)
+        d.d_ |= 1;
+    return d;
+}
+
+day
+operator*(int n, week_day wd)
+{
+    day d(1);
+    if (n < 1 || n > 5)
+        throw bad_date();
+    d.d_ = (unsigned char)((wd.d_+1 << 5) | n);
+    return d;
+}
+
+date&
+date::operator+=(int d)
+{
+    jdate_ += d;
+    fix_from_jdate();
+    return *this;
+}
+
+date
+operator+(const date& dt, month mnth)
+{
+    int dow, n, m, d, y;
+    dt.decode(dow, n);
+    y = dt.year();
+    m = dt.month();
+    d = dt.day();
+    int new_month = m - 1 + mnth.value;
+    if (new_month < 0)
+    {
+        int delta = ((-new_month - 1) / 12 + 1) * 12;
+        y -= delta / 12;
+        new_month += delta;
+    }
+    else if (new_month > 11)
+    {
+        int delta = ((new_month - 12) / 12 + 1) * 12;
+        y += delta / 12;
+        new_month -= delta;
+    }
+    m = new_month + 1;
+    date result(y, m, d);
+    result.encode(dow, n);
+    result.fix_from_ymd();
+    return result;
+}
+
+date
+operator+(const date& dt, year yr)
+{
+    int dow, n, m, d, y;
+    dt.decode(dow, n);
+    y = dt.year();
+    m = dt.month();
+    d = dt.day();
+    y += yr.value;
+    date result(y, m, d);
+    result.encode(dow, n);
+    result.fix_from_ymd();
+    return result;
+}
+
+}  // gregorian

Added: sandbox/committee/concepts/issues/date.h
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/date.h	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,343 @@
+// I, Howard Hinnant, hereby place this code in the public domain.
+
+#ifndef DATE_H
+#define DATE_H
+
+#include <exception>
+#include <istream>
+#include <ostream>
+#include <locale>
+#include <ctime>
+
+namespace gregorian
+{
+
+class day;
+
+namespace detail
+{
+
+class spec
+{
+private:
+    unsigned id_;
+    static unsigned id_next;
+
+    friend class gregorian::day;
+public:
+    spec() : id_(id_next++) {}
+    bool operator == (const spec& y) const {return id_ == y.id_;}
+    bool operator != (const spec& y) const {return id_ != y.id_;}
+};
+
+}  // detail
+
+extern const detail::spec last;
+extern const detail::spec first;
+
+class bad_date
+    : public std::exception
+{
+public:
+    virtual const char* what() const throw() {return "bad_date";}
+};
+
+class week_day;
+class date;
+
+class day
+{
+private:
+    unsigned char d_;
+
+    friend class gregorian::date;
+    friend day operator*(detail::spec s, week_day wd);
+    friend day operator*(int n, week_day wd);
+public:
+    day(int d);
+    day(detail::spec s) : d_((unsigned char)s.id_) {}
+};
+
+struct month
+{
+    month(int m) : value(m) {}
+    int value;
+};
+
+struct year
+{
+    year(int y) : value(y) {}
+    int value;
+};
+
+class week_day
+{
+private:
+    int d_;
+
+    friend class gregorian::date;
+    friend day operator*(detail::spec s, week_day wd);
+    friend day operator*(int n, week_day wd);
+public:
+    week_day(int d);
+};
+
+extern const week_day sun;
+extern const week_day mon;
+extern const week_day tue;
+extern const week_day wed;
+extern const week_day thu;
+extern const week_day fri;
+extern const week_day sat;
+
+extern const month jan;
+extern const month feb;
+extern const month mar;
+extern const month apr;
+extern const month may;
+extern const month jun;
+extern const month jul;
+extern const month aug;
+extern const month sep;
+extern const month oct;
+extern const month nov;
+extern const month dec;
+
+namespace detail
+{
+
+class day_month_spec
+{
+private:
+    day   d_;
+    month m_;
+
+    friend class gregorian::date;
+public:
+    day_month_spec(day d, month m);
+};
+
+inline
+day_month_spec::day_month_spec(day d, month m)
+    :   d_(d),
+        m_(m)
+{
+}
+
+class month_year_spec
+{
+private:
+    month m_;
+    year  y_;
+
+    friend class gregorian::date;
+public:
+    month_year_spec(month m, year y);
+};
+
+inline
+month_year_spec::month_year_spec(month m, year y)
+    :   m_(m),
+        y_(y)
+{
+}
+
+}  // detail
+
+date operator+(const date&, month);
+date operator+(const date&, year);
+
+class date
+{
+private:
+    unsigned long jdate_;
+    unsigned short year_;
+    unsigned char month_;
+    unsigned char day_;
+    static const unsigned char lastDay_s[12];
+
+public:
+    date();
+    date(detail::day_month_spec dm, gregorian::year y);
+    date(gregorian::day d, detail::month_year_spec my);
+
+    int day() const {return day_ & 0x1F;}
+    int month() const {return month_ & 0x0F;}
+    int year() const {return year_;}
+    int day_of_week() const {return static_cast<int>((jdate_+3) % 7);}
+    bool is_leap() const;
+
+    date& operator+=(int d);
+    date& operator++() {return *this += 1;}
+    date  operator++(int) {date tmp(*this); *this += 1; return tmp;}
+    date& operator-=(int d) {return *this += -d;}
+    date& operator--() {return *this -= 1;}
+    date  operator--(int) {date tmp(*this); *this -= 1; return tmp;}
+    friend date operator+(const date& x, int y) {date r(x); r += y; return r;}
+    friend date operator+(int x, const date& y) {return y + x;}
+    friend date operator-(const date& x, int y) {date r(x); r += -y; return r;}
+
+    date& operator+=(gregorian::month m) {*this = *this + m; return *this;}
+    date& operator-=(gregorian::month m) {return *this += gregorian::month(-m.value);}
+    friend date operator+(gregorian::month m, const date& y) {return y + m;}
+    friend date operator-(const date& x, gregorian::month m) {date r(x); r -= m; return r;}
+
+    date& operator+=(gregorian::year y) {*this = *this + y; return *this;}
+    date& operator-=(gregorian::year y) {return *this += gregorian::year(-y.value);}
+    friend date operator+(gregorian::year y, const date& x) {return x + y;}
+    friend date operator-(const date& x, gregorian::year y) {date r(x); r -= y; return r;}
+
+    friend long operator-(const date& x, const date& y) {return (long)(x.jdate_ - y.jdate_);}
+    friend bool operator==(const date& x, const date& y) {return x.jdate_ == y.jdate_;}
+    friend bool operator!=(const date& x, const date& y) {return x.jdate_ != y.jdate_;}
+    friend bool operator< (const date& x, const date& y) {return x.jdate_ <  y.jdate_;}
+    friend bool operator<=(const date& x, const date& y) {return x.jdate_ <= y.jdate_;}
+    friend bool operator> (const date& x, const date& y) {return x.jdate_ >  y.jdate_;}
+    friend bool operator>=(const date& x, const date& y) {return x.jdate_ >= y.jdate_;}
+
+private:
+
+    date(int y, int m, int d)
+        : year_((unsigned short)y), month_((unsigned char)m), day_((unsigned char)d) {}
+    void init();
+    void fix_from_ymd();
+    void fix_from_jdate();
+    void decode(int& dow, int& n) const;
+    void encode(int dow, int n);
+
+    friend date operator+(const date&, gregorian::month);
+    friend date operator+(const date&, gregorian::year);
+};
+
+day operator*(detail::spec s, week_day wd);
+day operator*(int n, week_day wd);
+
+detail::day_month_spec
+inline
+operator/(day d, month m)
+{
+    return detail::day_month_spec(d, m);
+}
+
+inline
+detail::day_month_spec
+operator/(month m, day d)
+{
+    return detail::day_month_spec(d, m);
+}
+
+inline
+detail::month_year_spec
+operator/(year y, month m)
+{
+    return detail::month_year_spec(m, y);
+}
+
+inline
+date
+operator/(detail::day_month_spec dm, year y)
+{
+    return date(dm, y);
+}
+
+inline
+date
+operator/(detail::month_year_spec my, day d)
+{
+    return date(d, my);
+}
+
+namespace detail
+{
+
+detail::day_month_spec
+inline
+operator/(spec d, int m)
+{
+    return day(d) / month(m);
+}
+
+inline
+detail::day_month_spec
+operator/(int m, spec d)
+{
+    return day(d) / month(m);
+}
+
+inline
+date
+operator/(detail::day_month_spec dm, int y)
+{
+    return date(dm, year(y));
+}
+
+inline
+date
+operator/(detail::month_year_spec my, int d)
+{
+    return date(day(d), my);
+}
+
+
+
+}  // detail
+
+template<class charT, class traits>
+std::basic_istream<charT,traits>&
+operator >>(std::basic_istream<charT,traits>& is, date& item)
+{
+    typename std::basic_istream<charT,traits>::sentry ok(is);
+    if (ok)
+    {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+        try
+        {
+            const std::time_get<charT>& tg = std::use_facet<std::time_get<charT> >
+                                                           (is.getloc());
+            std::tm t;
+            tg.get_date(is, 0, is, err, &t);
+            if (!(err & std::ios_base::failbit))
+                item = date(month(t.tm_mon+1) / day(t.tm_mday) / year(t.tm_year+1900));
+        }
+        catch (...)
+        {
+            err |= std::ios_base::badbit | std::ios_base::failbit;
+        }
+        is.setstate(err);
+    }
+    return is;
+}
+
+template<class charT, class traits>
+std::basic_ostream<charT, traits>&
+operator <<(std::basic_ostream<charT, traits>& os, const date& item)
+{
+    typename std::basic_ostream<charT, traits>::sentry ok(os);
+    if (ok)
+    {
+        bool failed;
+        try
+        {
+            const std::time_put<charT>& tp = std::use_facet<std::time_put<charT> >
+                                                           (os.getloc());
+            std::tm t;
+            t.tm_mday = item.day();
+            t.tm_mon = item.month() - 1;
+            t.tm_year = item.year() - 1900;
+            t.tm_wday = item.day_of_week();
+            charT pattern[2] = {'%', 'x'};
+            failed = tp.put(os, os, os.fill(), &t, pattern, pattern+2).failed();
+        }
+        catch (...)
+        {
+            failed = true;
+        }
+        if (failed)
+            os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+    }
+    return os;
+}
+
+}  // gregorian
+
+#endif  // DATE_H

Added: sandbox/committee/concepts/issues/issues/concepts-issues.xml
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/issues/concepts-issues.xml	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,190 @@
+<issueslist revision="C1"
+            maintainer="Douglas Gregor &lt;doug.gregor_at_[hidden]&gt;"
+            active_docno="Dxxxx=xx-xxxx"
+            defect_docno="Dxxxx=xx-xxxx"
+            closed_docno="Dxxxx=xx-xxxx"
+            date="2007-03-03"
+>
+
+<intros>
+<intro list="Active">
+  <p>Also see:</p>
+  <ul>
+      <li>Table of Contents for all concepts issues.</li>
+      <li>Index by Section for all concepts issues.</li>
+      <li>Index by Status for all concepts issues.</li>
+      <li>Concepts Defect Reports List</li>
+      <li>Concepts Closed Issues List</li>
+  </ul>
+  <p>The purpose of this document is to record the status of issues
+  which have been related to the authors of the C++ concepts
+  proposals. Issues represent potential defects in the language
+  or library proposals for concepts. </p>
+
+  <p>This document contains only issues which are actively being
+  considered for concepts. That is, issues which have a
+  status of New, Open, 
+  Ready, and Review. See
+  Concepts Defect Reports List for issues considered defects and 
+  Concepts Closed Issues List for issues considered closed.</p>
+
+</intro>
+
+<intro list="Defects">
+  <p>Also see:</p>
+    <ul>
+      <li>Table of Contents for all concepts issues.</li>
+      <li>Index by Section for all concepts issues.</li>
+      <li>Index by Status for all concepts issues.</li>
+      <li>Concepts Active Issues List</li>
+      <li>Concepts Closed Issues List</li>
+    </ul>
+  <p>This document contains only concepts issues which have been closed
+  after being found to be defects
+  in the proposal.  That is, issues which have a status of DR. See the
+  Concepts Closed Issues List for issues closed as non-defects.  See the
+  Concepts Active Issues List for active issues and more information.  The
+  introductory material in that document also applies to this
+  document.</p>
+</intro>
+
+<intro list="Closed">
+  <p>Also see:</p>
+    <ul>
+      <li>Table of Contents for all concepts issues.</li>
+      <li>Index by Section for all concepts issues.</li>
+      <li>Index by Status for all concepts issues.</li>
+      <li>Concepts Active Issues List</li>
+      <li>Concepts Defect Reports List</li>
+    </ul>
+
+  <p>This document contains only concepts issues which have been closed
+  by the concepts authors as duplicates or not defects. That is,
+  issues which have a status of Dup or
+  NAD. See the Concepts Active Issues List active issues and more
+  information. See the Concepts Defect Reports List for issues considered
+  defects.  The introductory material in that document also applies to
+  this document.</p>
+</intro>
+
+<intro list="TOC">
+  <p>This document is the Table of Contents for the Concepts Active Issues List,
+  Concepts Defect Reports List, and Concepts Closed Issues List.</p>
+
+  <p>Also see:</p>
+    <ul>
+      <li>Index by Section</li>
+      <li>Index by Status</li>
+    </ul>
+</intro>
+
+<intro list="Section">
+  <p>This document is the Index by Section for the Concepts Active Issues List,
+  Concepts Defect Reports List, and Concepts Closed Issues List.</p>
+
+  <p>Also see:</p>
+    <ul>
+      <li>Table of Contents</li>
+      <li>Index by Status</li>
+    </ul>
+</intro>
+
+<intro list="Status">
+  <p>This document is the Index by Status for the Concepts Active Issues List,
+  Concepts Defect Reports List, and Concepts Closed Issues List.</p>
+
+  <p>Also see:</p>
+    <ul>
+      <li>Table of Contents</li>
+      <li>Index by Section</li>
+    </ul>
+</intro>
+
+</intros>
+
+<revision_history>
+
+<revision tag="C1">
+Initial version. (3 Mar 2008)
+</revision>
+
+</revision_history>
+
+<statuses>
+  <p><b><a name="New">New</a></b> - The issue has not yet been
+  reviewed. Any <b>Proposed Resolution</b> is purely a
+  suggestion from the issue submitter, and should not be construed as
+  the view of the committee.</p>
+
+  <p><b><a name="Open">Open</a></b> - The committee has discussed the issue
+  but is not yet ready to move the issue forward. There are several
+  possible reasons for open status:</p>
+     <ul>
+        <li>Consensus may have not yet have been reached as to how to deal
+            with the issue.</li>
+        <li>Informal consensus may have been reached, but the committee awaits
+            exact <b>Proposed Resolution</b> wording for review.</li>
+        <li>The committee wishes to consult additional technical experts before
+            proceeding.</li>
+        <li>The issue may require further study.</li>
+     </ul>
+
+  <p>A <b>Proposed Resolution</b> for an open issue is still not be
+  construed as the view of committee. Comments on the current state of
+  discussions are often given at the end of open issues in an italic
+  font. Such comments are for information only and should not be given
+  undue importance.</p>
+
+  <p><b><a name="Dup">Dup</a></b> - The committee has reached consensus that
+  the issue is a duplicate of another issue, and will not be further
+  dealt with. A <b>Rationale</b> identifies the duplicated issue's
+  issue number.  </p>
+
+  <p><b><a name="NAD">NAD</a></b> - The committee has reached consensus that
+  the issue is not a defect in the Standard.</p>
+
+  <p><b><a name="NAD Editorial">NAD Editorial</a></b> - The committee has reached consensus that
+  the issue can either be handled editorially, or is handled by a paper (usually
+  linked to in the rationale).</p>
+
+  <p><b><a name="NAD Future">NAD Future</a></b> - In addition to the regular
+  status, the committee believes that this issue should be revisited at the
+  next revision of the standard.</p>
+
+  <p><b><a name="Review">Review</a></b> - Exact wording of a
+  <b>Proposed Resolution</b> is now available for review on an issue
+  for which the committee previously reached informal consensus.</p>
+
+  <p><b><a name="Ready">Ready</a></b> - The committee has reached
+  consensus that the issue is a defect in the concepts proposal,
+  the <b>Proposed Resolution</b> is correct, and the issue is ready to
+  be integrated into the next concepts proposal.</p>
+
+  <p><b><a name="DR">DR</a></b> - (Defect Report) - The committee has
+  decided to accept the proposed resolution and the resolution is part
+  of a concepts proposal draft.</p>
+
+  <p><b>Pending</b> - This is a <i>status qualifier</i>.  When prepended to
+  a status this indicates the issue has been
+  processed by the committee, and a decision has been made to move the issue to
+  the associated unqualified status.  However for logistical reasons the indicated
+  outcome of the issue has not yet appeared in the latest working paper.
+
+  <p>Issues are always given the status of New when
+  they first appear on the issues list. They may progress to
+  Open or Review while the committee
+  is actively working on them. When the committee has reached consensus on
+  the disposition of an issue, the status will then change to
+  Dup, NAD, or
+  Ready as appropriate.  Once
+  a Ready issue has made it into a draft of the concepts proposal, it
+  is given the status of Defect Report
+  ( DR). To streamline the
+  process for concepts (since it is still a proposal, not part of the
+  committee working paper), we will often skip the Review or Ready
+  status.
+  </p>
+
+</statuses>
+
+</issueslist>

Added: sandbox/committee/concepts/issues/issues/concepts-template.xml
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/issues/concepts-template.xml	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,22 @@
+<?xml version='1.0' encoding='iso-8859-1' standalone='no'?>
+<!DOCTYPE issue SYSTEM "lwg-issue.dtd" [ 
+  <!ENTITY nbsp "&#160;">
+] >
+
+<issue num="???" status="New">
+<title>Your Title</title>
+<section><sref ref="00.0.0"/></section>
+<submitter>Your name</submitter>
+<date>29 Feb 1900</date>
+
+<discussion>
+<p>
+</p>
+</discussion>
+
+<resolution>
+<p>
+</p>
+</resolution>
+
+</issue>

Added: sandbox/committee/concepts/issues/issues/issue1.xml
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/issues/issue1.xml	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,39 @@
+<?xml version='1.0' encoding='iso-8859-1' standalone='no'?>
+<!DOCTYPE issue SYSTEM "lwg-issue.dtd" [ 
+  <!ENTITY nbsp "&#160;">
+] >
+
+<issue num="1" status="New">
+  <title>Naming and symmetry in EqualityComparable</title> 
+  <section><sref ref="[concept.comparison]"/></section>
+  <submitter>LWG</submitter>
+  <date>27 Feb 2008</date>
+
+  <discussion>
+    <p>Another way to characterize the problem with EqualityComparable:
+    the name suggests that it's a concept with semantics, one that's
+    based on some kind of mathematical notion. At the Bloomington
+    discussion there was a different naming convention for concepts
+    that are purely syntactic; e.g. HasPlus, as opposed to "Addable",
+    for a concept that doesn't mean anything more than that a +
+    exists. The two-parameter EqualityComparable really falls into
+    that category, since all it really means is that there's some kind
+    of operation spelled == and we're not saying what it does. The
+    one-parameter version of EqualityComparable really is
+      EqualityComparable, though, and it does have mathematical axioms.</p>
+
+    <p>General issue: do we accept the naming convention that purely
+      syntactic concepts should be named Has*?</p>
+
+    <p>If we do have a two-parameter HasEquals, do we also want it to
+      provide != ? In other words, does it have any kind of semantic
+      coherency?  </p>
+
+    <p>Can we make the two-parameter HasEquals symmetrical? That is:
+      if we say that there is a HasEquals for types T and U, and if t
+      and u are variables of the appropriate types, can we at least
+      say that t == u and u == t are both allowed and both mean the
+      same thing? Is there any way to write defaults in the concept
+      definition that won't ever give us an infinite loop?</p>
+  </discussion>
+</issue>

Added: sandbox/committee/concepts/issues/main.cpp
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/main.cpp	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,1498 @@
+#include <sstream>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <iterator>
+#include <stdexcept>
+#include <cctype>
+#include <cassert>
+#include <sys/types.h>
+#include <dirent.h>
+#include "date.h"
+
+namespace greg = gregorian;
+
+std::string insert_color("ins {background-color:#A0FFA0}\n");
+std::string delete_color("del {background-color:#FFA0A0}\n");
+
+std::string path;
+std::string issues_path;
+
+std::string
+remove_pending(std::string stat)
+{
+    typedef std::string::size_type size_type;
+    if (stat.find("Pending") == 0)
+        stat.erase(size_type(0), size_type(8));
+    return stat;
+}
+
+std::string
+find_file(std::string stat)
+{
+    stat = remove_pending(stat);
+    if (stat == "TC")
+        return "concepts-defects.html";
+    if (stat == "WP")
+        return "concepts-defects.html";
+    if (stat == "DR")
+        return "concepts-defects.html";
+    if (stat == "TRDec")
+        return "concepts-defects.html";
+    if (stat == "Dup")
+        return "concepts-closed.html";
+    if (stat == "NAD")
+        return "concepts-closed.html";
+    if (stat == "NAD Future")
+        return "concepts-closed.html";
+    if (stat == "NAD Editorial")
+        return "concepts-closed.html";
+    if (stat == "Ready")
+        return "concepts-active.html";
+    if (stat == "Tentatively Ready")
+        return "concepts-active.html";
+    if (stat == "Review")
+        return "concepts-active.html";
+    if (stat == "New")
+        return "concepts-active.html";
+    if (stat == "Open")
+        return "concepts-active.html";
+    throw std::runtime_error("unknown status " + stat);
+}
+
+bool
+is_active(const std::string& stat)
+{
+    return find_file(stat) == "concepts-active.html";
+}
+
+bool
+is_defect(const std::string& stat)
+{
+    return find_file(stat) == "concepts-defects.html";
+}
+
+bool
+is_closed(const std::string& stat)
+{
+    return find_file(stat) == "concepts-closed.html";
+}
+
+struct section_num
+{
+    std::string prefix;
+    std::vector<int> num;
+
+};
+
+std::istream&
+operator >> (std::istream& is, section_num& sn)
+{
+    sn.prefix.clear();
+    sn.num.clear();
+    ws(is);
+    if (is.peek() == 'T')
+    {
+        is.get();
+        if (is.peek() == 'R')
+        {
+            std::string w;
+            is >> w;
+            if (w == "R1")
+                sn.prefix = "TR1";
+            else if (w == "RDecimal")
+                sn.prefix = "TRDecimal";
+            else
+                throw std::runtime_error("section_num format error");
+            ws(is);
+        }
+        else
+        {
+            sn.num.push_back(100 + 'T' - 'A');
+            if (is.peek() != '.')
+                return is;
+             is.get();
+        }
+    }
+    while (true)
+    {
+        if (std::isdigit(is.peek()))
+        {
+            int n;
+            is >> n;
+            sn.num.push_back(n);
+        }
+        else
+        {
+            char c;
+            is >> c;
+            sn.num.push_back(100 + c - 'A');
+        }
+        if (is.peek() != '.')
+            break;
+        char dot;
+        is >> dot;
+    }
+    return is;
+}
+
+std::ostream&
+operator << (std::ostream& os, const section_num& sn)
+{
+    if (!sn.prefix.empty())
+        os << sn.prefix << " ";
+    if (sn.num.size() > 0)
+    {
+        if (sn.num.front() >= 100)
+            os << char(sn.num.front() - 100 + 'A');
+        else
+            os << sn.num.front();
+        for (unsigned i = 1; i < sn.num.size(); ++i)
+        {
+            os << '.';
+            if (sn.num[i] >= 100)
+                os << char(sn.num[i] - 100 + 'A');
+            else
+                os << sn.num[i];
+        }
+    }
+    return os;
+}
+
+bool
+operator<(const section_num& x, const section_num& y)
+{
+    if (x.prefix < y.prefix)
+        return true;
+    else if (y.prefix < x.prefix)
+        return false;
+    return x.num < y.num;
+}
+
+bool
+operator==(const section_num& x, const section_num& y)
+{
+    if (x.prefix != y.prefix)
+        return false;
+    return x.num == y.num;
+}
+
+bool
+operator!=(const section_num& x, const section_num& y)
+{
+    return !(x == y);
+}
+
+typedef std::string section_tag;
+
+struct issue
+{
+    int num;
+    std::string stat;
+    std::string title;
+    std::vector<section_tag> tags;
+    std::string submitter;
+    greg::date date;
+    std::vector<std::string> duplicates;
+    std::string text;
+    bool has_resolution;
+};
+
+typedef std::map<section_tag, section_num> SectionMap;
+SectionMap section_db;
+
+section_tag
+remove_square_brackets(const section_tag& tag)
+{
+    assert(tag.size() > 2);
+    assert(tag[0] == '[');
+    assert(tag[tag.size()-1] == ']');
+    return tag.substr(1, tag.size()-2);
+}
+
+struct sort_by_section
+{
+    bool operator()(const issue& x, const issue& y)
+    {
+        return section_db[x.tags[0]] < section_db[y.tags[0]];
+    }
+};
+
+struct sort_by_num
+{
+    bool operator()(const issue& x, const issue& y) const
+    {
+        return x.num < y.num;
+    }
+    bool operator()(const issue& x, int y) const
+    {
+        return x.num < y;
+    }
+    bool operator()(int x, const issue& y) const
+    {
+        return x < y.num;
+    }
+};
+
+struct sort_by_status
+{
+    bool operator()(const issue& x, const issue& y) const
+    {
+        if (is_active(x.stat) && !is_active(y.stat))
+            return true;
+        if (!is_active(x.stat) && is_active(y.stat))
+            return false;
+        return x.stat < y.stat;
+    }
+};
+
+struct sort_by_first_tag
+{
+    bool operator()(const issue& x, const issue& y) const
+    {
+        return x.tags[0] < y.tags[0];
+    }
+};
+
+struct equal_issue_num
+{
+    bool operator()(const issue& x, int y) {return x.num == y;}
+    bool operator()(int x, const issue& y) {return x == y.num;}
+};
+
+/*
+void display(const std::vector<issue>& issues)
+{
+    for (unsigned i = 0; i < issues.size(); ++i)
+        std::cout << issues[i];
+}
+*/
+SectionMap
+read_section_db()
+{
+    SectionMap section_db;
+    std::ifstream infile((path + "section.data").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Can't open section.data\n");
+    while (infile)
+    {
+        ws(infile);
+        std::string line;
+        getline(infile, line);
+        if (!line.empty())
+        {
+            assert(line[line.size()-1] == ']');
+            unsigned p = line.rfind('[');
+            assert(p != std::string::npos);
+            section_tag tag = line.substr(p);
+            assert(tag.size() > 2);
+            assert(tag[0] == '[');
+            assert(tag[tag.size()-1] == ']');
+            line.erase(p-1);
+            section_num num;
+            if (tag.find("[trdec.") != std::string::npos)
+            {
+                num.prefix = "TRDecimal";
+                line.erase(0, 10);
+            }
+            else if (tag.find("[tr.") != std::string::npos)
+            {
+                num.prefix = "TR1";
+                line.erase(0, 4);
+            }
+            std::istringstream temp(line);
+            if (!std::isdigit(line[0]))
+            {
+                char c;
+                temp >> c;
+                num.num.push_back(100 + c - 'A');
+                temp >> c;
+            }
+            while (temp)
+            {
+                int n;
+                temp >> n;
+                if (!temp.fail())
+                {
+                    num.num.push_back(n);
+                    char dot;
+                    temp >> dot;
+                }
+            }
+            section_db[tag] = num;
+        }
+    }
+    return section_db;
+}
+
+void
+check_against_index(const SectionMap& section_db)
+{
+    SectionMap::const_iterator s_db = section_db.begin();
+    SectionMap::const_iterator e_db = section_db.end();
+    for (SectionMap::const_iterator s_db = section_db.begin(), e_db = section_db.end(); s_db != e_db; ++s_db)
+    {
+        std::string temp = s_db->first;
+        temp.erase(temp.end()-1);
+        temp.erase(temp.begin());
+        std::cout << temp << ' ' << s_db->second << '\n';
+    }
+}
+
+std::string
+get_revision()
+{
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find("revision=\"");
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find revision in concepts-issues.xml");
+    i += sizeof("revision=\"") - 1;
+    unsigned j = s.find('\"', i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse revision in concepts-issues.xml");
+    return s.substr(i, j-i);
+}
+
+std::string
+get_maintainer()
+{
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find("maintainer=\"");
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find maintainer in concepts-issues.xml");
+    i += sizeof("maintainer=\"") - 1;
+    unsigned j = s.find('\"', i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse maintainer in concepts-issues.xml");
+    std::string r = s.substr(i, j-i);
+    std::size_t m = r.find("&lt;");
+    if (m == std::string::npos)
+        throw std::runtime_error("Unable to parse maintainer email address in concepts-issues.xml");
+    m += sizeof("&lt;") - 1;
+    std::size_t me = r.find("&gt;", m);
+    if (me == std::string::npos)
+        throw std::runtime_error("Unable to parse maintainer email address in concepts-issues.xml");
+    std::string email = r.substr(m, me-m);
+    // &lt;                                          howard.hinnant_at_[hidden]    &gt;
+    // &lt;<a href="mailto:howard.hinnant_at_[hidden]">howard.hinnant_at_[hidden]</a>&gt;
+    r.replace(m, me-m, "<a href=\"mailto:" + email + "\">" + email + "</a>");
+    return r;
+}
+
+std::string
+get_date()
+{
+#if 1
+    greg::date today;
+    std::ostringstream date;
+    date << today.year() << '-';
+    if (today.month() < 10)
+        date << '0';
+    date << today.month() << '-';
+    if (today.day() < 10)
+        date << '0';
+    date << today.day();
+    return date.str();
+#else
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find("date=\"");
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find date in concepts-issues.xml");
+    i += sizeof("date=\"") - 1;
+    unsigned j = s.find('\"', i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse date in concepts-issues.xml");
+    return s.substr(i, j-i);
+#endif
+}
+
+std::string
+get_doc_number(std::string doc)
+{
+    if (doc == "active")
+        doc = "active_docno=\"";
+    else if (doc == "defect")
+        doc = "defect_docno=\"";
+    else if (doc == "closed")
+        doc = "closed_docno=\"";
+    else
+        throw std::runtime_error("unknown argument to get_doc_number: " + doc);
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find(doc);
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find docno in concepts-issues.xml");
+    i += doc.size();
+    unsigned j = s.find('\"', i+1);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse docno in concepts-issues.xml");
+    return s.substr(i, j-i);
+}
+
+std::string
+get_intro(std::string doc)
+{
+    if (doc == "active")
+        doc = "<intro list=\"Active\">";
+    else if (doc == "defect")
+        doc = "<intro list=\"Defects\">";
+    else if (doc == "closed")
+        doc = "<intro list=\"Closed\">";
+    else
+        throw std::runtime_error("unknown argument to intro: " + doc);
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find(doc);
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find intro in concepts-issues.xml");
+    i += doc.size();
+    unsigned j = s.find("</intro>", i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse intro in concepts-issues.xml");
+    return s.substr(i, j-i);
+}
+
+void format(std::vector<issue>& issues, issue& is)
+{
+    std::string& s = is.text;
+    int issue_num = is.num;
+    std::vector<std::string> tag_stack;
+    std::ostringstream er;
+    for (unsigned i = 0; i < s.size(); ++i)
+    {
+        if (s[i] == '<')
+        {
+            unsigned j = s.find('>', i);
+            if (j == std::string::npos)
+            {
+                er.clear();
+                er.str("");
+                er << "missing '>' in issue " << issue_num;
+                throw std::runtime_error(er.str());
+            }
+            std::string tag;
+            {
+            std::istringstream iword(s.substr(i+1, j-i-1));
+            iword >> tag;
+            }
+            if (tag.empty())
+            {
+                er.clear();
+                er.str("");
+                er << "unexpected <> in issue " << issue_num;
+                throw std::runtime_error(er.str());
+            }
+            if (tag[0] == '/')  // closing tag
+            {
+                tag.erase(tag.begin());
+                if (tag == "issue" || tag == "revision")
+                {
+                    s.erase(i, j-i + 1);
+                    --i;
+                    return;
+                }
+                if (tag_stack.empty() || tag != tag_stack.back())
+                {
+                    er.clear();
+                    er.str("");
+                    er << "mismatched tags in issue " << issue_num;
+                    if (tag_stack.empty())
+                        er << ".  Had no open tag.";
+                    else
+                        er << ".  Open tag was " << tag_stack.back() << ".";
+                    er << "  Closing tag was " << tag;
+                    throw std::runtime_error(er.str());
+                }
+                tag_stack.pop_back();
+                if (tag == "discussion")
+                {
+                    s.erase(i, j-i + 1);
+                    --i;
+                }
+                else if (tag == "resolution")
+                {
+                    s.erase(i, j-i + 1);
+                    --i;
+                }
+                else if (tag == "rationale")
+                {
+                    s.erase(i, j-i + 1);
+                    --i;
+                }
+                else if (tag == "duplicate")
+                {
+                    s.erase(i, j-i + 1);
+                    --i;
+                }
+                else if (tag == "note")
+                {
+                    s.replace(i, j-i + 1, "]</i></p>\n");
+                    i += 9;
+                }
+                else
+                    i = j;
+                continue;
+            }
+            if (s[j-1] == '/')  // self-contained tag: sref, iref
+            {
+                if (tag == "sref")
+                {
+                    std::string r;
+                    unsigned k = s.find('\"', i+5);
+                    if (k >= j)
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "missing '\"' in sref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    unsigned l = s.find('\"', k+1);
+                    if (l >= j)
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "missing '\"' in sref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    ++k;
+                    r = s.substr(k, l-k);
+                    {
+                    std::ostringstream t;
+                    t << section_db[r] << ' ';
+                    r.insert(0, t.str());
+                    }
+                    j -= i - 1;
+                    s.replace(i, j, r);
+                    i += r.size() - 1;
+                    continue;
+                }
+                else if (tag == "iref")
+                {
+                    std::string r;
+                    unsigned k = s.find('\"', i+5);
+                    if (k >= j)
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "missing '\"' in iref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    unsigned l = s.find('\"', k+1);
+                    if (l >= j)
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "missing '\"' in iref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    ++k;
+                    r = s.substr(k, l-k);
+                    std::istringstream temp(r);
+                    int num;
+                    temp >> num;
+                    if (temp.fail())
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "bad number in iref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    std::vector<issue>::iterator n = std::lower_bound(issues.begin(), issues.end(), num, sort_by_num());
+                    if (n->num != num)
+                    {
+                        er.clear();
+                        er.str("");
+                        er << "couldn't find number in iref in issue " << issue_num;
+                        throw std::runtime_error(er.str());
+                    }
+                    if (!tag_stack.empty() && tag_stack.back() == "duplicate")
+                    {
+                        std::ostringstream temp;
+                        temp << is.num;
+                        std::string d = "<a href=\"";
+                        d += find_file(is.stat);
+                        d += '#';
+                        d += temp.str();
+                        d += "\">";
+                        d += temp.str();
+                        d += "</a>";
+                        n->duplicates.push_back(d);
+                        temp.str("");
+                        temp << n->num;
+                        d = "<a href=\"";
+                        d += find_file(n->stat);
+                        d += '#';
+                        d += temp.str();
+                        d += "\">";
+                        d += temp.str();
+                        d += "</a>";
+                        is.duplicates.push_back(d);
+                        r.clear();
+                    }
+                    else
+                    {
+                        r = "<a href=\"";
+                        r += find_file(n->stat);
+                        r += '#';
+                        std::string ns;
+                        {
+                        std::ostringstream t;
+                        t << num;
+                        ns = t.str();
+                        }
+                        r += ns;
+                        r += "\">";
+                        r += ns;
+                        r += "</a>";
+                    }
+                    j -= i - 1;
+                    s.replace(i, j, r);
+                    i += r.size() - 1;
+                    continue;
+                }
+                i = j;
+                continue;  // don't worry about this <tag/>
+            }
+            tag_stack.push_back(tag);
+            if (tag == "discussion")
+            {
+                s.replace(i, j-i + 1, "<p><b>Discussion:</b></p>");
+                i += 24;
+            }
+            else if (tag == "resolution")
+            {
+                s.replace(i, j-i + 1, "<p><b>Proposed resolution:</b></p>");
+                i += 33;
+            }
+            else if (tag == "rationale")
+            {
+                s.replace(i, j-i + 1, "<p><b>Rationale:</b></p>");
+                i += 23;
+            }
+            else if (tag == "duplicate")
+            {
+                s.erase(i, j-i + 1);
+                --i;
+            }
+            else if (tag == "note")
+            {
+                s.replace(i, j-i + 1, "<p><i>[");
+                i += 6;
+            }
+            else if (tag == "!--")
+            {
+                tag_stack.pop_back();
+                j = s.find("-->", i);
+                j += 3;
+                s.erase(i, j-i);
+                --i;
+            }
+            else
+                i = j;
+        }
+    }
+}
+
+std::string
+get_revisions(std::vector<issue>& issues)
+{
+    std::string r = "<ul>\n";
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find("<revision_history>");
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find <revision_history> in concepts-issues.xml");
+    i += sizeof("<revision_history>") - 1;
+    unsigned j = s.find("</revision_history>", i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to find </revision_history> in concepts-issues.xml");
+    s = s.substr(i, j-i);
+    j = 0;
+    while (true)
+    {
+        i = s.find("<revision tag=\"", j);
+        if (i == std::string::npos)
+            break;
+        i += sizeof("<revision tag=\"") - 1;
+        j = s.find('\"', i);
+        std::string rv = s.substr(i, j-i);
+        i = j+2;
+        j = s.find("</revision>", i);
+        issue is;
+        is.text = s.substr(i, j-i);
+        format(issues, is);
+        r += "<li>";
+        r += rv + ": ";
+        r += is.text;
+        r += "</li>\n";
+    }
+    r += "</ul>\n";
+    return r;
+}
+
+std::string
+get_statuses()
+{
+    std::ifstream infile((issues_path + "concepts-issues.xml").c_str());
+    if (!infile.is_open())
+        throw std::runtime_error("Unable to open concepts-issues.xml");
+    std::istreambuf_iterator<char> first(infile), last;
+    std::string s(first, last);
+    unsigned i = s.find("<statuses>");
+    if (i == std::string::npos)
+        throw std::runtime_error("Unable to find statuses in concepts-issues.xml");
+    i += sizeof("<statuses>") - 1;
+    unsigned j = s.find("</statuses>", i);
+    if (j == std::string::npos)
+        throw std::runtime_error("Unable to parse statuses in concepts-issues.xml");
+    return s.substr(i, j-i);
+}
+
+void
+print_table(std::ostream& out, std::vector<issue>::const_iterator i, std::vector<issue>::const_iterator e)
+{
+    std::string prev_tag;
+    for (; i != e; ++i)
+    {
+        out << "<tr>\n";
+
+        // Number
+        out << "<td align=\"right\"><a href=\"";
+        out << find_file(i->stat);
+        out << '#';
+        out << i->num;
+        out << "\">";
+        out << i->num;
+        out << "</a></td>\n";
+
+        // Status
+        out << "<td align=\"left\"><a href=\"concepts-active.html#";
+        out << remove_pending(i->stat);
+        out << "\">";
+        out << i->stat;
+        out << "</a></td>\n";
+
+        // Section
+        out << "<td align=\"left\">";
+        out << section_db[i->tags[0]] << " " << i->tags[0];
+        if (i->tags[0] != prev_tag)
+        {
+            prev_tag = i->tags[0];
+            out << "<a name=\"" << remove_square_brackets(prev_tag) << "\"</a>";
+        }
+        out << "</td>\n";
+
+        // Title
+        out << "<td align=\"left\">";
+        out << i->title;
+        out << "</td>\n";
+
+        // Has Proposed Resolution
+        out << "<td align=\"center\">";
+        if (i->has_resolution)
+            out << "Yes";
+        else
+            out << "<font color=\"red\">No</font>";
+        out << "</td>\n";
+
+        // Duplicates
+        out << "<td align=\"left\">";
+        if (!i->duplicates.empty())
+        {
+            out << i->duplicates[0];
+            for (unsigned j = 1; j < i->duplicates.size(); ++j)
+                out << ", " << i->duplicates[j];
+        }
+        out << "</td>\n";
+
+        out << "</tr>\n";
+    }
+    out << "</table>\n";
+}
+
+void print_file_header(std::ostream& out, const std::string& title)
+{
+    out << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n";
+    out << "    \"http://www.w3.org/TR/html4/strict.dtd\">\n";
+    out << "<html>\n";
+    out << "<head>\n";
+    out << "<title>" << title << "</title>\n";
+    out << "<style type=\"text/css\">\n";
+    out << "p {text-align:justify}\n";
+    out << "li {text-align:justify}\n";
+    out << insert_color;
+    out << delete_color;
+    out << "</style>\n";
+    out << "</head>\n";
+    out << "<body>\n";
+}
+
+void print_file_trailer(std::ostream& out)
+{
+    out << "</body>\n";
+    out << "</html>\n";
+}
+
+void make_sort_by_num(std::vector<issue>& issues)
+{
+    std::ofstream out((path + "concepts-toc.html").c_str());
+    out << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n";
+    out << "    \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n";
+    out << "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n";
+    out << "<head>\n";
+    out << "<title>Concepts Issues List Table of Contents</title>\n";
+    out << "<style type=\"text/css\">\n";
+    out << "p {text-align:justify}\n";
+    out << "li {text-align:justify}\n";
+    out << insert_color;
+    out << delete_color;
+    out << "</style>\n";
+    out << "</head>\n";
+    out << "<body>\n";
+
+    out << "<h1>C++ Concepts Issues List (Revision " << get_revision() << ")</h1>\n";
+    out << "<h1>Table of Contents</h1>\n";
+    out << "<p>Reference ISO/IEC IS 14882:1998(E)</p>\n";
+    out << "<p>This document is the Table of Contents for the <a href=\"concepts-active.html\">Concepts Active Issues List</a>,"
+           " <a href=\"concepts-defects.html\">Concepts Defect Reports List</a>, and <a href=\"concepts-closed.html\">Concepts Closed Issues List</a>.</p>\n";
+    out << "<h2>Table of Contents</h2>\n";
+
+    out << "<table border=\"1\" cellpadding=\"4\">\n";
+    out << "<tr>\n";
+    out << "<td align=\"center\"><b>Issue</b></td>\n";
+    out << "<td align=\"center\"><a href=\"concepts-status.html\"><b>Status</b></a></td>\n";
+    out << "<td align=\"center\"><a href=\"concepts-index.html\"><b>Section</b></a></td>\n";
+    out << "<td align=\"center\"><b>Title</b></td>\n";
+    out << "<td align=\"center\"><b>Proposed Resolution</b></td>\n";
+    out << "<td align=\"center\"><b>Duplicates</b></td></tr>\n";
+
+    sort(issues.begin(), issues.end(), sort_by_num());
+    print_table(out, issues.begin(), issues.end());
+
+    out << "</body>\n";
+    out << "</html>\n";
+
+}
+
+void make_sort_by_status(std::vector<issue>& issues)
+{
+    std::ofstream out((path + "concepts-status.html").c_str());
+    out << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n";
+    out << "    \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n";
+    out << "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n";
+    out << "<head>\n";
+    out << "<title>Concepts Issues List Table of Contents</title>\n";
+    out << "<style type=\"text/css\">\n";
+    out << "p {text-align:justify}\n";
+    out << "li {text-align:justify}\n";
+    out << insert_color;
+    out << delete_color;
+    out << "</style>\n";
+    out << "</head>\n";
+    out << "<body>\n";
+
+    out << "<h1>C++ Concepts Issues List (Revision " << get_revision() << ")</h1>\n";
+    out << "<h1>Table of Contents</h1>\n";
+    out << "<p>Reference ISO/IEC IS 14882:1998(E)</p>\n";
+    out << "<p>This document is the Table of Contents for the <a href=\"concepts-active.html\">Concepts Active Issues List</a>,"
+           " <a href=\"concepts-defects.html\">Concepts Defect Reports List</a>, and <a href=\"concepts-closed.html\">Concepts Closed Issues List</a>.</p>\n";
+
+    out << "<h2>Index by Status</h2>\n";
+
+    sort(issues.begin(), issues.end(), sort_by_num());
+    stable_sort(issues.begin(), issues.end(), sort_by_section());
+    stable_sort(issues.begin(), issues.end(), sort_by_status());
+
+    for (std::vector<issue>::const_iterator i = issues.begin(), e = issues.end(); i != e;)
+    {
+
+        std::string current_status = i->stat;
+        std::vector<issue>::const_iterator j = i;
+        for (; j != e; ++j)
+        {
+            if (j->stat != current_status)
+                break;
+        }
+        out << "<h2><a name=\"" << current_status << "\"</a>" << current_status << " (" << (j-i) << " issues)</h2>\n";
+
+        out << "<table border=\"1\" cellpadding=\"4\">\n";
+        out << "<tr>\n";
+        out << "<td align=\"center\"><a href=\"concepts-toc.html\"><b>Issue</b></a></td>\n";
+        out << "<td align=\"center\"><b>Status</b></td>\n";
+        out << "<td align=\"center\"><a href=\"concepts-index.html\"><b>Section</b></a></td>\n";
+        out << "<td align=\"center\"><b>Title</b></td>\n";
+        out << "<td align=\"center\"><b>Proposed Resolution</b></td>\n";
+        out << "<td align=\"center\"><b>Duplicates</b></td></tr>\n";
+
+        print_table(out, i, j);
+        i = j;
+    }
+
+    out << "</body>\n";
+    out << "</html>\n";
+
+}
+
+std::string
+major_section(const section_num& sn)
+{
+    std::ostringstream out;
+    std::string prefix = sn.prefix;
+    if (!prefix.empty())
+        out << prefix << " ";
+    if (sn.num[0] < 100)
+        out << sn.num[0];
+    else
+        out << char(sn.num[0] - 100 + 'A');
+    return out.str();
+}
+
+struct sort_by_mjr_section
+{
+    bool operator()(const issue& x, const issue& y) const
+    {
+        return section_db[x.tags[0]].num[0] < section_db[y.tags[0]].num[0];
+    }
+};
+
+void make_sort_by_section(std::vector<issue>& issues, bool active_only = false)
+{
+    std::string filename;
+    if (active_only)
+        filename = path + "concepts-index-open.html";
+    else
+        filename = path + "concepts-index.html";
+    std::ofstream out(filename.c_str());
+    out << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n";
+    out << "    \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n";
+    out << "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n";
+    out << "<head>\n";
+    out << "<title>Concepts Issues List Table of Contents</title>\n";
+    out << "<style type=\"text/css\">\n";
+    out << "p {text-align:justify}\n";
+    out << "li {text-align:justify}\n";
+    out << insert_color;
+    out << delete_color;
+    out << "</style>\n";
+    out << "</head>\n";
+    out << "<body>\n";
+
+    out << "<h1>C++ Concepts Issues List (Revision " << get_revision() << ")</h1>\n";
+    out << "<h1>Table of Contents</h1>\n";
+    out << "<p>Reference ISO/IEC IS 14882:1998(E)</p>\n";
+    out << "<p>This document is the Table of Contents for the <a href=\"concepts-active.html\">Concepts Active Issues List</a>,"
+           " <a href=\"concepts-defects.html\">Concepts Defect Reports List</a>, and <a href=\"concepts-closed.html\">Concepts Closed Issues List</a>.</p>\n";
+    out << "<h2>Index by Section";
+    if (active_only)
+        out << " (active issues only)";
+    out << "</h2>\n";
+    if (active_only)
+        out << "<p><a href=\"concepts-index.html\">(view all issues)</a></p>\n";
+    else
+        out << "<p><a href=\"concepts-index-open.html\">(view only open issues)</a></p>\n";
+    sort(issues.begin(), issues.end(), sort_by_num());
+    stable_sort(issues.begin(), issues.end(), sort_by_status());
+    std::vector<issue>::iterator e = issues.end();
+    if (active_only)
+    {
+        std::vector<issue>::iterator j;
+        for (j = issues.begin(); j != e; ++j)
+        {
+            if (!is_active(j->stat))
+                break;
+        }
+        e = j;
+    }
+    stable_sort(issues.begin(), e, sort_by_section());
+    std::set<issue, sort_by_mjr_section> mjr_section_open;
+    for (std::vector<issue>::const_iterator i = issues.begin(), e = issues.end(); i != e; ++i)
+        if (is_active(i->stat))
+            mjr_section_open.insert(*i);
+
+    for (std::vector<issue>::const_iterator i = issues.begin(); i != e;)
+    {
+        int current_num = section_db[i->tags[0]].num[0];
+        std::vector<issue>::const_iterator j = i;
+        for (; j != e; ++j)
+        {
+            if (section_db[j->tags[0]].num[0] != current_num)
+                break;
+        }
+        std::string msn = major_section(section_db[i->tags[0]]);
+        out << "<h2><a name=\"Section " << msn << "\"></a>" << "Section " << msn;
+        out << " (" << (j-i) << " issues)</h2>\n";
+        out << "<p>";
+        if (active_only)
+            out << "<a href=\"concepts-index.html#Section " << msn << "\">(view all issues)</a>";
+        else if (mjr_section_open.count(*i) > 0)
+            out << "<a href=\"concepts-index-open.html#Section " << msn << "\">(view only open issues)</a>";
+        out << "</p>\n";
+
+        out << "<table border=\"1\" cellpadding=\"4\">\n";
+        out << "<tr>\n";
+        out << "<td align=\"center\"><a href=\"concepts-toc.html\"><b>Issue</b></a></td>\n";
+        out << "<td align=\"center\"><a href=\"concepts-status.html\"><b>Status</b></a></td>\n";
+        out << "<td align=\"center\"><b>Section</b></td>\n";
+        out << "<td align=\"center\"><b>Title</b></td>\n";
+        out << "<td align=\"center\"><b>Proposed Resolution</b></td>\n";
+        out << "<td align=\"center\"><b>Duplicates</b></td></tr>\n";
+
+        print_table(out, i, j);
+        i = j;
+    }
+
+    out << "</body>\n";
+    out << "</html>\n";
+
+}
+
+struct if_active
+{
+    bool operator()(const issue& i) {return is_active(i.stat);}
+};
+
+template <class Pred>
+void
+print_issues(std::ostream& out, const std::vector<issue>& issues, Pred pred)
+{
+    std::multiset<issue, sort_by_first_tag> all_issues(issues.begin(), issues.end());
+    std::multiset<issue, sort_by_first_tag> active_issues;
+    for (std::vector<issue>::const_iterator i = issues.begin(), e = issues.end(); i != e; ++i)
+    {
+        if (if_active()(*i))
+            active_issues.insert(*i);
+    }
+    std::multiset<issue, sort_by_status> issues_by_status(issues.begin(), issues.end());
+    for (std::vector<issue>::const_iterator i = issues.begin(), e = issues.end(); i != e; ++i)
+    {
+        if (pred(*i))
+        {
+            out << "<hr>\n";
+    
+            // Number and title
+            out << "<h3>";
+            out << "<a name=\"";
+            out << i->num;
+            out << "\"></a>";
+            out << i->num << ". " << i->title << "</h3>\n";
+    
+            // Section, Status, Submitter, Date
+            out << "<p><b>Section:</b> ";
+            out << section_db[i->tags[0]] << " " << i->tags[0];
+            for (unsigned k = 1; k < i->tags.size(); ++k)
+                out << ", " << section_db[i->tags[k]] << " " << i->tags[k];
+            out << " <b>Status:</b> <a href=\"concepts-active.html#" << remove_pending(i->stat) << "\">" << i->stat << "</a>\n";
+            out << " <b>Submitter:</b> " << i->submitter;
+            out << " <b>Date:</b> " << i->date.year() << '-';
+            if (i->date.month() < 10)
+                out << '0';
+            out << i->date.month() << '-';
+            if (i->date.day() < 10)
+                out << '0';
+            out << i->date.day() << "</p>\n";
+
+            // view active issues in []
+            if (active_issues.count(*i) > 1)
+                out << "<p><b>View other</b> " << "<a href=\"" << "concepts-index-open.html#" << remove_square_brackets(i->tags[0])
+                    << "\">" << "active issues</a> in " << i->tags[0] << ".</p>\n";
+
+            // view all issues in []
+            if (all_issues.count(*i) > 1)
+                out << "<p><b>View all other</b> " << "<a href=\"" << "concepts-index.html#" << remove_square_brackets(i->tags[0])
+                    << "\">" << "issues</a> in " << i->tags[0] << ".</p>\n";
+
+            // view all issues with same status
+            if (issues_by_status.count(*i) > 1)
+            {
+                out << "<p><b>View all issues with</b> "
+                    << "<a href=\"concepts-status.html#" << i->stat << "\">" << i->stat << "</a>"
+                    << " status.</p>\n";
+            }
+
+            // duplicates
+            if (!i->duplicates.empty())
+            {
+                out << "<p><b>Duplicate of:</b> ";
+                out << i->duplicates[0];
+                for (unsigned j = 1; j < i->duplicates.size(); ++j)
+                    out << ", " << i->duplicates[j];
+                out << "</p>\n";
+            }
+
+            // text
+            out << i->text << "\n\n";
+        }
+    }
+}
+
+void print_paper_heading(std::ostream& out, const std::string& paper)
+{
+    out << "<table>\n";
+    out << "<tr>\n";
+    out << "<td align=\"left\">Doc. no.</td>\n";
+    out << "<td align=\"left\">" << get_doc_number(paper) << "</td>\n";
+    out << "</tr>\n";
+    out << "<tr>\n";
+    out << "<td align=\"left\">Date:</td>\n";
+    out << "<td align=\"left\">" << get_date() << "</td>\n";
+    out << "</tr>\n";
+    out << "<tr>\n";
+    out << "<td align=\"left\">Project:</td>\n";
+    out << "<td align=\"left\">Programming Language C++</td>\n";
+    out << "</tr>\n";
+    out << "<tr>\n";
+    out << "<td align=\"left\">Reply to:</td>\n";
+    out << "<td align=\"left\">" << get_maintainer() << "</td>\n";
+    out << "</tr>\n";
+    out << "</table>\n";
+    out << "<h1>";
+    if (paper == "active")
+        out << "C++ Concepts Active Issues List (Revision ";
+    else if (paper == "defect")
+        out << "C++ Concepts Defect Report List (Revision ";
+    else if (paper == "closed")
+        out << "C++ Concepts Closed Issues List (Revision ";
+    out << get_revision() << ")</h1>\n";
+}
+
+void make_active(std::vector<issue>& issues)
+{
+    sort(issues.begin(), issues.end(), sort_by_num());
+    std::ofstream out((path + "concepts-active.html").c_str());
+    print_file_header(out, "C++ Concepts Active Issues List");
+    print_paper_heading(out, "active");
+    out << get_intro("active") << '\n';
+    out << "<h2>Revision History</h2>\n" << get_revisions(issues) << '\n';
+    out << "<h2><a name=\"Status\"></a>Issue Status</h2>\n" << get_statuses() << '\n';
+    out << "<h2>Active Issues</h2>\n";
+    print_issues(out, issues, if_active());   
+    print_file_trailer(out);
+}
+
+struct if_defect
+{
+    bool operator()(const issue& i) {return is_defect(i.stat);}
+};
+
+void make_defect(std::vector<issue>& issues)
+{
+    sort(issues.begin(), issues.end(), sort_by_num());
+    std::ofstream out((path + "concepts-defects.html").c_str());
+    print_file_header(out, "C++ Concepts Defect Report List");
+    print_paper_heading(out, "defect");
+    out << get_intro("defect") << '\n';
+    out << "<h2>Revision History</h2>\n" << get_revisions(issues) << '\n';
+    out << "<h2>Defect Reports</h2>\n";
+    print_issues(out, issues, if_defect());   
+    print_file_trailer(out);
+}
+
+struct if_closed
+{
+    bool operator()(const issue& i) {return is_closed(i.stat);}
+};
+
+void make_closed(std::vector<issue>& issues)
+{
+    sort(issues.begin(), issues.end(), sort_by_num());
+    std::ofstream out((path + "concepts-closed.html").c_str());
+    print_file_header(out, "C++ Concepts Closed Issues List");
+    print_paper_heading(out, "closed");
+    out << get_intro("closed") << '\n';
+    out << "<h2>Revision History</h2>\n" << get_revisions(issues) << '\n';
+    out << "<h2>Closed Issues</h2>\n";
+    print_issues(out, issues, if_closed());   
+    print_file_trailer(out);
+}
+
+int parse_month(const std::string& m)
+{
+    if (m == "Jan")
+        return 1;
+    if (m == "Feb")
+        return 2;
+    if (m == "Mar")
+        return 3;
+    if (m == "Apr")
+        return 4;
+    if (m == "May")
+        return 5;
+    if (m == "Jun")
+        return 6;
+    if (m == "Jul")
+        return 7;
+    if (m == "Aug")
+        return 8;
+    if (m == "Sep")
+        return 9;
+    if (m == "Oct")
+        return 10;
+    if (m == "Nov")
+        return 11;
+    if (m == "Dec")
+        return 12;
+    throw std::runtime_error("unknown month");
+}
+
+int
+main(int argc, char* argv[])
+{
+    if (argc == 2)
+        path = argv[1];
+    else
+    {
+        char cwd[1024];
+        if (getcwd(cwd, sizeof(cwd)) == 0)
+        {
+            std::cout << "unable to getcwd\n";
+            return 1;
+        }
+        path = cwd;
+    }
+    if (path[path.size()-1] != '/')
+        path += '/';
+    issues_path = path + "issues/";
+    section_db = read_section_db();
+//    check_against_index(section_db);
+    std::vector<issue> issues;
+/*    for (unsigned i = 0; i < sizeof(issue_files)/sizeof(issue_files[0]); ++i)
+    {
+        std::ifstream infile((issues_path + issue_files[i]).c_str());
+        if (!infile.is_open())
+        {
+            std::cout << "Unable to open file " << (issues_path + issue_files[i]) << '\n';
+            return 1;
+        }
+        std::istreambuf_iterator<char> first(infile), last;
+        std::string f(first, last);
+        infile.close();
+        unsigned l2 = 0;
+        while (true)
+        {
+            unsigned k2 = f.find("<sref", l2);
+            if (k2 == std::string::npos)
+                break;
+             l2 = f.find("/>", k2) + 2;
+             std::string r = f.substr(k2, l2-k2);
+             std::istringstream temp(r);
+             std::string w;
+             temp >> w; // <sref
+             ws(temp);
+             char c;
+             temp >> c; // r
+             temp >> c; // e
+             temp >> c; // f
+             temp >> c; // =
+             temp >> c; // "
+             section_num sn;
+             temp >> sn;
+             if (section_db.find(sn) == section_db.end())
+                throw std::runtime_error(issue_files[i] + " invalid section");
+             r = "<sref ref=\"" + section_db[sn] + "\"/>";
+             f.replace(k2, l2-k2, r);
+             l2 = k2 + r.size();
+        }
+        std::ofstream out((issues_path + issue_files[i]).c_str());
+        out << f;
+*/
+    DIR* dir = opendir(issues_path.c_str());
+    if (dir == 0)
+    {
+        std::cout << "Unable to open issues dir\n";
+        return 1;
+    }
+    for (dirent* entry = readdir(dir); entry != 0; entry = readdir(dir))
+    {
+        std::string issue_file = entry->d_name;
+        if (issue_file.find("issue") != 0)
+            continue;
+        std::ifstream infile((issues_path + issue_file).c_str());
+        if (!infile.is_open())
+        {
+            std::cout << "Unable to open file " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        std::istreambuf_iterator<char> first(infile), last;
+        issues.push_back(issue());
+        std::string& tx = issues.back().text;
+        tx.assign(first, last);
+        infile.close();
+        
+        // Get issue number
+        issue& is = issues.back();
+        unsigned k = tx.find("<issue num=\"");
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue number in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k += sizeof("<issue num=\"") - 1;
+        unsigned l = tx.find('\"', k);
+        std::istringstream temp(tx.substr(k, l-k));
+        temp >> is.num;
+
+        // Get issue status
+        k = tx.find("status=\"", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue status in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k += sizeof("status=\"") - 1;
+        l = tx.find('\"', k);
+        is.stat = tx.substr(k, l-k);
+
+        // Get issue title
+        k = tx.find("<title>", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue title in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k +=  sizeof("<title>") - 1;
+        l = tx.find("</title>", k);
+        is.title = tx.substr(k, l-k);
+
+        // Get issue sections
+        k = tx.find("<section>", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue section in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k += sizeof("<section>") - 1;
+        l = tx.find("</section>", k);
+        while (k < l)
+        {
+            k = tx.find('\"', k);
+            if (k >= l)
+                break;
+            unsigned k2 = tx.find('\"', k+1);
+            if (k2 >= l)
+            {
+                std::cout << "Unable to find issue section in " << (issues_path + issue_file) << '\n';
+                return 1;
+            }
+            ++k;
+            is.tags.push_back(tx.substr(k, k2-k));
+            if (section_db.find(is.tags.back()) == section_db.end())
+            {
+                std::cout << "Unable to find issue section: " << is.tags.back() << " in database" << (issues_path + issue_file) << '\n';
+                return 1;
+            }
+            k = k2;
+            ++k;
+        }
+        if (is.tags.empty())
+        {
+            std::cout << "Unable to find issue section in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+
+        // Get submitter
+        k = tx.find("<submitter>", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue submitter in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k += sizeof("<submitter>") - 1;
+        l = tx.find("</submitter>", k);
+        is.submitter = tx.substr(k, l-k);
+
+        // Get date
+        k = tx.find("<date>", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue date in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        k += sizeof("<date>") - 1;
+        l = tx.find("</date>", k);
+        temp.clear();
+        temp.str(tx.substr(k, l-k));
+        {
+        int d;
+        temp >> d;
+        if (temp.fail())
+            throw std::runtime_error("date format error in " + issue_file);
+        std::string month;
+        temp >> month;
+        int m;
+        try
+        {
+            m = parse_month(month);
+            int y = 0;
+            temp >> y;
+            is.date = greg::month(m)/greg::day(d)/y;
+        }
+        catch (std::exception& e)
+        {
+            throw std::runtime_error(e.what() + std::string(" in ") + issue_file);
+        }
+        }
+
+        // Trim text to <discussion>
+        k = tx.find("<discussion>", l);
+        if (k == std::string::npos)
+        {
+            std::cout << "Unable to find issue discussion in " << (issues_path + issue_file) << '\n';
+            return 1;
+        }
+        tx.erase(0, k);
+
+        // Find out if issue has a proposed resolution
+        if (is_active(is.stat))
+        {
+            unsigned k2 = tx.find("<resolution>", 0);
+            if (k2 == std::string::npos)
+            {
+                is.has_resolution = false;
+            }
+            else
+            {
+                k2 += sizeof("<resolution>") - 1;
+                unsigned l2 = tx.find("</resolution>", k2);
+                is.has_resolution = l2 - k2 > 15;
+            }
+        }
+        else
+            is.has_resolution = true;
+    }
+    closedir(dir);
+    sort(issues.begin(), issues.end(), sort_by_num());
+    for (std::vector<issue>::iterator i = issues.begin(), e = issues.end(); i != e; ++i)
+        format(issues, *i);
+    make_sort_by_num(issues);
+    make_sort_by_status(issues);
+    make_sort_by_section(issues);
+    make_sort_by_section(issues, true);
+    make_active(issues);
+    make_defect(issues);
+    make_closed(issues);
+    std::cout << "Made all documents\n";
+}

Added: sandbox/committee/concepts/issues/section.data
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/issues/section.data	2008-03-03 11:27:23 EST (Mon, 03 Mar 2008)
@@ -0,0 +1,1781 @@
+1 [intro]
+    1.1 [intro.scope]
+    1.2 [intro.refs]
+    1.3 [intro.defs]
+        1.3.1 [defns.argument]
+        1.3.2 [defns.cond.supp]
+        1.3.3 [defns.diagnostic]
+        1.3.4 [defns.dynamic.type]
+        1.3.5 [defns.ill.formed]
+        1.3.6 [defns.impl.defined]
+        1.3.7 [defns.impl.limits]
+        1.3.8 [defns.locale.specific]
+        1.3.9 [defns.multibyte]
+        1.3.10 [defns.parameter]
+        1.3.11 [defns.signature]
+        1.3.12 [defns.static.type]
+        1.3.13 [defns.undefined]
+        1.3.14 [defns.unspecified]
+        1.3.15 [defns.well.formed]
+    1.4 [intro.compliance]
+    1.5 [intro.structure]
+    1.6 [syntax]
+    1.7 [intro.memory]
+    1.8 [intro.object]
+    1.9 [intro.execution]
+    1.10 [intro.multithread]
+    1.11 [intro.ack]
+2 [lex]
+    2.1 [lex.phases]
+    2.2 [lex.charset]
+    2.3 [lex.trigraph]
+    2.4 [lex.pptoken]
+    2.5 [lex.digraph]
+    2.6 [lex.token]
+    2.7 [lex.comment]
+    2.8 [lex.header]
+    2.9 [lex.ppnumber]
+    2.10 [lex.name]
+    2.11 [lex.key]
+    2.12 [lex.operators]
+    2.13 [lex.literal]
+        2.13.1 [lex.icon]
+        2.13.2 [lex.ccon]
+        2.13.3 [lex.fcon]
+        2.13.4 [lex.string]
+        2.13.5 [lex.bool]
+        2.13.6 [lex.nullptr]
+3 [basic]
+    3.1 [basic.def]
+    3.2 [basic.def.odr]
+    3.3 [basic.scope]
+        3.3.1 [basic.scope.pdecl]
+        3.3.2 [basic.scope.local]
+        3.3.3 [basic.scope.proto]
+        3.3.4 [basic.funscope]
+        3.3.5 [basic.scope.namespace]
+        3.3.6 [basic.scope.class]
+        3.3.7 [basic.scope.enum]
+        3.3.8 [basic.scope.hiding]
+    3.4 [basic.lookup]
+        3.4.1 [basic.lookup.unqual]
+        3.4.2 [basic.lookup.argdep]
+        3.4.3 [basic.lookup.qual]
+            3.4.3.1 [class.qual]
+            3.4.3.2 [namespace.qual]
+        3.4.4 [basic.lookup.elab]
+        3.4.5 [basic.lookup.classref]
+        3.4.6 [basic.lookup.udir]
+    3.5 [basic.link]
+    3.6 [basic.start]
+        3.6.1 [basic.start.main]
+        3.6.2 [basic.start.init]
+        3.6.3 [basic.start.term]
+    3.7 [basic.stc]
+        3.7.1 [basic.stc.static]
+        3.7.2 [basic.stc.auto]
+        3.7.3 [basic.stc.dynamic]
+            3.7.3.1 [basic.stc.dynamic.allocation]
+            3.7.3.2 [basic.stc.dynamic.deallocation]
+        3.7.4 [basic.stc.inherit]
+    3.8 [basic.life]
+    3.9 [basic.types]
+        3.9.1 [basic.fundamental]
+        3.9.2 [basic.compound]
+        3.9.3 [basic.type.qualifier]
+    3.10 [basic.lval]
+    3.11 [basic.align]
+4 [conv]
+    4.1 [conv.lval]
+    4.2 [conv.array]
+    4.3 [conv.func]
+    4.4 [conv.qual]
+    4.5 [conv.prom]
+    4.6 [conv.fpprom]
+    4.7 [conv.integral]
+    4.8 [conv.double]
+    4.9 [conv.fpint]
+    4.10 [conv.ptr]
+    4.11 [conv.mem]
+    4.12 [conv.bool]
+    4.13 [conv.rank]
+5 [expr]
+    5.1 [expr.prim]
+    5.2 [expr.post]
+        5.2.1 [expr.sub]
+        5.2.2 [expr.call]
+        5.2.3 [expr.type.conv]
+        5.2.4 [expr.pseudo]
+        5.2.5 [expr.ref]
+        5.2.6 [expr.post.incr]
+        5.2.7 [expr.dynamic.cast]
+        5.2.8 [expr.typeid]
+        5.2.9 [expr.static.cast]
+        5.2.10 [expr.reinterpret.cast]
+        5.2.11 [expr.const.cast]
+    5.3 [expr.unary]
+        5.3.1 [expr.unary.op]
+        5.3.2 [expr.pre.incr]
+        5.3.3 [expr.sizeof]
+        5.3.4 [expr.new]
+        5.3.5 [expr.delete]
+        5.3.6 [expr.alignof]
+    5.4 [expr.cast]
+    5.5 [expr.mptr.oper]
+    5.6 [expr.mul]
+    5.7 [expr.add]
+    5.8 [expr.shift]
+    5.9 [expr.rel]
+    5.10 [expr.eq]
+    5.11 [expr.bit.and]
+    5.12 [expr.xor]
+    5.13 [expr.or]
+    5.14 [expr.log.and]
+    5.15 [expr.log.or]
+    5.16 [expr.cond]
+    5.17 [expr.ass]
+    5.18 [expr.comma]
+    5.19 [expr.const]
+6 [stmt.stmt]
+    6.1 [stmt.label]
+    6.2 [stmt.expr]
+    6.3 [stmt.block]
+    6.4 [stmt.select]
+        6.4.1 [stmt.if]
+        6.4.2 [stmt.switch]
+    6.5 [stmt.iter]
+        6.5.1 [stmt.while]
+        6.5.2 [stmt.do]
+        6.5.3 [stmt.for]
+    6.6 [stmt.jump]
+        6.6.1 [stmt.break]
+        6.6.2 [stmt.cont]
+        6.6.3 [stmt.return]
+        6.6.4 [stmt.goto]
+    6.7 [stmt.dcl]
+    6.8 [stmt.ambig]
+7 [dcl.dcl]
+    7.1 [dcl.spec]
+        7.1.1 [dcl.stc]
+        7.1.2 [dcl.fct.spec]
+        7.1.3 [dcl.typedef]
+        7.1.4 [dcl.friend]
+        7.1.5 [dcl.constexpr]
+        7.1.6 [dcl.type]
+            7.1.6.1 [dcl.type.cv]
+            7.1.6.2 [dcl.type.simple]
+            7.1.6.3 [dcl.type.elab]
+            7.1.6.4 [dcl.spec.auto]
+        7.1.7 [dcl.align]
+    7.2 [dcl.enum]
+    7.3 [basic.namespace]
+        7.3.1 [namespace.def]
+            7.3.1.1 [namespace.unnamed]
+            7.3.1.2 [namespace.memdef]
+        7.3.2 [namespace.alias]
+        7.3.3 [namespace.udecl]
+        7.3.4 [namespace.udir]
+    7.4 [dcl.asm]
+    7.5 [dcl.link]
+8 [dcl.decl]
+    8.1 [dcl.name]
+    8.2 [dcl.ambig.res]
+    8.3 [dcl.meaning]
+        8.3.1 [dcl.ptr]
+        8.3.2 [dcl.ref]
+        8.3.3 [dcl.mptr]
+        8.3.4 [dcl.array]
+        8.3.5 [dcl.fct]
+        8.3.6 [dcl.fct.default]
+    8.4 [dcl.fct.def]
+    8.5 [dcl.init]
+        8.5.1 [dcl.init.aggr]
+        8.5.2 [dcl.init.string]
+        8.5.3 [dcl.init.ref]
+9 [class]
+    9.1 [class.name]
+    9.2 [class.mem]
+    9.3 [class.mfct]
+        9.3.1 [class.mfct.non-static]
+        9.3.2 [class.this]
+    9.4 [class.static]
+        9.4.1 [class.static.mfct]
+        9.4.2 [class.static.data]
+    9.5 [class.union]
+    9.6 [class.bit]
+    9.7 [class.nest]
+    9.8 [class.local]
+    9.9 [class.nested.type]
+10 [class.derived]
+    10.1 [class.mi]
+    10.2 [class.member.lookup]
+    10.3 [class.virtual]
+    10.4 [class.abstract]
+11 [class.access]
+    11.1 [class.access.spec]
+    11.2 [class.access.base]
+    11.3 [class.access.dcl]
+    11.4 [class.friend]
+    11.5 [class.protected]
+    11.6 [class.access.virt]
+    11.7 [class.paths]
+    11.8 [class.access.nest]
+12 [special]
+    12.1 [class.ctor]
+    12.2 [class.temporary]
+    12.3 [class.conv]
+        12.3.1 [class.conv.ctor]
+        12.3.2 [class.conv.fct]
+    12.4 [class.dtor]
+    12.5 [class.free]
+    12.6 [class.init]
+        12.6.1 [class.expl.init]
+        12.6.2 [class.base.init]
+    12.7 [class.cdtor]
+    12.8 [class.copy]
+13 [over]
+    13.1 [over.load]
+    13.2 [over.dcl]
+    13.3 [over.match]
+        13.3.1 [over.match.funcs]
+            13.3.1.1 [over.match.call]
+                13.3.1.1.1 [over.call.func]
+                13.3.1.1.2 [over.call.object]
+            13.3.1.2 [over.match.oper]
+            13.3.1.3 [over.match.ctor]
+            13.3.1.4 [over.match.copy]
+            13.3.1.5 [over.match.conv]
+            13.3.1.6 [over.match.ref]
+        13.3.2 [over.match.viable]
+        13.3.3 [over.match.best]
+            13.3.3.1 [over.best.ics]
+                13.3.3.1.1 [over.ics.scs]
+                13.3.3.1.2 [over.ics.user]
+                13.3.3.1.3 [over.ics.ellipsis]
+                13.3.3.1.4 [over.ics.ref]
+            13.3.3.2 [over.ics.rank]
+    13.4 [over.over]
+    13.5 [over.oper]
+        13.5.1 [over.unary]
+        13.5.2 [over.binary]
+        13.5.3 [over.ass]
+        13.5.4 [over.call]
+        13.5.5 [over.sub]
+        13.5.6 [over.ref]
+        13.5.7 [over.inc]
+    13.6 [over.built]
+14 [temp]
+    14.1 [temp.param]
+    14.2 [temp.names]
+    14.3 [temp.arg]
+        14.3.1 [temp.arg.type]
+        14.3.2 [temp.arg.nontype]
+        14.3.3 [temp.arg.template]
+    14.4 [temp.type]
+    14.5 [temp.decls]
+        14.5.1 [temp.class]
+            14.5.1.1 [temp.mem.func]
+            14.5.1.2 [temp.mem.class]
+            14.5.1.3 [temp.static]
+        14.5.2 [temp.mem]
+        14.5.3 [temp.variadic]
+        14.5.4 [temp.friend]
+        14.5.5 [temp.class.spec]
+            14.5.5.1 [temp.class.spec.match]
+            14.5.5.2 [temp.class.order]
+            14.5.5.3 [temp.class.spec.mfunc]
+        14.5.6 [temp.fct]
+            14.5.6.1 [temp.over.link]
+            14.5.6.2 [temp.func.order]
+        14.5.7 [temp.alias]
+    14.6 [temp.res]
+        14.6.1 [temp.local]
+        14.6.2 [temp.dep]
+            14.6.2.1 [temp.dep.type]
+            14.6.2.2 [temp.dep.expr]
+            14.6.2.3 [temp.dep.constexpr]
+            14.6.2.4 [temp.dep.temp]
+        14.6.3 [temp.nondep]
+        14.6.4 [temp.dep.res]
+            14.6.4.1 [temp.point]
+            14.6.4.2 [temp.dep.candidate]
+        14.6.5 [temp.inject]
+    14.7 [temp.spec]
+        14.7.1 [temp.inst]
+        14.7.2 [temp.explicit]
+        14.7.3 [temp.expl.spec]
+    14.8 [temp.fct.spec]
+        14.8.1 [temp.arg.explicit]
+        14.8.2 [temp.deduct]
+            14.8.2.1 [temp.deduct.call]
+            14.8.2.2 [temp.deduct.funcaddr]
+            14.8.2.3 [temp.deduct.conv]
+            14.8.2.4 [temp.deduct.partial]
+            14.8.2.5 [temp.deduct.type]
+        14.8.3 [temp.over]
+15 [except]
+    15.1 [except.throw]
+    15.2 [except.ctor]
+    15.3 [except.handle]
+    15.4 [except.spec]
+    15.5 [except.special]
+        15.5.1 [except.terminate]
+        15.5.2 [except.unexpected]
+        15.5.3 [except.uncaught]
+    15.6 [except.access]
+16 [cpp]
+    16.1 [cpp.cond]
+    16.2 [cpp.include]
+    16.3 [cpp.replace]
+        16.3.1 [cpp.subst]
+        16.3.2 [cpp.stringize]
+        16.3.3 [cpp.concat]
+        16.3.4 [cpp.rescan]
+        16.3.5 [cpp.scope]
+    16.4 [cpp.line]
+    16.5 [cpp.error]
+    16.6 [cpp.pragma]
+    16.7 [cpp.null]
+    16.8 [cpp.predefined]
+    16.9 [cpp.pragma.op]
+17 [library]
+    17.1 [definitions]
+        17.1.1 [defns.arbitrary.stream]
+        17.1.2 [defns.blocked]
+        17.1.3 [defns.character]
+        17.1.4 [defns.character.container]
+        17.1.5 [defns.comparison]
+        17.1.6 [defns.component]
+        17.1.7 [defns.deadlock]
+        17.1.8 [defns.default.behavior]
+        17.1.9 [defns.handler]
+        17.1.10 [defns.iostream.templates]
+        17.1.11 [defns.modifier]
+        17.1.12 [defns.obj.state]
+        17.1.13 [defns.ntcts]
+        17.1.14 [defns.narrow.iostream]
+        17.1.15 [defns.observer]
+        17.1.16 [defns.replacement]
+        17.1.17 [defns.repositional.stream]
+        17.1.18 [defns.required.behavior]
+        17.1.19 [defns.reserved.function]
+        17.1.20 [defns.stable]
+        17.1.21 [defns.traits]
+        17.1.22 [defns.wide.iostream]
+    17.2 [defns.additional]
+    17.3 [description]
+        17.3.1 [structure]
+            17.3.1.1 [structure.summary]
+            17.3.1.2 [structure.requirements]
+            17.3.1.3 [structure.specifications]
+            17.3.1.4 [structure.see.also]
+        17.3.2 [conventions]
+            17.3.2.1 [type.descriptions]
+                17.3.2.1.1 [enumerated.types]
+                17.3.2.1.2 [bitmask.types]
+                17.3.2.1.3 [character.seq]
+                    17.3.2.1.3.1 [byte.strings]
+                    17.3.2.1.3.2 [multibyte.strings]
+                    17.3.2.1.3.3 [char16_t.seq]
+                    17.3.2.1.3.4 [char32_t.seq]
+                    17.3.2.1.3.5 [wide.characters]
+            17.3.2.2 [functions.within.classes]
+            17.3.2.3 [objects.within.classes]
+    17.4 [requirements]
+        17.4.1 [organization]
+            17.4.1.1 [contents]
+            17.4.1.2 [headers]
+            17.4.1.3 [compliance]
+        17.4.2 [using]
+            17.4.2.1 [using.headers]
+            17.4.2.2 [using.linkage]
+        17.4.3 [constraints]
+            17.4.3.1 [reserved.names]
+                17.4.3.1.1 [macro.names]
+                17.4.3.1.2 [global.names]
+                17.4.3.1.3 [extern.names]
+                17.4.3.1.4 [extern.types]
+            17.4.3.2 [alt.headers]
+            17.4.3.3 [derived.classes]
+            17.4.3.4 [replacement.functions]
+            17.4.3.5 [handler.functions]
+            17.4.3.6 [res.on.functions]
+            17.4.3.7 [res.on.arguments]
+            17.4.3.8 [res.on.required]
+        17.4.4 [conforming]
+            17.4.4.1 [res.on.headers]
+            17.4.4.2 [res.on.macro.definitions]
+            17.4.4.3 [global.functions]
+            17.4.4.4 [member.functions]
+            17.4.4.5 [reentrancy]
+            17.4.4.6 [protection.within.classes]
+            17.4.4.7 [derivation]
+            17.4.4.8 [res.on.exception.handling]
+            17.4.4.9 [value.error.codes]
+18 [language.support]
+    18.1 [support.types]
+    18.2 [support.limits]
+        18.2.1 [limits]
+            18.2.1.1 [numeric.limits]
+            18.2.1.2 [numeric.limits.members]
+            18.2.1.3 [round.style]
+            18.2.1.4 [denorm.style]
+            18.2.1.5 [numeric.special]
+        18.2.2 [c.limits]
+    18.3 [cstdint]
+        18.3.1 [cstdint.syn]
+        18.3.2 [stdinth]
+    18.4 [support.start.term]
+    18.5 [support.dynamic]
+        18.5.1 [new.delete]
+            18.5.1.1 [new.delete.single]
+            18.5.1.2 [new.delete.array]
+            18.5.1.3 [new.delete.placement]
+        18.5.2 [alloc.errors]
+            18.5.2.1 [bad.alloc]
+            18.5.2.2 [new.handler]
+            18.5.2.3 [set.new.handler]
+    18.6 [support.rtti]
+        18.6.1 [type.info]
+        18.6.2 [bad.cast]
+        18.6.3 [bad.typeid]
+    18.7 [support.exception]
+        18.7.1 [exception]
+        18.7.2 [exception.unexpected]
+            18.7.2.1 [bad.exception]
+            18.7.2.2 [unexpected.handler]
+            18.7.2.3 [set.unexpected]
+            18.7.2.4 [unexpected]
+        18.7.3 [exception.terminate]
+            18.7.3.1 [terminate.handler]
+            18.7.3.2 [set.terminate]
+            18.7.3.3 [terminate]
+        18.7.4 [uncaught]
+        18.7.5 [propagation]
+    18.8 [support.runtime]
+19 [diagnostics]
+    19.1 [std.exceptions]
+        19.1.1 [logic.error]
+        19.1.2 [domain.error]
+        19.1.3 [invalid.argument]
+        19.1.4 [length.error]
+        19.1.5 [out.of.range]
+        19.1.6 [runtime.error]
+        19.1.7 [range.error]
+        19.1.8 [overflow.error]
+        19.1.9 [underflow.error]
+    19.2 [assertions]
+    19.3 [errno]
+    19.4 [syserr]
+        19.4.1 [syserr.errcat]
+            19.4.1.1 [syserr.errcat.overview]
+            19.4.1.2 [syserr.errcat.virtuals]
+            19.4.1.3 [syserr.errcat.nonvirtuals]
+            19.4.1.4 [syserr.errcat.derived]
+            19.4.1.5 [syserr.errcat.objects]
+        19.4.2 [syserr.errcode]
+            19.4.2.1 [syserr.errcode.overview]
+            19.4.2.2 [syserr.errcode.constructors]
+            19.4.2.3 [syserr.errcode.modifiers]
+            19.4.2.4 [syserr.errcode.observers]
+            19.4.2.5 [syserr.errcode.nonmembers]
+        19.4.3 [syserr.errcondition]
+            19.4.3.1 [syserr.errcondition.overview]
+            19.4.3.2 [syserr.errcondition.constructors]
+            19.4.3.3 [syserr.errcondition.modifiers]
+            19.4.3.4 [syserr.errcondition.observers]
+            19.4.3.5 [syserr.errcondition.nonmembers]
+        19.4.4 [syserr.compare]
+        19.4.5 [syserr.syserr]
+            19.4.5.1 [syserr.syserr.overview]
+            19.4.5.2 [syserr.syserr.members]
+20 [utilities]
+    20.1 [utility.concepts]
+        20.1.1 [concept.support]
+        20.1.2 [concept.comparison]
+        20.1.3 [concept.destruct]
+        20.1.4 [concept.construct]
+        20.1.5 [concept.copymove]
+        20.1.6 [concept.memory]
+        20.1.7 [concept.regular]
+        20.1.8 [concept.convertible]
+        20.1.9 [concept.true]
+        20.1.10 [concept.operator]
+        20.1.11 [concept.arithmetic]
+        20.1.12 [concept.predicate]
+        20.1.13 [concept.allocator]
+    20.2 [utility]
+        20.2.1 [operators]
+        20.2.2 [forward]
+        20.2.3 [pairs]
+    20.3 [tuple]
+        20.3.1 [tuple.tuple]
+            20.3.1.1 [tuple.cnstr]
+            20.3.1.2 [tuple.creation]
+            20.3.1.3 [tuple.helper]
+            20.3.1.4 [tuple.elem]
+            20.3.1.5 [tuple.rel]
+    20.4 [meta]
+        20.4.1 [meta.rqmts]
+        20.4.2 [meta.type.synop]
+        20.4.3 [meta.help]
+        20.4.4 [meta.unary]
+            20.4.4.1 [meta.unary.cat]
+            20.4.4.2 [meta.unary.comp]
+            20.4.4.3 [meta.unary.prop]
+        20.4.5 [meta.rel]
+        20.4.6 [meta.trans]
+            20.4.6.1 [meta.trans.cv]
+            20.4.6.2 [meta.trans.ref]
+            20.4.6.3 [meta.trans.sign]
+            20.4.6.4 [meta.trans.arr]
+            20.4.6.5 [meta.trans.ptr]
+        20.4.7 [meta.trans.other]
+    20.5 [function.objects]
+        20.5.1 [func.def]
+        20.5.2 [func.require]
+        20.5.3 [base]
+        20.5.4 [func.ret]
+        20.5.5 [refwrap]
+            20.5.5.1 [refwrap.const]
+            20.5.5.2 [refwrap.assign]
+            20.5.5.3 [refwrap.access]
+            20.5.5.4 [refwrap.invoke]
+            20.5.5.5 [refwrap.helpers]
+        20.5.6 [arithmetic.operations]
+        20.5.7 [comparisons]
+        20.5.8 [logical.operations]
+        20.5.9 [bitwise.operations]
+        20.5.10 [negators]
+        20.5.11 [bind]
+            20.5.11.1 [func.bind]
+                20.5.11.1.1 [func.bind.isbind]
+                20.5.11.1.2 [func.bind.isplace]
+                20.5.11.1.3 [func.bind.bind]
+                20.5.11.1.4 [func.bind.place]
+        20.5.12 [function.pointer.adaptors]
+        20.5.13 [member.pointer.adaptors]
+        20.5.14 [func.memfn]
+        20.5.15 [func.wrap]
+            20.5.15.1 [func.wrap.badcall]
+                20.5.15.1.1 [func.wrap.badcall.const]
+            20.5.15.2 [func.wrap.func]
+                20.5.15.2.1 [func.wrap.func.con]
+                20.5.15.2.2 [func.wrap.func.mod]
+                20.5.15.2.3 [func.wrap.func.cap]
+                20.5.15.2.4 [func.wrap.func.inv]
+                20.5.15.2.5 [func.wrap.func.targ]
+                20.5.15.2.6 [func.wrap.func.nullptr]
+                20.5.15.2.7 [func.wrap.func.alg]
+                X [func.wrap.func.undef]
+        20.5.16 [unord.hash]
+    20.6 [memory]
+        20.6.1 [default.allocator]
+            20.6.1.1 [allocator.members]
+            20.6.1.2 [allocator.globals]
+        20.6.2 [storage.iterator]
+        20.6.3 [temporary.buffer]
+        20.6.4 [specialized.algorithms]
+            20.6.4.1 [uninitialized.copy]
+            20.6.4.2 [uninitialized.fill]
+            20.6.4.3 [uninitialized.fill.n]
+        20.6.5 [unique.ptr]
+            20.6.5.1 [unique.ptr.dltr]
+                20.6.5.1.1 [unique.ptr.dltr.dflt]
+                20.6.5.1.2 [unique.ptr.dltr.dflt1]
+                20.6.5.1.3 [unique.ptr.dltr.dflt2]
+            20.6.5.2 [unique.ptr.single]
+                20.6.5.2.1 [unique.ptr.single.ctor]
+                20.6.5.2.2 [unique.ptr.single.dtor]
+                20.6.5.2.3 [unique.ptr.single.asgn]
+                20.6.5.2.4 [unique.ptr.single.observers]
+                20.6.5.2.5 [unique.ptr.single.modifiers]
+            20.6.5.3 [unique.ptr.runtime]
+                20.6.5.3.1 [unique.ptr.runtime.ctor]
+                20.6.5.3.2 [unique.ptr.runtime.observers]
+                20.6.5.3.3 [unique.ptr.runtime.modifiers]
+            20.6.5.4 [unique.ptr.compiletime]
+                20.6.5.4.1 [unique.ptr.compiletime.dtor]
+                20.6.5.4.2 [unique.ptr.compiletime.observers]
+                20.6.5.4.3 [unique.ptr.compiletime.modifiers]
+            20.6.5.5 [unique.ptr.special]
+        20.6.6 [util.smartptr]
+            20.6.6.1 [util.smartptr.weakptr]
+            20.6.6.2 [util.smartptr.shared]
+                20.6.6.2.1 [util.smartptr.shared.const]
+                20.6.6.2.2 [util.smartptr.shared.dest]
+                20.6.6.2.3 [util.smartptr.shared.assign]
+                20.6.6.2.4 [util.smartptr.shared.mod]
+                20.6.6.2.5 [util.smartptr.shared.obs]
+                20.6.6.2.6 [util.smartptr.shared.create]
+                20.6.6.2.7 [util.smartptr.shared.cmp]
+                20.6.6.2.8 [util.smartptr.shared.io]
+                20.6.6.2.9 [util.smartptr.shared.spec]
+                20.6.6.2.10 [util.smartptr.shared.cast]
+                20.6.6.2.11 [util.smartptr.getdeleter]
+            20.6.6.3 [util.smartptr.weak]
+                20.6.6.3.1 [util.smartptr.weak.const]
+                20.6.6.3.2 [util.smartptr.weak.dest]
+                20.6.6.3.3 [util.smartptr.weak.assign]
+                20.6.6.3.4 [util.smartptr.weak.mod]
+                20.6.6.3.5 [util.smartptr.weak.obs]
+                20.6.6.3.6 [util.smartptr.weak.cmp]
+                20.6.6.3.7 [util.smartptr.weak.spec]
+            20.6.6.4 [util.smartptr.enab]
+        20.6.7 [ptr.align]
+        20.6.8 [c.malloc]
+    20.7 [date.time]
+21 [strings]
+    21.1 [char.traits]
+        21.1.1 [char.traits.require]
+        21.1.2 [char.traits.typedefs]
+        21.1.3 [char.traits.specializations]
+            21.1.3.1 [char.traits.specializations.char]
+            21.1.3.2 [char.traits.specializations.char16_t]
+            21.1.3.3 [char.traits.specializations.char32_t]
+            21.1.3.4 [char.traits.specializations.wchar.t]
+    21.2 [string.classes]
+    21.3 [basic.string]
+        21.3.1 [string.require]
+        21.3.2 [string.cons]
+        21.3.3 [string.iterators]
+        21.3.4 [string.capacity]
+        21.3.5 [string.access]
+        21.3.6 [string.modifiers]
+            21.3.6.1 [string::op+=]
+            21.3.6.2 [string::append]
+            21.3.6.3 [string::assign]
+            21.3.6.4 [string::insert]
+            21.3.6.5 [string::erase]
+            21.3.6.6 [string::replace]
+            21.3.6.7 [string::copy]
+            21.3.6.8 [string::swap]
+        21.3.7 [string.ops]
+            21.3.7.1 [string.accessors]
+            21.3.7.2 [string::find]
+            21.3.7.3 [string::rfind]
+            21.3.7.4 [string::find.first.of]
+            21.3.7.5 [string::find.last.of]
+            21.3.7.6 [string::find.first.not.of]
+            21.3.7.7 [string::find.last.not.of]
+            21.3.7.8 [string::substr]
+            21.3.7.9 [string::compare]
+        21.3.8 [string.nonmembers]
+            21.3.8.1 [string::op+]
+            21.3.8.2 [string::operator==]
+            21.3.8.3 [string::op!=]
+            21.3.8.4 [string::op&lt;]
+            21.3.8.5 [string::op&gt;]
+            21.3.8.6 [string::op&lt;=]
+            21.3.8.7 [string::op&gt;=]
+            21.3.8.8 [string.special]
+            21.3.8.9 [string.io]
+    21.4 [string.conversions]
+    21.5 [c.strings]
+22 [localization]
+    22.1 [locales]
+        22.1.1 [locale]
+            22.1.1.1 [locale.types]
+                22.1.1.1.1 [locale.category]
+                22.1.1.1.2 [locale.facet]
+                22.1.1.1.3 [locale.id]
+            22.1.1.2 [locale.cons]
+            22.1.1.3 [locale.members]
+            22.1.1.4 [locale.operators]
+            22.1.1.5 [locale.statics]
+        22.1.2 [locale.global.templates]
+        22.1.3 [locale.convenience]
+            22.1.3.1 [classification]
+            22.1.3.2 [conversions]
+                22.1.3.2.1 [conversions.character]
+                22.1.3.2.2 [conversions.string]
+                22.1.3.2.3 [conversions.buffer]
+    22.2 [locale.categories]
+        22.2.1 [category.ctype]
+            22.2.1.1 [locale.ctype]
+                22.2.1.1.1 [locale.ctype.members]
+                22.2.1.1.2 [locale.ctype.virtuals]
+            22.2.1.2 [locale.ctype.byname]
+            22.2.1.3 [facet.ctype.special]
+                22.2.1.3.1 [facet.ctype.char.dtor]
+                22.2.1.3.2 [facet.ctype.char.members]
+                22.2.1.3.3 [facet.ctype.char.statics]
+                22.2.1.3.4 [facet.ctype.char.virtuals]
+            22.2.1.4 [locale.codecvt]
+                22.2.1.4.1 [locale.codecvt.members]
+                22.2.1.4.2 [locale.codecvt.virtuals]
+            22.2.1.5 [locale.codecvt.byname]
+        22.2.2 [category.numeric]
+            22.2.2.1 [locale.num.get]
+                22.2.2.1.1 [facet.num.get.members]
+                22.2.2.1.2 [facet.num.get.virtuals]
+            22.2.2.2 [locale.nm.put]
+                22.2.2.2.1 [facet.num.put.members]
+                22.2.2.2.2 [facet.num.put.virtuals]
+        22.2.3 [facet.numpunct]
+            22.2.3.1 [locale.numpunct]
+                22.2.3.1.1 [facet.numpunct.members]
+                22.2.3.1.2 [facet.numpunct.virtuals]
+            22.2.3.2 [locale.numpunct.byname]
+        22.2.4 [category.collate]
+            22.2.4.1 [locale.collate]
+                22.2.4.1.1 [locale.collate.members]
+                22.2.4.1.2 [locale.collate.virtuals]
+            22.2.4.2 [locale.collate.byname]
+        22.2.5 [category.time]
+            22.2.5.1 [locale.time.get]
+                22.2.5.1.1 [locale.time.get.members]
+                22.2.5.1.2 [locale.time.get.virtuals]
+            22.2.5.2 [locale.time.get.byname]
+            22.2.5.3 [locale.time.put]
+                22.2.5.3.1 [locale.time.put.members]
+                22.2.5.3.2 [locale.time.put.virtuals]
+            22.2.5.4 [locale.time.put.byname]
+        22.2.6 [category.monetary]
+            22.2.6.1 [locale.money.get]
+                22.2.6.1.1 [locale.money.get.members]
+                22.2.6.1.2 [locale.money.get.virtuals]
+            22.2.6.2 [locale.money.put]
+                22.2.6.2.1 [locale.money.put.members]
+                22.2.6.2.2 [locale.money.put.virtuals]
+            22.2.6.3 [locale.moneypunct]
+                22.2.6.3.1 [locale.moneypunct.members]
+                22.2.6.3.2 [locale.moneypunct.virtuals]
+            22.2.6.4 [locale.moneypunct.byname]
+        22.2.7 [category.messages]
+            22.2.7.1 [locale.messages]
+                22.2.7.1.1 [locale.messages.members]
+                22.2.7.1.2 [locale.messages.virtuals]
+            22.2.7.2 [locale.messages.byname]
+        22.2.8 [facets.examples]
+    22.3 [locale.stdcvt]
+    22.4 [c.locales]
+23 [containers]
+    23.1 [container.requirements]
+        23.1.1 [sequence.reqmts]
+        23.1.2 [associative.reqmts]
+        23.1.3 [unord.req]
+            23.1.3.1 [unord.req.except]
+    23.2 [sequences]
+        23.2.1 [array]
+            23.2.1.1 [array.cons]
+            23.2.1.2 [array.special]
+            23.2.1.3 [array.size]
+            23.2.1.4 [array.data]
+            23.2.1.5 [array.zero]
+            23.2.1.6 [array.tuple]
+        23.2.2 [deque]
+            23.2.2.1 [deque.cons]
+            23.2.2.2 [deque.capacity]
+            23.2.2.3 [deque.modifiers]
+            23.2.2.4 [deque.special]
+        23.2.3 [list]
+            23.2.3.1 [list.cons]
+            23.2.3.2 [list.capacity]
+            23.2.3.3 [list.modifiers]
+            23.2.3.4 [list.ops]
+            23.2.3.5 [list.special]
+        23.2.4 [container.adaptors]
+            23.2.4.1 [queue]
+                23.2.4.1.1 [queue.defn]
+                23.2.4.1.2 [queue.ops]
+                23.2.4.1.3 [queue.special]
+            23.2.4.2 [priority.queue]
+                23.2.4.2.1 [priqueue.cons]
+                23.2.4.2.2 [priqueue.members]
+                23.2.4.2.3 [priqueue.special]
+            23.2.4.3 [stack]
+                23.2.4.3.1 [stack.defn]
+                23.2.4.3.2 [stack.ops]
+                23.2.4.3.3 [stack.special]
+        23.2.5 [vector]
+            23.2.5.1 [vector.cons]
+            23.2.5.2 [vector.capacity]
+            23.2.5.3 [vector.data]
+            23.2.5.4 [vector.modifiers]
+            23.2.5.5 [vector.special]
+        23.2.6 [vector.bool]
+    23.3 [associative]
+        23.3.1 [map]
+            23.3.1.1 [map.cons]
+            23.3.1.2 [map.access]
+            23.3.1.3 [map.modifiers]
+            23.3.1.4 [map.ops]
+            23.3.1.5 [map.special]
+        23.3.2 [multimap]
+            23.3.2.1 [multimap.cons]
+            23.3.2.2 [multimap.modifiers]
+            23.3.2.3 [multimap.ops]
+            23.3.2.4 [multimap.special]
+        23.3.3 [set]
+            23.3.3.1 [set.cons]
+            23.3.3.2 [set.special]
+        23.3.4 [multiset]
+            23.3.4.1 [multiset.cons]
+            23.3.4.2 [multiset.special]
+        23.3.5 [template.bitset]
+            23.3.5.1 [bitset.cons]
+            23.3.5.2 [bitset.members]
+            23.3.5.3 [bitset.operators]
+    23.4 [unord]
+        23.4.1 [unord.map]
+            23.4.1.1 [unord.map.cnstr]
+            23.4.1.2 [unord.map.elem]
+            23.4.1.3 [unord.map.swap]
+        23.4.2 [unord.multimap]
+            23.4.2.1 [unord.multimap.cnstr]
+            23.4.2.2 [unord.multimap.swap]
+        23.4.3 [unord.set]
+            23.4.3.1 [unord.set.cnstr]
+            23.4.3.2 [unord.set.swap]
+        23.4.4 [unord.multiset]
+            23.4.4.1 [unord.multiset.cnstr]
+            23.4.4.2 [unord.multiset.swap]
+24 [iterators]
+    24.1 [iterator.requirements]
+        24.1.1 [input.iterators]
+        24.1.2 [output.iterators]
+        24.1.3 [forward.iterators]
+        24.1.4 [bidirectional.iterators]
+        24.1.5 [random.access.iterators]
+    24.2 [iterator.synopsis]
+    24.3 [iterator.primitives]
+        24.3.1 [iterator.traits]
+        24.3.2 [iterator.basic]
+        24.3.3 [std.iterator.tags]
+        24.3.4 [iterator.operations]
+    24.4 [predef.iterators]
+        24.4.1 [reverse.iterators]
+            24.4.1.1 [reverse.iterator]
+            24.4.1.2 [reverse.iter.requirements]
+            24.4.1.3 [reverse.iter.ops]
+                24.4.1.3.1 [reverse.iter.cons]
+                24.4.1.3.2 [reverse.iter.op=]
+                24.4.1.3.3 [reverse.iter.conv]
+                24.4.1.3.4 [reverse.iter.op.star]
+                24.4.1.3.5 [reverse.iter.opref]
+                24.4.1.3.6 [reverse.iter.op++]
+                24.4.1.3.7 [reverse.iter.op--]
+                24.4.1.3.8 [reverse.iter.op+]
+                24.4.1.3.9 [reverse.iter.op+=]
+                24.4.1.3.10 [reverse.iter.op-]
+                24.4.1.3.11 [reverse.iter.op-=]
+                24.4.1.3.12 [reverse.iter.opindex]
+                24.4.1.3.13 [reverse.iter.op==]
+                24.4.1.3.14 [reverse.iter.op&lt;]
+                24.4.1.3.15 [reverse.iter.op!=]
+                24.4.1.3.16 [reverse.iter.op&gt;]
+                24.4.1.3.17 [reverse.iter.op&gt;=]
+                24.4.1.3.18 [reverse.iter.op&lt;=]
+                24.4.1.3.19 [reverse.iter.opdiff]
+                24.4.1.3.20 [reverse.iter.opsum]
+        24.4.2 [insert.iterators]
+            24.4.2.1 [back.insert.iterator]
+            24.4.2.2 [back.insert.iter.ops]
+                24.4.2.2.1 [back.insert.iter.cons]
+                24.4.2.2.2 [back.insert.iter.op=]
+                24.4.2.2.3 [back.insert.iter.op*]
+                24.4.2.2.4 [back.insert.iter.op++]
+                24.4.2.2.5 [back.inserter]
+            24.4.2.3 [front.insert.iterator]
+            24.4.2.4 [front.insert.iter.ops]
+                24.4.2.4.1 [front.insert.iter.cons]
+                24.4.2.4.2 [front.insert.iter.op=]
+                24.4.2.4.3 [front.insert.iter.op*]
+                24.4.2.4.4 [front.insert.iter.op++]
+                24.4.2.4.5 [front.inserter]
+            24.4.2.5 [insert.iterator]
+            24.4.2.6 [insert.iter.ops]
+                24.4.2.6.1 [insert.iter.cons]
+                24.4.2.6.2 [insert.iter.op=]
+                24.4.2.6.3 [insert.iter.op*]
+                24.4.2.6.4 [insert.iter.op++]
+                24.4.2.6.5 [inserter]
+        24.4.3 [move.iterators]
+            24.4.3.1 [move.iterator]
+            24.4.3.2 [move.iter.requirements]
+            24.4.3.3 [move.iter.ops]
+                24.4.3.3.1 [move.iter.op.const]
+                24.4.3.3.2 [move.iter.op=]
+                24.4.3.3.3 [move.iter.op.conv]
+                24.4.3.3.4 [move.iter.op.star]
+                24.4.3.3.5 [move.iter.op.ref]
+                24.4.3.3.6 [move.iter.op.incr]
+                24.4.3.3.7 [move.iter.op.decr]
+                24.4.3.3.8 [move.iter.op.+]
+                24.4.3.3.9 [move.iter.op.+=]
+                24.4.3.3.10 [move.iter.op.-]
+                24.4.3.3.11 [move.iter.op.-=]
+                24.4.3.3.12 [move.iter.op.index]
+                24.4.3.3.13 [move.iter.op.comp]
+                24.4.3.3.14 [move.iter.nonmember]
+    24.5 [stream.iterators]
+        24.5.1 [istream.iterator]
+            24.5.1.1 [istream.iterator.cons]
+            24.5.1.2 [istream.iterator.ops]
+        24.5.2 [ostream.iterator]
+            24.5.2.1 [ostream.iterator.cons.des]
+            24.5.2.2 [ostream.iterator.ops]
+        24.5.3 [istreambuf.iterator]
+            24.5.3.1 [istreambuf.iterator::proxy]
+            24.5.3.2 [istreambuf.iterator.cons]
+            24.5.3.3 [istreambuf.iterator::op*]
+            24.5.3.4 [istreambuf.iterator::op++]
+            24.5.3.5 [istreambuf.iterator::equal]
+            24.5.3.6 [istreambuf.iterator::op==]
+            24.5.3.7 [istreambuf.iterator::op!=]
+        24.5.4 [ostreambuf.iterator]
+            24.5.4.1 [ostreambuf.iter.cons]
+            24.5.4.2 [ostreambuf.iter.ops]
+25 [algorithms]
+    25.1 [alg.nonmodifying]
+        25.1.1 [alg.foreach]
+        25.1.2 [alg.find]
+        25.1.3 [alg.find.end]
+        25.1.4 [alg.find.first.of]
+        25.1.5 [alg.adjacent.find]
+        25.1.6 [alg.count]
+        25.1.7 [mismatch]
+        25.1.8 [alg.equal]
+        25.1.9 [alg.search]
+    25.2 [alg.modifying.operations]
+        25.2.1 [alg.copy]
+        25.2.2 [alg.move]
+        25.2.3 [alg.swap]
+        25.2.4 [alg.transform]
+        25.2.5 [alg.replace]
+        25.2.6 [alg.fill]
+        25.2.7 [alg.generate]
+        25.2.8 [alg.remove]
+        25.2.9 [alg.unique]
+        25.2.10 [alg.reverse]
+        25.2.11 [alg.rotate]
+        25.2.12 [alg.random.shuffle]
+        25.2.13 [alg.partitions]
+    25.3 [alg.sorting]
+        25.3.1 [alg.sort]
+            25.3.1.1 [sort]
+            25.3.1.2 [stable.sort]
+            25.3.1.3 [partial.sort]
+            25.3.1.4 [partial.sort.copy]
+            25.3.1.5 [is.sorted]
+        25.3.2 [alg.nth.element]
+        25.3.3 [alg.binary.search]
+            25.3.3.1 [lower.bound]
+            25.3.3.2 [upper.bound]
+            25.3.3.3 [equal.range]
+            25.3.3.4 [binary.search]
+        25.3.4 [alg.merge]
+        25.3.5 [alg.set.operations]
+            25.3.5.1 [includes]
+            25.3.5.2 [set.union]
+            25.3.5.3 [set.intersection]
+            25.3.5.4 [set.difference]
+            25.3.5.5 [set.symmetric.difference]
+        25.3.6 [alg.heap.operations]
+            25.3.6.1 [push.heap]
+            25.3.6.2 [pop.heap]
+            25.3.6.3 [make.heap]
+            25.3.6.4 [sort.heap]
+            25.3.6.5 [is.heap]
+        25.3.7 [alg.min.max]
+        25.3.8 [alg.lex.comparison]
+        25.3.9 [alg.permutation.generators]
+    25.4 [alg.c.library]
+26 [numerics]
+    26.1 [numeric.requirements]
+    26.2 [cfenv]
+        26.2.1 [cfenv.syn]
+        26.2.2 [fenv]
+    26.3 [complex.numbers]
+        26.3.1 [complex.synopsis]
+        26.3.2 [complex]
+        26.3.3 [complex.special]
+        26.3.4 [complex.members]
+        26.3.5 [complex.member.ops]
+        26.3.6 [complex.ops]
+        26.3.7 [complex.value.ops]
+        26.3.8 [complex.transcendentals]
+        26.3.9 [cmplx.over]
+        26.3.10 [ccmplx]
+        26.3.11 [cmplxh]
+    26.4 [rand]
+        26.4.1 [rand.req]
+            26.4.1.1 [rand.req.genl]
+            26.4.1.2 [rand.req.urng]
+            26.4.1.3 [rand.req.eng]
+            26.4.1.4 [rand.req.adapt]
+            26.4.1.5 [rand.req.dist]
+        26.4.2 [rand.synopsis]
+        26.4.3 [rand.eng]
+            26.4.3.1 [rand.eng.lcong]
+            26.4.3.2 [rand.eng.mers]
+            26.4.3.3 [rand.eng.sub]
+        26.4.4 [rand.adapt]
+            26.4.4.1 [rand.adapt.disc]
+            26.4.4.2 [rand.adapt.ibits]
+            26.4.4.3 [rand.adapt.shuf]
+            26.4.4.4 [rand.adapt.xor]
+        26.4.5 [rand.predef]
+        26.4.6 [rand.device]
+        26.4.7 [rand.util]
+            26.4.7.1 [rand.util.seedseq]
+            26.4.7.2 [rand.util.canonical]
+        26.4.8 [rand.dist]
+            26.4.8.1 [rand.dist.uni]
+                26.4.8.1.1 [rand.dist.uni.int]
+                26.4.8.1.2 [rand.dist.uni.real]
+            26.4.8.2 [rand.dist.bern]
+                26.4.8.2.1 [rand.dist.bern.bernoulli]
+                26.4.8.2.2 [rand.dist.bern.bin]
+                26.4.8.2.3 [rand.dist.bern.geo]
+                26.4.8.2.4 [rand.dist.bern.negbin]
+            26.4.8.3 [rand.dist.pois]
+                26.4.8.3.1 [rand.dist.pois.poisson]
+                26.4.8.3.2 [rand.dist.pois.exp]
+                26.4.8.3.3 [rand.dist.pois.gamma]
+                26.4.8.3.4 [rand.dist.pois.weibull]
+                26.4.8.3.5 [rand.dist.pois.extreme]
+            26.4.8.4 [rand.dist.norm]
+                26.4.8.4.1 [rand.dist.norm.normal]
+                26.4.8.4.2 [rand.dist.norm.lognormal]
+                26.4.8.4.3 [rand.dist.norm.chisq]
+                26.4.8.4.4 [rand.dist.norm.cauchy]
+                26.4.8.4.5 [rand.dist.norm.f]
+                26.4.8.4.6 [rand.dist.norm.t]
+            26.4.8.5 [rand.dist.samp]
+                26.4.8.5.1 [rand.dist.samp.discrete]
+                26.4.8.5.2 [rand.dist.samp.pconst]
+                26.4.8.5.3 [rand.dist.samp.genpdf]
+    26.5 [numarray]
+        26.5.1 [valarray.synopsis]
+        26.5.2 [template.valarray]
+            26.5.2.1 [valarray.cons]
+            26.5.2.2 [valarray.assign]
+            26.5.2.3 [valarray.access]
+            26.5.2.4 [valarray.sub]
+            26.5.2.5 [valarray.unary]
+            26.5.2.6 [valarray.cassign]
+            26.5.2.7 [valarray.members]
+        26.5.3 [valarray.nonmembers]
+            26.5.3.1 [valarray.binary]
+            26.5.3.2 [valarray.comparison]
+            26.5.3.3 [valarray.transcend]
+            26.5.3.4 [valarray.special]
+        26.5.4 [class.slice]
+            26.5.4.1 [cons.slice]
+            26.5.4.2 [slice.access]
+        26.5.5 [template.slice.array]
+            26.5.5.1 [slice.arr.assign]
+            26.5.5.2 [slice.arr.comp.assign]
+            26.5.5.3 [slice.arr.fill]
+        26.5.6 [class.gslice]
+            26.5.6.1 [gslice.cons]
+            26.5.6.2 [gslice.access]
+        26.5.7 [template.gslice.array]
+            26.5.7.1 [gslice.array.assign]
+            26.5.7.2 [gslice.array.comp.assign]
+            26.5.7.3 [gslice.array.fill]
+        26.5.8 [template.mask.array]
+            26.5.8.1 [mask.array.assign]
+            26.5.8.2 [mask.array.comp.assign]
+            26.5.8.3 [mask.array.fill]
+        26.5.9 [template.indirect.array]
+            26.5.9.1 [indirect.array.assign]
+            26.5.9.2 [indirect.array.comp.assign]
+            26.5.9.3 [indirect.array.fill]
+    26.6 [numeric.ops]
+        26.6.1 [accumulate]
+        26.6.2 [inner.product]
+        26.6.3 [partial.sum]
+        26.6.4 [adjacent.difference]
+    26.7 [c.math]
+27 [input.output]
+    27.1 [iostreams.requirements]
+        27.1.1 [iostream.limits.imbue]
+        27.1.2 [iostreams.limits.pos]
+    27.2 [iostream.forward]
+    27.3 [iostream.objects]
+        27.3.1 [narrow.stream.objects]
+        27.3.2 [wide.stream.objects]
+    27.4 [iostreams.base]
+        27.4.1 [stream.types]
+        27.4.2 [ios.base]
+            27.4.2.1 [ios.types]
+                27.4.2.1.1 [ios::failure]
+                27.4.2.1.2 [ios::fmtflags]
+                27.4.2.1.3 [ios::iostate]
+                27.4.2.1.4 [ios::openmode]
+                27.4.2.1.5 [ios::seekdir]
+                27.4.2.1.6 [ios::Init]
+            27.4.2.2 [fmtflags.state]
+            27.4.2.3 [ios.base.locales]
+            27.4.2.4 [ios.members.static]
+            27.4.2.5 [ios.base.storage]
+            27.4.2.6 [ios.base.callback]
+            27.4.2.7 [ios.base.cons]
+        27.4.3 [fpos]
+            27.4.3.1 [fpos.members]
+            27.4.3.2 [fpos.operations]
+        27.4.4 [ios]
+            27.4.4.1 [basic.ios.cons]
+            27.4.4.2 [basic.ios.members]
+            27.4.4.3 [iostate.flags]
+        27.4.5 [std.ios.manip]
+            27.4.5.1 [fmtflags.manip]
+            27.4.5.2 [adjustfield.manip]
+            27.4.5.3 [basefield.manip]
+            27.4.5.4 [floatfield.manip]
+    27.5 [stream.buffers]
+        27.5.1 [streambuf.reqts]
+        27.5.2 [streambuf]
+            27.5.2.1 [streambuf.cons]
+            27.5.2.2 [streambuf.members]
+                27.5.2.2.1 [streambuf.locales]
+                27.5.2.2.2 [streambuf.buffer]
+                27.5.2.2.3 [streambuf.pub.get]
+                27.5.2.2.4 [streambuf.pub.pback]
+                27.5.2.2.5 [streambuf.pub.put]
+            27.5.2.3 [streambuf.protected]
+                27.5.2.3.1 [streambuf.assign]
+                27.5.2.3.2 [streambuf.get.area]
+                27.5.2.3.3 [streambuf.put.area]
+            27.5.2.4 [streambuf.virtuals]
+                27.5.2.4.1 [streambuf.virt.locales]
+                27.5.2.4.2 [streambuf.virt.buffer]
+                27.5.2.4.3 [streambuf.virt.get]
+                27.5.2.4.4 [streambuf.virt.pback]
+                27.5.2.4.5 [streambuf.virt.put]
+    27.6 [iostream.format]
+        27.6.1 [input.streams]
+            27.6.1.1 [istream]
+                27.6.1.1.1 [istream.cons]
+                27.6.1.1.2 [istream.assign]
+                27.6.1.1.3 [istream::sentry]
+            27.6.1.2 [istream.formatted]
+                27.6.1.2.1 [istream.formatted.reqmts]
+                27.6.1.2.2 [istream.formatted.arithmetic]
+                27.6.1.2.3 [istream::extractors]
+            27.6.1.3 [istream.unformatted]
+            27.6.1.4 [istream.manip]
+            27.6.1.5 [iostreamclass]
+                27.6.1.5.1 [iostream.cons]
+                27.6.1.5.2 [iostream.dest]
+                27.6.1.5.3 [iostream.assign]
+        27.6.2 [output.streams]
+            27.6.2.1 [ostream]
+            27.6.2.2 [ostream.cons]
+            27.6.2.3 [ostream.assign]
+            27.6.2.4 [ostream::sentry]
+            27.6.2.5 [ostream.seeks]
+            27.6.2.6 [ostream.formatted]
+                27.6.2.6.1 [ostream.formatted.reqmts]
+                27.6.2.6.2 [ostream.inserters.arithmetic]
+                27.6.2.6.3 [ostream.inserters]
+                27.6.2.6.4 [ostream.inserters.character]
+            27.6.2.7 [ostream.unformatted]
+            27.6.2.8 [ostream.manip]
+        27.6.3 [std.manip]
+        27.6.4 [ext.manip]
+    27.7 [string.streams]
+        27.7.1 [stringbuf]
+            27.7.1.1 [stringbuf.cons]
+            27.7.1.2 [stringbuf.assign]
+            27.7.1.3 [stringbuf.members]
+            27.7.1.4 [stringbuf.virtuals]
+        27.7.2 [istringstream]
+            27.7.2.1 [istringstream.cons]
+            27.7.2.2 [istringstream.assign]
+            27.7.2.3 [istringstream.members]
+        27.7.3 [ostringstream]
+            27.7.3.1 [ostringstream.cons]
+            27.7.3.2 [ostringstream.assign]
+            27.7.3.3 [ostringstream.members]
+        27.7.4 [stringstream]
+        27.7.5 [stringstream.cons]
+            27.7.5.1 [stringstream.assign]
+        27.7.6 [stringstream.members]
+    27.8 [file.streams]
+        27.8.1 [fstreams]
+            27.8.1.1 [filebuf]
+            27.8.1.2 [filebuf.cons]
+            27.8.1.3 [filebuf.assign]
+            27.8.1.4 [filebuf.members]
+            27.8.1.5 [filebuf.virtuals]
+            27.8.1.6 [ifstream]
+            27.8.1.7 [ifstream.cons]
+            27.8.1.8 [ifstream.assign]
+            27.8.1.9 [ifstream.members]
+            27.8.1.10 [ofstream]
+            27.8.1.11 [ofstream.cons]
+            27.8.1.12 [ofstream.assign]
+            27.8.1.13 [ofstream.members]
+            27.8.1.14 [fstream]
+            27.8.1.15 [fstream.cons]
+            27.8.1.16 [fstream.assign]
+            27.8.1.17 [fstream.members]
+        27.8.2 [c.files]
+28 [re]
+    28.1 [re.def]
+        28.1.1 [defns.regex.collating.element]
+        28.1.2 [defns.regex.finite.state.machine]
+        28.1.3 [defns.regex.format.specifier]
+        28.1.4 [defns.regex.matched]
+        28.1.5 [defns.regex.primary.equivalence.class]
+        28.1.6 [defns.regex.regular.expression]
+        28.1.7 [defns.regex.subexpression]
+    28.2 [re.req]
+    28.3 [re.sum]
+    28.4 [re.syn]
+    28.5 [re.const]
+        28.5.1 [re.synopt]
+        28.5.2 [re.matchflag]
+        28.5.3 [re.err]
+    28.6 [re.badexp]
+    28.7 [re.traits]
+    28.8 [re.regex]
+        28.8.1 [re.regex.const]
+        28.8.2 [re.regex.construct]
+        28.8.3 [re.regex.assign]
+        28.8.4 [re.regex.operations]
+        28.8.5 [re.regex.locale]
+        28.8.6 [re.regex.swap]
+        28.8.7 [re.regex.nonmemb]
+            28.8.7.1 [re.regex.nmswap]
+    28.9 [re.submatch]
+        28.9.1 [re.submatch.members]
+        28.9.2 [re.submatch.op]
+    28.10 [re.results]
+        28.10.1 [re.results.const]
+        28.10.2 [re.results.size]
+        28.10.3 [re.results.acc]
+        28.10.4 [re.results.form]
+        28.10.5 [re.results.all]
+        28.10.6 [re.results.swap]
+        28.10.7 [re.results.nonmember]
+    28.11 [re.alg]
+        28.11.1 [re.except]
+        28.11.2 [re.alg.match]
+        28.11.3 [re.alg.search]
+        28.11.4 [re.alg.replace]
+    28.12 [re.iter]
+        28.12.1 [re.regiter]
+            28.12.1.1 [re.regiter.cnstr]
+            28.12.1.2 [re.regiter.comp]
+            28.12.1.3 [re.regiter.deref]
+            28.12.1.4 [re.regiter.incr]
+        28.12.2 [re.tokiter]
+            28.12.2.1 [re.tokiter.cnstr]
+            28.12.2.2 [re.tokiter.comp]
+            28.12.2.3 [re.tokiter.deref]
+            28.12.2.4 [re.tokiter.incr]
+    28.13 [re.grammar]
+29 [atomics]
+    29.1 [atomics.order]
+    29.2 [atomics.lockfree]
+    29.3 [atomics.flag]
+    29.4 [atomics.types]
+        29.4.1 [atomics.types.integral]
+        29.4.2 [atomics.types.address]
+        29.4.3 [atomics.types.generic]
+        29.4.4 [atomics.types.operations]
+30 [thread]
+    30.1 [thread.req]
+        30.1.1 [thread.req.paramname]
+        30.1.2 [thread.req.exception]
+        30.1.3 [thread.req.native]
+        30.1.4 [thread.req.timing]
+    30.2 [thread.threads]
+        30.2.1 [thread.thread.class]
+            30.2.1.1 [thread.thread.id]
+            30.2.1.2 [thread.thread.constr]
+            30.2.1.3 [thread.thread.destr]
+            30.2.1.4 [thread.thread.assign]
+            30.2.1.5 [thread.thread.member]
+            30.2.1.6 [thread.thread.static]
+            30.2.1.7 [thread.thread.algorithm]
+        30.2.2 [thread.thread.this]
+    30.3 [thread.mutex]
+        30.3.1 [thread.mutex.requirements]
+            30.3.1.1 [thread.mutex.class]
+            30.3.1.2 [thread.mutex.recursive]
+        30.3.2 [thread.timedmutex.requirements]
+            30.3.2.1 [thread.timedmutex.class]
+            30.3.2.2 [thread.timedmutex.recursive]
+        30.3.3 [thread.lock]
+            30.3.3.1 [thread.lock.guard]
+            30.3.3.2 [thread.lock.unique]
+                30.3.3.2.1 [thread.lock.unique.cons]
+                30.3.3.2.2 [thread.lock.unique.locking]
+                30.3.3.2.3 [thread.lock.unique.mod]
+                30.3.3.2.4 [thread.lock.unique.obs]
+        30.3.4 [thread.lock.algorithm]
+        30.3.5 [thread.once]
+            30.3.5.1 [thread.once.onceflag]
+            30.3.5.2 [thread.once.callonce]
+    30.4 [thread.condition]
+        30.4.1 [thread.condition.condvar]
+        30.4.2 [thread.condition.condvarany]
+31 [datetime]
+    31.1 [datetime.req]
+    31.2 [datetime.syn]
+    31.3 [datetime.duration]
+    31.4 [datetime.nanoseconds]
+    31.5 [datetime.microseconds]
+    31.6 [datetime.milliseconds]
+    31.7 [datetime.seconds]
+    31.8 [datetime.minutes]
+    31.9 [datetime.hours]
+    31.10 [datetime.system]
+    31.11 [datetime.nonmembers]
+A [gram]
+    A.1 [gram.key]
+    A.2 [gram.lex]
+    A.3 [gram.basic]
+    A.4 [gram.expr]
+    A.5 [gram.stmt]
+    A.6 [gram.dcl]
+    A.7 [gram.decl]
+    A.8 [gram.class]
+    A.9 [gram.derived]
+    A.10 [gram.special]
+    A.11 [gram.over]
+    A.12 [gram.temp]
+    A.13 [gram.except]
+    A.14 [gram.cpp]
+B [implimits]
+C [diff]
+    C.1 [diff.iso]
+        C.1.1 [diff.lex]
+        C.1.2 [diff.basic]
+        C.1.3 [diff.expr]
+        C.1.4 [diff.stat]
+        C.1.5 [diff.dcl]
+        C.1.6 [diff.decl]
+        C.1.7 [diff.class]
+        C.1.8 [diff.special]
+        C.1.9 [diff.cpp]
+    C.2 [diff.library]
+        C.2.1 [diff.mods.to.headers]
+        C.2.2 [diff.mods.to.definitions]
+            C.2.2.1 [diff.char16]
+            C.2.2.2 [diff.wchar.t]
+            C.2.2.3 [diff.header.iso646.h]
+            C.2.2.4 [diff.null]
+        C.2.3 [diff.mods.to.declarations]
+        C.2.4 [diff.mods.to.behavior]
+            C.2.4.1 [diff.offsetof]
+            C.2.4.2 [diff.malloc]
+D [depr]
+    D.1 [depr.incr.bool]
+    D.2 [depr.static]
+    D.3 [depr.access.dcl]
+    D.4 [depr.string]
+    D.5 [depr.c.headers]
+    D.6 [depr.ios.members]
+    D.7 [depr.str.strstreams]
+        D.7.1 [depr.strstreambuf]
+            D.7.1.1 [depr.strstreambuf.cons]
+            D.7.1.2 [depr.strstreambuf.members]
+            D.7.1.3 [depr.strstreambuf.virtuals]
+        D.7.2 [depr.istrstream]
+            D.7.2.1 [depr.istrstream.cons]
+            D.7.2.2 [depr.istrstream.members]
+        D.7.3 [depr.ostrstream]
+            D.7.3.1 [depr.ostrstream.cons]
+            D.7.3.2 [depr.ostrstream.members]
+        D.7.4 [depr.strstream]
+            D.7.4.1 [depr.strstream.cons]
+            D.7.4.2 [depr.strstream.dest]
+            D.7.4.3 [depr.strstream.oper]
+    D.8 [depr.lib.binders]
+        D.8.1 [depr.lib.binder.1st]
+        D.8.2 [depr.lib.bind.1st]
+        D.8.3 [depr.lib.binder.2nd]
+        D.8.4 [depr.lib.bind.2nd]
+    D.9 [depr.auto.ptr]
+        D.9.1 [auto.ptr]
+            D.9.1.1 [auto.ptr.cons]
+            D.9.1.2 [auto.ptr.members]
+            D.9.1.3 [auto.ptr.conv]
+E [extendid]
+F [xref]
+
+TR1 1 [tr.intro]
+    TR1 1.1 [tr.description]
+    TR1 1.2 [tr.intro.ext]
+    TR1 1.3 [tr.intro.namespaces]
+TR1 2 [tr.util]
+    TR1 2.1 [tr.util.refwrap]
+        TR1 2.1.1 [tr.util.refwrp.synopsis]
+        TR1 2.1.2 [tr.util.refwrp.refwrp]
+            TR1 2.1.2.1 [tr.util.refwrp.const]
+            TR1 2.1.2.2 [tr.util.refwrp.assign]
+            TR1 2.1.2.3 [tr.util.refwrp.access]
+            TR1 2.1.2.4 [tr.util.refwrp.invoke]
+            TR1 2.1.2.5 [tr.util.refwrp.helpers]
+    TR1 2.2 [tr.util.smartptr]
+        TR1 2.2.1 [tr.util.smartptr.synopsis]
+        TR1 2.2.2 [tr.util.smartptr.weakptr]
+        TR1 2.2.3 [tr.util.smartptr.shared]
+            TR1 2.2.3.1 [tr.util.smartptr.shared.const]
+            TR1 2.2.3.2 [tr.util.smartptr.shared.dest]
+            TR1 2.2.3.3 [tr.util.smartptr.shared.assign]
+            TR1 2.2.3.4 [tr.util.smartptr.shared.mod]
+            TR1 2.2.3.5 [tr.util.smartptr.shared.obs]
+            TR1 2.2.3.6 [tr.util.smartptr.shared.cmp]
+            TR1 2.2.3.7 [tr.util.smartptr.shared.io]
+            TR1 2.2.3.8 [tr.util.smartptr.shared.spec]
+            TR1 2.2.3.9 [tr.util.smartptr.shared.cast]
+            TR1 2.2.3.10 [tr.util.smartptr.getdeleter]
+        TR1 2.2.4 [tr.util.smartptr.weak]
+            TR1 2.2.4.1 [tr.util.smartptr.weak.const]
+            TR1 2.2.4.2 [tr.util.smartptr.weak.dest]
+            TR1 2.2.4.3 [tr.util.smartptr.weak.assign]
+            TR1 2.2.4.4 [tr.util.smartptr.weak.mod]
+            TR1 2.2.4.5 [tr.util.smartptr.weak.obs]
+            TR1 2.2.4.6 [tr.util.smartptr.weak.cmp]
+            TR1 2.2.4.7 [tr.util.smartptr.weak.spec]
+        TR1 2.2.5 [tr.util.smartptr.enab]
+TR1 3 [tr.func]
+    TR1 3.1 [tr.func.def]
+    TR1 3.2 [tr.func.syn]
+    TR1 3.3 [tr.func.require]
+    TR1 3.4 [tr.func.ret]
+    TR1 3.5 [tr.func.memfn]
+    TR1 3.6 [tr.func.bind]
+        TR1 3.6.1 [tr.func.bind.isbind]
+        TR1 3.6.2 [tr.func.bind.isplace]
+        TR1 3.6.3 [tr.func.bind.bind]
+        TR1 3.6.4 [tr.func.bind.place]
+    TR1 3.7 [tr.func.wrap]
+        TR1 3.7.1 [tr.func.wrap.badcall]
+            TR1 3.7.1.1 [tr.func.wrap.badcall.const]
+        TR1 3.7.2 [tr.func.wrap.func]
+            TR1 3.7.2.1 [tr.func.wrap.func.con]
+            TR1 3.7.2.2 [tr.func.wrap.func.mod]
+            TR1 3.7.2.3 [tr.func.wrap.func.cap]
+            TR1 3.7.2.4 [tr.func.wrap.func.inv]
+            TR1 3.7.2.5 [tr.func.wrap.func.targ]
+            TR1 3.7.2.6 [tr.func.wrap.func.undef]
+            TR1 3.7.2.7 [tr.func.wrap.func.nullptr]
+            TR1 3.7.2.8 [tr.func.wrap.func.alg]
+TR1 4 [tr.meta]
+    TR1 4.1 [tr.meta.rqmts]
+    TR1 4.2 [tr.meta.type.synop]
+    TR1 4.3 [tr.meta.help]
+    TR1 4.4 [tr.meta.requirements]
+    TR1 4.5 [tr.meta.unary]
+        TR1 4.5.1 [tr.meta.unary.cat]
+        TR1 4.5.2 [tr.meta.unary.comp]
+        TR1 4.5.3 [tr.meta.unary.prop]
+    TR1 4.6 [tr.meta.rel]
+    TR1 4.7 [tr.meta.trans]
+        TR1 4.7.1 [tr.meta.trans.cv]
+        TR1 4.7.2 [tr.meta.trans.ref]
+        TR1 4.7.3 [tr.meta.trans.arr]
+        TR1 4.7.4 [tr.meta.trans.ptr]
+    TR1 4.8 [tr.meta.trans.other]
+    TR1 4.9 [tr.meta.req]
+TR1 5 [tr.num]
+    TR1 5.1 [tr.rand]
+        TR1 5.1.1 [tr.rand.req]
+        TR1 5.1.2 [tr.rand.synopsis]
+        TR1 5.1.3 [tr.rand.var]
+        TR1 5.1.4 [tr.rand.eng]
+            TR1 5.1.4.1 [tr.rand.eng.lcong]
+            TR1 5.1.4.2 [tr.rand.eng.mers]
+            TR1 5.1.4.3 [tr.rand.eng.sub]
+            TR1 5.1.4.4 [tr.rand.eng.sub1]
+            TR1 5.1.4.5 [tr.rand.eng.disc]
+            TR1 5.1.4.6 [tr.rand.eng.xor]
+        TR1 5.1.5 [tr.rand.predef]
+        TR1 5.1.6 [tr.rand.device]
+        TR1 5.1.7 [tr.rand.dist]
+            TR1 5.1.7.1 [tr.rand.dist.iunif]
+            TR1 5.1.7.2 [tr.rand.dist.bern]
+            TR1 5.1.7.3 [tr.rand.dist.geom]
+            TR1 5.1.7.4 [tr.rand.dist.pois]
+            TR1 5.1.7.5 [tr.rand.dist.bin]
+            TR1 5.1.7.6 [tr.rand.dist.runif]
+            TR1 5.1.7.7 [tr.rand.dist.exp]
+            TR1 5.1.7.8 [tr.rand.dist.norm]
+            TR1 5.1.7.9 [tr.rand.dist.gamma]
+    TR1 5.2 [tr.num.sf]
+        TR1 5.2.1 [tr.num.sf.cmath]
+            TR1 5.2.1.1 [tr.num.sf.Lnm]
+            TR1 5.2.1.2 [tr.num.sf.Plm]
+            TR1 5.2.1.3 [tr.num.sf.beta]
+            TR1 5.2.1.4 [tr.num.sf.ellK]
+            TR1 5.2.1.5 [tr.num.sf.ellEx]
+            TR1 5.2.1.6 [tr.num.sf.ellPx]
+            TR1 5.2.1.7 [tr.num.sf.conhyp]
+            TR1 5.2.1.8 [tr.num.sf.I]
+            TR1 5.2.1.9 [tr.num.sf.J]
+            TR1 5.2.1.10 [tr.num.sf.K]
+            TR1 5.2.1.11 [tr.num.sf.N]
+            TR1 5.2.1.12 [tr.num.sf.ellF]
+            TR1 5.2.1.13 [tr.num.sf.ellE]
+            TR1 5.2.1.14 [tr.num.sf.ellP]
+            TR1 5.2.1.15 [tr.num.sf.ei]
+            TR1 5.2.1.16 [tr.num.sf.Hn]
+            TR1 5.2.1.17 [tr.num.sf.hyper]
+            TR1 5.2.1.18 [tr.num.sf.Ln]
+            TR1 5.2.1.19 [tr.num.sf.Pl]
+            TR1 5.2.1.20 [tr.num.sf.riemannzeta]
+            TR1 5.2.1.21 [tr.num.sf.j]
+            TR1 5.2.1.22 [tr.num.sf.Ylm]
+            TR1 5.2.1.23 [tr.num.sf.n]
+        TR1 5.2.2 [tr.num.sf.mathh]
+TR1 6 [tr.cont]
+    TR1 6.1 [tr.tuple]
+        TR1 6.1.1 [tr.tuple.synopsis]
+        TR1 6.1.2 [tr.tuple.synopsis.pair]
+        TR1 6.1.3 [tr.tuple.tuple]
+            TR1 6.1.3.1 [tr.tuple.cnstr]
+            TR1 6.1.3.2 [tr.tuple.creation]
+            TR1 6.1.3.3 [tr.tuple.helper]
+            TR1 6.1.3.4 [tr.tuple.elem]
+            TR1 6.1.3.5 [tr.tuple.rel]
+        TR1 6.1.4 [tr.tuple.pairs]
+    TR1 6.2 [tr.array]
+        TR1 6.2.1 [tr.array.syn]
+        TR1 6.2.2 [tr.array.array]
+            TR1 6.2.2.1 [tr.array.cons]
+            TR1 6.2.2.2 [tr.array.special]
+            TR1 6.2.2.3 [tr.array.size]
+            TR1 6.2.2.4 [tr.array.zero]
+            TR1 6.2.2.5 [tr.array.tuple]
+    TR1 6.3 [tr.hash]
+        TR1 6.3.1 [tr.unord.req]
+            TR1 6.3.1.1 [tr.unord.req.except]
+        TR1 6.3.2 [tr.unord.fun.syn]
+        TR1 6.3.3 [tr.unord.hash]
+        TR1 6.3.4 [tr.unord.unord]
+            TR1 6.3.4.1 [tr.unord.syn.set]
+            TR1 6.3.4.2 [tr.unord.syn.map]
+            TR1 6.3.4.3 [tr.unord.set]
+                TR1 6.3.4.3.1 [tr.unord.set.cnstr]
+                TR1 6.3.4.3.2 [tr.unord.set.swap]
+            TR1 6.3.4.4 [tr.unord.map]
+                TR1 6.3.4.4.1 [tr.unord.map.cnstr]
+                TR1 6.3.4.4.2 [tr.unord.map.elem]
+                TR1 6.3.4.4.3 [tr.unord.map.swap]
+            TR1 6.3.4.5 [tr.unord.multiset]
+                TR1 6.3.4.5.1 [tr.unord.multiset.cnstr]
+                TR1 6.3.4.5.2 [tr.unord.multiset.swap]
+            TR1 6.3.4.6 [tr.unord.multimap]
+                TR1 6.3.4.6.1 [tr.unord.multimap.cnstr]
+                TR1 6.3.4.6.2 [tr.unord.multimap.swap]
+TR1 7 [tr.re]
+    TR1 7.1 [tr.re.def]
+    TR1 7.2 [tr.re.req]
+    TR1 7.3 [tr.re.sum]
+    TR1 7.4 [tr.re.syn]
+    TR1 7.5 [tr.re.const]
+        TR1 7.5.1 [tr.re.synopt]
+        TR1 7.5.2 [tr.re.matchflag]
+        TR1 7.5.3 [tr.re.err]
+    TR1 7.6 [tr.re.badexp]
+    TR1 7.7 [tr.re.traits]
+    TR1 7.8 [tr.re.regex]
+        TR1 7.8.1 [tr.re.regex.const]
+        TR1 7.8.2 [tr.re.regex.construct]
+        TR1 7.8.3 [tr.re.regex.assign]
+        TR1 7.8.4 [tr.re.regex.operations]
+        TR1 7.8.5 [tr.re.regex.locale]
+        TR1 7.8.6 [tr.re.regex.swap]
+        TR1 7.8.7 [tr.re.regex.nonmemb]
+            TR1 7.8.7.1 [tr.re.regex.nmswap.]
+    TR1 7.9 [tr.re.submatch]
+        TR1 7.9.1 [tr.re.submatch.members]
+        TR1 7.9.2 [tr.re.submatch.op]
+    TR1 7.10 [tr.re.results]
+        TR1 7.10.1 [tr.re.results.const]
+        TR1 7.10.2 [tr.re.results.size]
+        TR1 7.10.3 [tr.re.results.acc]
+        TR1 7.10.4 [tr.re.results.form]
+        TR1 7.10.5 [tr.re.results.all]
+        TR1 7.10.1 [tr.re.results.swap]
+    TR1 7.11 [tr.re.alg]
+        TR1 7.11.1 [tr.re.except]
+        TR1 7.11.2 [tr.re.alg.match]
+        TR1 7.11.3 [tr.re.alg.search]
+        TR1 7.11.4 [tr.re.alg.replace]
+    TR1 7.12 [tr.re.iter]
+        TR1 7.12.1 [tr.re.regiter]
+            TR1 7.12.1.1 [tr.re.regiter.cnstr]
+            TR1 7.12.1.2 [tr.re.regiter.comp]
+            TR1 7.12.1.3 [tr.re.regiter.deref]
+            TR1 7.12.1.4 [tr.re.regiter.incr]
+        TR1 7.12.2 [tr.re.tokiter]
+            TR1 7.12.2.1 [tr.re.tokiter.cnstr]
+            TR1 7.12.2.2 [tr.re.tokiter.comp]
+            TR1 7.12.2.3 [tr.re.tokiter.deref]
+            TR1 7.12.2.4 [tr.re.tokiter.incr]
+    TR1 7.13 [tr.re.grammar]
+TR1 8 [tr.c99]
+    TR1 8.1 [tr.c99.cmplx]
+        TR1 8.1.1 [tr.c99.cmplx.syn]
+        TR1 8.1.2 [tr.c99.cmplx.acos]
+        TR1 8.1.3 [tr.c99.cmplx.asin]
+        TR1 8.1.4 [tr.c99.cmplx.atan]
+        TR1 8.1.5 [tr.c99.cmplx.acosh]
+        TR1 8.1.6 [tr.c99.cmplx.asinh]
+        TR1 8.1.7 [tr.c99.cmplx.atanh]
+        TR1 8.1.8 [tr.c99.cmplx.fabs]
+        TR1 8.1.9 [tr.c99.cmplx.over]
+    TR1 8.2 [tr.c99.ccmplx]
+    TR1 8.3 [tr.c99.cmplxh]
+    TR1 8.4 [tr.c99.cctype]
+        TR1 8.4.1 [tr.c99.cctype.syn]
+        TR1 8.4.2 [tr.c99.cctype.blank]
+    TR1 8.5 [tr.c99.ctypeh]
+    TR1 8.6 [tr.c99.cfenv]
+        TR1 8.6.1 [tr.c99.cfenv.syn]
+        TR1 8.6.2 [tr.c99.cfenv.def]
+    TR1 8.7 [tr.c99.fenv]
+    TR1 8.8 [tr.c99.cfloat]
+    TR1 8.9 [tr.c99.floath]
+    TR1 8.10 [tr.c99.ios]
+        TR1 8.10.1 [tr.c99.ios.syn]
+        TR1 8.10.2 [tr.c99.ios.hex]
+    TR1 8.11 [tr.c99.cinttypes]
+        TR1 8.11.1 [tr.c99.cinttypes.syn]
+        TR1 8.11.2 [tr.c99.cinttypes.def]
+    TR1 8.12 [tr.c99.inttypesh]
+    TR1 8.13 [tr.c99.climits]
+    TR1 8.14 [tr.c99.limitsh]
+    TR1 8.15 [tr.c99.locale]
+    TR1 8.16 [tr.c99.cmath]
+        TR1 8.16.1 [tr.c99.cmath.syn]
+        TR1 8.16.2 [tr.c99.cmath.def]
+        TR1 8.16.3 [tr.c99.cmath.tmpl]
+        TR1 8.16.4 [tr.c99.cmath.over]
+    TR1 8.17 [tr.c99.mathh]
+    TR1 8.18 [tr.c99.cstdarg]
+    TR1 8.19 [tr.c99.stdargh]
+    TR1 8.20 [tr.c99.cbool]
+    TR1 8.21 [tr.c99.boolh]
+    TR1 8.22 [tr.c99.cstdint]
+        TR1 8.22.1 [tr.c99.cstdint.syn]
+        TR1 8.22.2 [tr.c99.cstdint.def]
+    TR1 8.23 [tr.c99.stdinth]
+    TR1 8.24 [tr.c99.cstdio]
+        TR1 8.24.1 [tr.c99.cstdio.syn]
+        TR1 8.24.2 [tr.c99.cstdio.def]
+        TR1 8.24.3 [tr.c99.cstdio.spec]
+        TR1 8.24.4 [tr.c99.stdioh]
+    TR1 8.25 [tr.c99.cstdlib]
+        TR1 8.25.1 [tr.c99.cstdlib.syn]
+        TR1 8.25.2 [tr.c99.cstdlib.def]
+        TR1 8.25.3 [tr.c99.cstdlib.abs]
+        TR1 8.25.4 [tr.c99.cstdlib.div]
+    TR1 8.26 [tr.c99.stdlibh]
+    TR1 8.27 [tr.c99.ctgmath]
+    TR1 8.28 [tr.c99.tgmathh]
+    TR1 8.29 [tr.c99.ctime]
+    TR1 8.30 [tr.c99.cwchar]
+        TR1 8.30.1 [tr.c99.cwchar.syn]
+        TR1 8.30.2 [tr.c99.cwchar.def]
+        TR1 8.30.3 [tr.c99.cwchar.spec]
+    TR1 8.31 [tr.c99.wcharh]
+    TR1 8.32 [tr.c99.cwctype]
+        TR1 8.32.1 [tr.c99.cwctype.syn]
+        TR1 8.32.2 [tr.c99.cwctype.iswblank]
+    TR1 8.33 [tr.c99.wctypeh]
+TR1 A [tr.limits]
+
+TRDecimal 1 [trdec.intro]
+    TRDecimal 1.1 [trdec.model]
+    TRDecimal 1.2 [trdec.encodings]
+    TRDecimal 1.3 [trdec.refs]
+TRDecimal 2 [trdec.conventions]
+    TRDecimal 2.1 [trdec.relation.intro]
+    TRDecimal 2.2 [trdec.relation.tr1]
+    TRDecimal 2.3 [trdec.categories]
+    TRDecimal 2.4 [trdec.namespace]
+TRDecimal 3 [trdec.types]
+    TRDecimal 3.1 [trdec.types.encodings]
+    TRDecimal 3.2 [trdec.types.types]
+        TRDecimal 3.2.1 [trdec.types.types.synopsis]
+        TRDecimal 3.2.2 [trdec.types.types.decimal32]
+            TRDecimal 3.2.2.1 [trdec.types.types.decimal32.cons]
+            TRDecimal 3.2.2.2 [trdec.types.types.decimal32.conv.float]
+            TRDecimal 3.2.2.3 [trdec.types.types.decimal32.conv.from.int]
+            TRDecimal 3.2.2.4 [trdec.types.types.decimal32.conv.to.int]
+            TRDecimal 3.2.2.5 [trdec.types.types.decimal32.incr]
+            TRDecimal 3.2.2.6 [trdec.types.types.decimal32.comp.ass]
+        TRDecimal 3.2.3 [trdec.types.types.decimal64]
+            TRDecimal 3.2.3.1 [trdec.types.types.decimal64.cons]
+            TRDecimal 3.2.3.2 [trdec.types.types.decimal64.float]
+            TRDecimal 3.2.3.3 [trdec.types.types.decimal64.from.int]
+            TRDecimal 3.2.3.4 [trdec.types.types.decimal64.to.int]
+            TRDecimal 3.2.3.5 [trdec.types.types.decimal64.incr]
+            TRDecimal 3.2.3.6 [trdec.types.types.decimal64.comp.ass]
+        TRDecimal 3.2.4 [trdec.types.types.decimal128]
+            TRDecimal 3.2.4.1 [trdec.types.types.decimal128.cons]
+            TRDecimal 3.2.4.2 [trdec.types.types.decimal128.float]
+            TRDecimal 3.2.4.3 [trdec.types.types.decimal128.from.int]
+            TRDecimal 3.2.4.4 [trdec.types.types.decimal128.to.int]
+            TRDecimal 3.2.4.5 [trdec.types.types.decimal128.incr]
+            TRDecimal 3.2.4.6 [trdec.types.types.decimal128.comp.ass]
+        TRDecimal 3.2.5 [trdec.types.types.init]
+        TRDecimal 3.2.6 [trdec.types.types.conv.float]
+        TRDecimal 3.2.7 [trdec.types.types.unary]
+        TRDecimal 3.2.8 [trdec.types.types.binary]
+        TRDecimal 3.2.9 [trdec.types.types.comp]
+        TRDecimal 3.2.10 [trdec.types.types.input]
+        TRDecimal 3.2.11 [trdec.types.types.output]
+    TRDecimal 3.3 [trdec.types.limits]
+    TRDecimal 3.4 [trdec.types.cdecfloat]
+        TRDecimal 3.4.1 [trdec.types.cdecfloat.synopsis]
+        TRDecimal 3.4.2 [trdec.types.decfloat.h.synopsis]
+        TRDecimal 3.4.3 [trdec.types.cdecfloat.max.value]
+        TRDecimal 3.4.4 [trdec.types.cdecfloat.epsilon]
+        TRDecimal 3.4.5 [trdec.types.cdecfloat.min.normal.value]
+        TRDecimal 3.4.6 [trdec.types.cdecfloat.min.subnormal.value]
+        TRDecimal 3.4.7 [trdec.types.cdecfloat.eval.format]
+    TRDecimal 3.5 [trdec.types.cfenv]
+        TRDecimal 3.5.1 [trdec.types.cfenv.synopsis]
+        TRDecimal 3.5.2 [trdec.types.cfenv.round]
+        TRDecimal 3.5.3 [trdec.types.cfenv.fe_dec_getround]
+        TRDecimal 3.5.4 [trdec.types.cfenv.fe_dec_setround]
+        TRDecimal 3.5.5 [trdec.types.cfenv.fenv.h]
+    TRDecimal 3.6 [trdec.types.cmath]
+        TRDecimal 3.6.1 [trdec.types.cmath.synopsis]
+        TRDecimal 3.6.2 [trdec.types.cmath.macros]
+        TRDecimal 3.6.3 [trdec.types.cmath.eval.format]
+        TRDecimal 3.6.4 [trdec.types.cmath.samequantum]
+        TRDecimal 3.6.5 [trdec.types.cmath.quantize]
+        TRDecimal 3.6.6 [trdec.types.cmath.elementary]
+            TRDecimal 3.6.6.1 [trdec.types.cmath.elementary.abs]
+        TRDecimal 3.6.7 [trdec.types.cmath.math.h]
+            TRDecimal 3.6.7.1 [trdec.types.cmath.math.h.synopsis]
+    TRDecimal 3.7 [trdec.types.cstdio]
+    TRDecimal 3.8 [trdec.types.cstdlib]
+        TRDecimal 3.8.1 [trdec.types.cstdlib.synopsis]
+        TRDecimal 3.8.2 [trdec.types.cstdlib.strtod]
+        TRDecimal 3.8.3 [trdec.types.cstdlib.stdlib.h]
+    TRDecimal 3.9 [trdec.types.cwchar]
+        TRDecimal 3.9.1 [trdec.types.cwchar.synopsis]
+        TRDecimal 3.9.2 [trdec.types.cwchar.wcstod]
+        TRDecimal 3.9.3 [trdec.types.cwchar.wchar.h]
+    TRDecimal 3.10 [trdec.types.facets]
+        TRDecimal 3.10.1 [trdec.types.facets.locale]
+        TRDecimal 3.10.2 [trdec.types.facets.extended_num_get]
+            TRDecimal 3.10.2.1 [trdec.types.facets.extended_num_get.mem]
+            TRDecimal 3.10.2.2 [trdec.types.facets.extended_num_get.virt]
+        TRDecimal 3.10.3 [trdec.types.facets.extended_num_put]
+            TRDecimal 3.10.3.1 [trdec.types.facets.extended_num_put.mem]
+            TRDecimal 3.10.3.2 [trdec.types.facets.extended_num_put.virt]
+    TRDecimal 3.11 [trdec.types.traits]
+        TRDecimal 3.11.1 [trdec.types.traits.synopsis]
+        TRDecimal 3.11.2 [trdec.types.traits.is_decimal_floating_point]
+    TRDecimal 3.12 [trdec.types.hash]
+        TRDecimal 3.12.1 [trdec.types.hash.synopsis]
+        TRDecimal 3.12.2 [trdec.types.hash.spec]
+TRDecimal 4 [trdec.compat]
+    TRDecimal 4.1 [trdec.compat.decfloat.h]
+    TRDecimal 4.2 [trdec.compat.literals]
+    TRDecimal 4.3 [trdec.compat.conv]