Add files using upload-large-folder tool

.gitattributes

@@ -73,3 +73,5 @@ mingw/bin/objcopy.exe filter=lfs diff=lfs merge=lfs -text
 mingw/bin/ld.bfd.exe filter=lfs diff=lfs merge=lfs -text
 mingw/bin/gprof.exe filter=lfs diff=lfs merge=lfs -text
 cmake/bin/cmake-gui.exe filter=lfs diff=lfs merge=lfs -text
+ffmpeg/bin/avformat-61.dll filter=lfs diff=lfs merge=lfs -text
+mingw/bin/strip.exe filter=lfs diff=lfs merge=lfs -text

ffmpeg/bin/avformat-61.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2c1a2587ae4ace0e08f65f79d6467b156caec6f6f3d4341ac7667bafc5a64fc
+size 19841536

mingw/bin/strip.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61968221989b7575249b850dcb4e16d79e7a8d8495daaa2daac52d3ce4411652
+size 1160718

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/assoc_container.hpp

@@ -0,0 +1,689 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file assoc_container.hpp
+ * Contains associative containers.
+ */
+
+#ifndef PB_DS_ASSOC_CNTNR_HPP
+#define PB_DS_ASSOC_CNTNR_HPP
+
+#include <ext/typelist.h>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <ext/pb_ds/detail/container_base_dispatch.hpp>
+#include <ext/pb_ds/detail/basic_tree_policy/traits.hpp>
+
+namespace __gnu_pbds
+{
+#define PB_DS_BASE_C_DEC \
+  detail::container_base_dispatch<Key, Mapped, Tag, Policy_Tl, Allocator>::type
+
+  // An abstract basic associative container.
+  template<typename Key, 
+	   typename Mapped, 
+	   typename Tag, 
+	   typename Policy_Tl, 
+	   typename Allocator>
+  class container_base : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef typename PB_DS_BASE_C_DEC 			base_type;
+
+  public:
+    typedef Tag 					container_category;
+    typedef Allocator 					allocator;
+    typedef typename allocator::size_type 		size_type;
+    typedef typename allocator::difference_type 	difference_type;
+
+    // key_type
+    typedef typename allocator::template rebind<Key>::other::value_type key_type;
+    typedef typename allocator::template rebind<key_type>::other key_rebind;
+    typedef typename key_rebind::reference 		key_reference;
+    typedef typename key_rebind::const_reference 	const_key_reference;
+    typedef typename key_rebind::pointer 		key_pointer;
+    typedef typename key_rebind::const_pointer 		const_key_pointer;
+
+    // mapped_type
+    typedef Mapped 					mapped_type;
+    typedef typename allocator::template rebind<mapped_type>::other mapped_rebind;
+    typedef typename mapped_rebind::reference 		mapped_reference;
+    typedef typename mapped_rebind::const_reference	const_mapped_reference;
+    typedef typename mapped_rebind::pointer 		mapped_pointer;
+    typedef typename mapped_rebind::const_pointer 	const_mapped_pointer;
+
+    // value_type
+    typedef typename base_type::value_type 		value_type;
+    typedef typename allocator::template rebind<value_type>::other value_rebind;
+    typedef typename value_rebind::reference		reference;
+    typedef typename value_rebind::const_reference 	const_reference;
+    typedef typename value_rebind::pointer 		pointer;
+    typedef typename value_rebind::const_pointer 	const_pointer;
+
+    // iterators
+    typedef typename base_type::iterator 		iterator;
+    typedef typename base_type::const_iterator 		const_iterator;
+    typedef typename base_type::point_iterator 		point_iterator;
+    typedef typename base_type::const_point_iterator 	const_point_iterator;
+
+    virtual
+    ~container_base() { }
+
+  protected:
+#define PB_DS_CLASS_NAME 		container_base
+#include <ext/pb_ds/detail/constructors_destructor_fn_imps.hpp>
+#undef PB_DS_CLASS_NAME
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+
+#define PB_DS_BASE_C_DEC \
+  container_base<Key, Mapped, Tag, typename __gnu_cxx::typelist::append< \
+  typename __gnu_cxx::typelist::create4<Hash_Fn, Eq_Fn, Resize_Policy, detail::integral_constant<int, Store_Hash> >::type, Policy_TL>::type, Allocator>
+
+  // An abstract basic hash-based associative container.
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn,
+	   typename Eq_Fn,
+	   typename Resize_Policy,
+	   bool Store_Hash,
+	   typename Tag,
+	   typename Policy_TL,
+	   typename Allocator>
+  class basic_hash_table : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    virtual
+    ~basic_hash_table() { }
+
+  protected:
+#define PB_DS_CLASS_NAME basic_hash_table
+#include <ext/pb_ds/detail/constructors_destructor_fn_imps.hpp>
+#undef PB_DS_CLASS_NAME
+
+  private:
+    basic_hash_table& 
+    operator=(const base_type&);
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+
+#define PB_DS_BASE_C_DEC \
+  basic_hash_table<Key, Mapped,	Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, \
+		   cc_hash_tag,	\
+	  typename __gnu_cxx::typelist::create1<Comb_Hash_Fn>::type, Allocator>
+
+  // A concrete collision-chaining hash-based associative container.
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn = typename detail::default_hash_fn<Key>::type,
+	   typename Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   typename Comb_Hash_Fn = detail::default_comb_hash_fn::type,
+	   typename Resize_Policy = typename detail::default_resize_policy<Comb_Hash_Fn>::type,
+	   bool Store_Hash = detail::default_store_hash,
+	   typename Allocator = std::allocator<char> >
+  class cc_hash_table :  public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC 	base_type;
+
+  public:
+    typedef Hash_Fn 		hash_fn;
+    typedef Eq_Fn 		eq_fn;
+    typedef Resize_Policy 	resize_policy;
+    typedef Comb_Hash_Fn 	comb_hash_fn;
+
+    // Default constructor.
+    cc_hash_table() { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the Hash_Fn object of the container object.
+    cc_hash_table(const hash_fn& h) 
+    : base_type(h) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, and
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e)
+    : base_type(h, e) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, r_eq_fn
+    // will be copied by the eq_fn object of the container object, and
+    // r_comb_hash_fn will be copied by the comb_hash_fn object of the
+    // container object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch)
+    : base_type(h, e, ch) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, r_eq_fn
+    // will be copied by the eq_fn object of the container object,
+    // r_comb_hash_fn will be copied by the comb_hash_fn object of the
+    // container object, and r_resize_policy will be copied by the
+    // resize_policy object of the container object.
+    cc_hash_table(const hash_fn& h, const eq_fn& e, const comb_hash_fn& ch, 
+		  const resize_policy& rp)    
+    : base_type(h, e, ch, rp) { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    cc_hash_table(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h)
+    : base_type(h)
+    { copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // and r_eq_fn will be copied by the eq_fn object of the container
+    // object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e)
+    : base_type(h, e)
+    { copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object, and r_comb_hash_fn will be copied by the comb_hash_fn
+    // object of the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e,
+		  const comb_hash_fn& ch)
+    : base_type(h, e, ch)
+    { copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object, r_comb_hash_fn will be copied by the comb_hash_fn
+    // object of the container object, and r_resize_policy will be
+    // copied by the resize_policy object of the container object.
+    template<typename It>
+    cc_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, 
+		  const comb_hash_fn& ch, const resize_policy& rp)
+    : base_type(h, e, ch, rp)
+    { copy_from_range(first, last); }
+
+    cc_hash_table(const cc_hash_table& other)
+    : base_type((const base_type&)other)
+    { }
+
+    virtual
+    ~cc_hash_table() { }
+
+    cc_hash_table& 
+    operator=(const cc_hash_table& other)
+    {
+      if (this != &other)
+	{
+	  cc_hash_table tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(cc_hash_table& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+
+#define PB_DS_BASE_C_DEC \
+  basic_hash_table<Key, Mapped,	Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, \
+		   gp_hash_tag, \
+		   typename __gnu_cxx::typelist::create2<Comb_Probe_Fn, Probe_Fn>::type, Allocator>
+
+  // A concrete general-probing hash-based associative container.
+  template<typename Key,
+	   typename Mapped,
+	   typename Hash_Fn = typename detail::default_hash_fn<Key>::type,
+	   typename Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   typename Comb_Probe_Fn = detail::default_comb_hash_fn::type,
+	   typename Probe_Fn = typename detail::default_probe_fn<Comb_Probe_Fn>::type,
+	   typename Resize_Policy = typename detail::default_resize_policy<Comb_Probe_Fn>::type,
+	   bool Store_Hash = detail::default_store_hash,
+	   typename Allocator = std::allocator<char> >
+  class gp_hash_table : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC 	base_type;
+
+  public:
+    typedef Hash_Fn 		hash_fn;
+    typedef Eq_Fn 		eq_fn;
+    typedef Comb_Probe_Fn	comb_probe_fn;
+    typedef Probe_Fn 		probe_fn;
+    typedef Resize_Policy 	resize_policy;
+
+    // Default constructor.
+    gp_hash_table() { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object.
+    gp_hash_table(const hash_fn& h)
+    : base_type(h) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, and
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e)
+    : base_type(h, e) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, r_eq_fn
+    // will be copied by the eq_fn object of the container object, and
+    // r_comb_probe_fn will be copied by the comb_probe_fn object of
+    // the container object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp)
+    : base_type(h, e, cp) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, r_eq_fn
+    // will be copied by the eq_fn object of the container object,
+    // r_comb_probe_fn will be copied by the comb_probe_fn object of
+    // the container object, and r_probe_fn will be copied by the
+    // probe_fn object of the container object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, 
+		  const probe_fn& p)
+    : base_type(h, e, cp, p) { }
+
+    // Constructor taking some policy objects. r_hash_fn will be
+    // copied by the hash_fn object of the container object, r_eq_fn
+    // will be copied by the eq_fn object of the container object,
+    // r_comb_probe_fn will be copied by the comb_probe_fn object of
+    // the container object, r_probe_fn will be copied by the probe_fn
+    // object of the container object, and r_resize_policy will be
+    // copied by the Resize_Policy object of the container object.
+    gp_hash_table(const hash_fn& h, const eq_fn& e, const comb_probe_fn& cp, 
+		  const probe_fn& p, const resize_policy& rp)
+    : base_type(h, e, cp, p, rp) { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    gp_hash_table(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h)
+    : base_type(h)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // and r_eq_fn will be copied by the eq_fn object of the container
+    // object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e)
+    : base_type(h, e)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object, and r_comb_probe_fn will be copied by the comb_probe_fn
+    // object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, 
+		  const comb_probe_fn& cp)
+    : base_type(h, e, cp)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object, r_comb_probe_fn will be copied by the comb_probe_fn
+    // object of the container object, and r_probe_fn will be copied
+    // by the probe_fn object of the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, 
+		  const comb_probe_fn& cp, const probe_fn& p)
+    : base_type(h, e, cp, p)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object. r_hash_fn
+    // will be copied by the hash_fn object of the container object,
+    // r_eq_fn will be copied by the eq_fn object of the container
+    // object, r_comb_probe_fn will be copied by the comb_probe_fn
+    // object of the container object, r_probe_fn will be copied by
+    // the probe_fn object of the container object, and
+    // r_resize_policy will be copied by the resize_policy object of
+    // the container object.
+    template<typename It>
+    gp_hash_table(It first, It last, const hash_fn& h, const eq_fn& e, 
+		  const comb_probe_fn& cp, const probe_fn& p, 
+		  const resize_policy& rp)
+    : base_type(h, e, cp, p, rp)
+    { base_type::copy_from_range(first, last); }
+
+    gp_hash_table(const gp_hash_table& other)
+    : base_type((const base_type&)other)
+    { }
+
+    virtual
+    ~gp_hash_table() { }
+
+    gp_hash_table& 
+    operator=(const gp_hash_table& other)
+    {
+      if (this != &other)
+	{
+	  gp_hash_table tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(gp_hash_table& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+
+#define PB_DS_BASE_C_DEC \
+  container_base<Key, Mapped, Tag, Policy_Tl, Allocator>
+
+  // An abstract basic tree-like (tree, trie) associative container.
+  template<typename Key, typename Mapped, typename Tag, 
+	   typename Node_Update, typename Policy_Tl, typename Allocator>
+  class basic_tree : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC 	base_type;
+
+  public:
+    typedef Node_Update 	node_update;
+
+    virtual
+    ~basic_tree() { }
+
+  protected:
+#define PB_DS_CLASS_NAME 		basic_tree
+#include <ext/pb_ds/detail/constructors_destructor_fn_imps.hpp>
+#undef PB_DS_CLASS_NAME
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+
+#define PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC \
+  detail::tree_traits<Key, Mapped,Cmp_Fn,Node_Update,Tag, Allocator>
+
+#define PB_DS_BASE_C_DEC \
+  basic_tree<Key,Mapped,Tag,typename PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC::node_update, \
+	     typename __gnu_cxx::typelist::create2<Cmp_Fn, PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC >::type, Allocator>
+
+  // A concrete basic tree-based associative container.
+  template<typename Key, typename Mapped, typename Cmp_Fn = std::less<Key>,
+	   typename Tag = rb_tree_tag,
+	   template<typename Const_Node_Iterator, typename Node_Iterator, typename Cmp_Fn_, typename Allocator_>
+  class Node_Update = __gnu_pbds::null_tree_node_update,
+	   typename Allocator = std::allocator<char> >
+  class tree : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC 	base_type;
+
+  public:
+    // Comparison functor type.
+    typedef Cmp_Fn 		cmp_fn;
+
+    tree() { }
+
+    // Constructor taking some policy objects. r_cmp_fn will be copied
+    // by the Cmp_Fn object of the container object.
+    tree(const cmp_fn& c)
+    : base_type(c) { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    tree(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects The value_types between first_it and
+    // last_it will be inserted into the container object. r_cmp_fn
+    // will be copied by the cmp_fn object of the container object.
+    template<typename It>
+    tree(It first, It last, const cmp_fn& c)
+      : base_type(c)
+    { base_type::copy_from_range(first, last); }
+
+    tree(const tree& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~tree() { }
+
+    tree& 
+    operator=(const tree& other)
+    {
+      if (this != &other)
+	{
+	  tree tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(tree& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_BASE_C_DEC
+#undef PB_DS_TREE_NODE_AND_IT_TRAITS_C_DEC
+
+
+#define PB_DS_TRIE_NODE_AND_ITS_TRAITS \
+  detail::trie_traits<Key,Mapped,E_Access_Traits,Node_Update,Tag,Allocator>
+
+#define PB_DS_BASE_C_DEC \
+  basic_tree<Key,Mapped,Tag, typename PB_DS_TRIE_NODE_AND_ITS_TRAITS::node_update, \
+	     typename __gnu_cxx::typelist::create2<E_Access_Traits, PB_DS_TRIE_NODE_AND_ITS_TRAITS >::type, Allocator>
+
+  // A concrete basic trie-based associative container.
+  template<typename Key,
+	   typename Mapped,
+	   typename E_Access_Traits = typename detail::default_trie_e_access_traits<Key>::type,
+	   typename Tag = pat_trie_tag,
+	   template<typename Const_Node_Iterator,
+		    typename Node_Iterator,
+		    typename E_Access_Traits_,
+		    typename Allocator_>
+  class Node_Update = null_trie_node_update,
+	   typename Allocator = std::allocator<char> >
+  class trie : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    // Element access traits type.
+    typedef E_Access_Traits e_access_traits;
+
+    trie() { }
+
+    // Constructor taking some policy objects. r_e_access_traits will
+    // be copied by the E_Access_Traits object of the container
+    // object.
+    trie(const e_access_traits& t)
+    : base_type(t) { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    trie(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects. The value_types between first_it and
+    // last_it will be inserted into the container object.
+    template<typename It>
+    trie(It first, It last, const e_access_traits& t)
+    : base_type(t)
+    { base_type::copy_from_range(first, last); }
+
+    trie(const trie& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~trie() { }
+
+    trie& 
+    operator=(const trie& other)
+    {
+      if (this != &other)
+	{
+	  trie tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(trie& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_BASE_C_DEC
+#undef PB_DS_TRIE_NODE_AND_ITS_TRAITS
+
+
+#define PB_DS_BASE_C_DEC \
+  container_base<Key, Mapped, list_update_tag, \
+		 typename __gnu_cxx::typelist::create2<Eq_Fn, Update_Policy>::type, Allocator>
+
+  // A list-update based associative container.
+  template<typename Key,
+	   typename Mapped,
+	   class Eq_Fn = typename detail::default_eq_fn<Key>::type,
+	   class Update_Policy = detail::default_update_policy::type,
+	   class Allocator = std::allocator<char> >
+  class list_update : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC 	base_type;
+
+  public:
+    typedef Eq_Fn 		eq_fn;
+    typedef Update_Policy 	update_policy;
+    typedef Allocator 		allocator;
+
+    list_update() { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    list_update(It first, It last)
+    { base_type::copy_from_range(first, last); }
+
+    list_update(const list_update& other)
+    : base_type((const base_type&)other) { }
+
+    virtual
+    ~list_update() { }
+
+    list_update& 
+    operator=(const list_update& other)
+    {
+      if (this !=& other)
+	{
+	  list_update tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(list_update& other)
+    { base_type::swap(other); }
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/basic_types.hpp

@@ -0,0 +1,217 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file basic_types.hpp
+ * Contains basic types used by containers.
+ */
+
+#ifndef PB_DS_BASIC_TYPES_HPP
+#define PB_DS_BASIC_TYPES_HPP
+
+#include <algorithm>
+#include <utility>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+    template<typename Key, typename Mapped, typename Allocator, bool Store_Hash>
+    struct value_type_base;
+
+    /**
+     * Specialization of value_type_base for the case where the hash value
+     * is not stored alongside each value.
+     **/
+    template<typename Key, typename Mapped, typename Allocator>
+    struct value_type_base<Key, Mapped, Allocator, false>
+    {
+      typedef typename Allocator::template rebind<Mapped>::other mapped_type_allocator;
+      typedef typename mapped_type_allocator::value_type mapped_type;
+      typedef typename mapped_type_allocator::pointer mapped_pointer;
+      typedef typename mapped_type_allocator::const_pointer const_mapped_pointer;
+      typedef typename mapped_type_allocator::reference mapped_reference;
+      typedef typename mapped_type_allocator::const_reference const_mapped_reference;
+
+      typedef typename Allocator::template rebind<std::pair<const Key, Mapped> >::other value_type_allocator;
+      typedef typename value_type_allocator::value_type value_type;
+      typedef typename value_type_allocator::pointer pointer;
+      typedef typename value_type_allocator::const_pointer const_pointer;
+      typedef typename value_type_allocator::reference reference;
+      typedef typename value_type_allocator::const_reference const_reference;
+
+      struct stored_value_type
+      {
+	value_type m_value;
+      };
+    };
+
+    /**
+     * Specialization of value_type_base for the case where the hash value
+     * is stored alongside each value.
+     **/
+    template<typename Key, typename Mapped, typename Allocator>
+    struct value_type_base<Key, Mapped, Allocator, true>
+    {
+      typedef typename Allocator::template rebind<Mapped>::other mapped_type_allocator;
+      typedef typename mapped_type_allocator::value_type mapped_type;
+      typedef typename mapped_type_allocator::pointer mapped_pointer;
+      typedef typename mapped_type_allocator::const_pointer const_mapped_pointer;
+      typedef typename mapped_type_allocator::reference mapped_reference;
+      typedef typename mapped_type_allocator::const_reference const_mapped_reference;
+
+      typedef typename Allocator::template rebind<std::pair<const Key, Mapped> >::other value_type_allocator;
+      typedef typename value_type_allocator::value_type value_type;
+      typedef typename value_type_allocator::pointer pointer;
+      typedef typename value_type_allocator::const_pointer const_pointer;
+      typedef typename value_type_allocator::reference reference;
+      typedef typename value_type_allocator::const_reference const_reference;
+
+      struct stored_value_type
+      {
+	value_type m_value;
+	typename Allocator::size_type m_hash;
+      };
+    };
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Allocator>
+
+#define PB_DS_CLASS_C_DEC \
+    value_type_base<Key, null_mapped_type, Allocator, false>
+
+    /**
+     * Specialization of value_type_base for the case where the hash value
+     * is not stored alongside each value.
+     **/
+    template<typename Key, typename Allocator>
+    struct value_type_base<Key, null_mapped_type, Allocator, false>
+    {
+      typedef typename Allocator::template rebind<null_mapped_type>::other mapped_type_allocator;
+      typedef typename mapped_type_allocator::value_type mapped_type;
+      typedef typename mapped_type_allocator::pointer mapped_pointer;
+      typedef typename mapped_type_allocator::const_pointer const_mapped_pointer;
+      typedef typename mapped_type_allocator::reference mapped_reference;
+      typedef typename mapped_type_allocator::const_reference const_mapped_reference;
+
+      typedef Key value_type;
+
+      typedef typename Allocator::template rebind<value_type>::other value_type_allocator;
+      typedef typename value_type_allocator::pointer pointer;
+      typedef typename value_type_allocator::const_pointer const_pointer;
+      typedef typename value_type_allocator::reference reference;
+      typedef typename value_type_allocator::const_reference const_reference;
+
+      struct stored_value_type
+      {
+	value_type m_value;
+      };
+
+      static null_mapped_type s_null_mapped;
+    };
+
+    PB_DS_CLASS_T_DEC
+    null_mapped_type PB_DS_CLASS_C_DEC::s_null_mapped;
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+    template<typename Key, typename Allocator>
+
+#define PB_DS_CLASS_C_DEC \
+    value_type_base<Key, null_mapped_type, Allocator, true>
+
+    /**
+     * Specialization of value_type_base for the case where the hash value
+     * is stored alongside each value.
+     **/
+    template<typename Key, typename Allocator>
+    struct value_type_base<Key, null_mapped_type, Allocator, true>
+    {
+      typedef typename Allocator::template rebind<null_mapped_type>::other mapped_type_allocator;
+      typedef typename mapped_type_allocator::value_type mapped_type;
+      typedef typename mapped_type_allocator::pointer mapped_pointer;
+      typedef typename mapped_type_allocator::const_pointer const_mapped_pointer;
+      typedef typename mapped_type_allocator::reference mapped_reference;
+      typedef typename mapped_type_allocator::const_reference const_mapped_reference;
+
+      typedef Key value_type;
+
+      typedef typename Allocator::template rebind<value_type>::other value_type_allocator;
+      typedef typename value_type_allocator::pointer pointer;
+      typedef typename value_type_allocator::const_pointer const_pointer;
+      typedef typename value_type_allocator::reference reference;
+      typedef typename value_type_allocator::const_reference const_reference;
+
+      struct stored_value_type
+      {
+	value_type m_value;
+	typename Allocator::size_type m_hash;
+      };
+
+      static null_mapped_type s_null_mapped;
+    };
+
+    PB_DS_CLASS_T_DEC
+    null_mapped_type PB_DS_CLASS_C_DEC::s_null_mapped;
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+    template<typename Key, typename Mapped>
+    struct no_throw_copies
+    {
+      typedef integral_constant<int, is_simple<Key>::value && is_simple<Mapped>::value> indicator;
+    };
+
+    template<typename Key>
+    struct no_throw_copies<Key, null_mapped_type>
+    {
+      typedef integral_constant<int, is_simple<Key>::value> indicator;
+    };
+  } // namespace detail
+} // namespace __gnu_pbds
+
+#endif 
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp

@@ -0,0 +1,62 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file policy_access_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn()
+{
+  return (*this);
+}
+
+PB_DS_CLASS_T_DEC
+const Cmp_Fn& 
+PB_DS_CLASS_C_DEC::
+get_cmp_fn() const
+{
+  return (*this);
+}
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/binary_heap_/resize_policy.hpp

@@ -0,0 +1,259 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file resize_policy.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+#ifndef PB_DS_BINARY_HEAP_RESIZE_POLICY_HPP
+#define PB_DS_BINARY_HEAP_RESIZE_POLICY_HPP
+
+#include <debug/debug.h>
+
+namespace __gnu_pbds
+{
+  namespace detail
+  {
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+
+#define PB_DS_CLASS_C_DEC resize_policy<Size_Type>
+
+    template<typename Size_Type>
+    class resize_policy
+    {
+    public:
+      typedef Size_Type size_type;
+
+      enum
+	{
+	  min_size = 16
+	};
+
+    public:
+      inline
+      resize_policy();
+
+      inline void
+      swap(PB_DS_CLASS_C_DEC& other);
+
+      inline bool
+      resize_needed_for_grow(size_type size) const;
+
+      inline bool
+      resize_needed_for_shrink(size_type size) const;
+
+      inline bool
+      grow_needed(size_type size) const;
+
+      inline bool
+      shrink_needed(size_type size) const;
+
+      inline size_type
+      get_new_size_for_grow() const;
+
+      inline size_type
+      get_new_size_for_shrink() const;
+
+      size_type
+      get_new_size_for_arbitrary(size_type size) const;
+
+      inline void
+      notify_grow_resize();
+
+      inline void
+      notify_shrink_resize();
+
+      void
+      notify_arbitrary(size_type actual_size);
+
+#ifdef _GLIBCXX_DEBUG
+      void
+      assert_valid() const;
+#endif 
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+      void
+      trace() const;
+#endif 
+
+    private:
+      enum
+	{
+	  ratio = 8,
+	  factor = 2
+	};
+
+    private:
+      size_type m_next_shrink_size;
+      size_type m_next_grow_size;
+    };
+
+    PB_DS_CLASS_T_DEC
+    inline
+    PB_DS_CLASS_C_DEC::
+    resize_policy() :
+      m_next_shrink_size(0),
+      m_next_grow_size(min_size)
+    { _GLIBCXX_DEBUG_ONLY(assert_valid();) }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    swap(PB_DS_CLASS_C_DEC& other)
+    {
+      std::swap(m_next_shrink_size, other.m_next_shrink_size);
+      std::swap(m_next_grow_size, other.m_next_grow_size);
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline bool
+    PB_DS_CLASS_C_DEC::
+    resize_needed_for_grow(size_type size) const
+    {
+      _GLIBCXX_DEBUG_ASSERT(size <= m_next_grow_size);
+      return size == m_next_grow_size;
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline bool
+    PB_DS_CLASS_C_DEC::
+    resize_needed_for_shrink(size_type size) const
+    {
+      _GLIBCXX_DEBUG_ASSERT(size <= m_next_grow_size);
+      return size == m_next_shrink_size;
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    get_new_size_for_grow() const
+    { return m_next_grow_size*  factor; }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    get_new_size_for_shrink() const
+    {
+      const size_type half_size = m_next_grow_size / factor;
+      return std::max(static_cast<size_type>(min_size), half_size);
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline typename PB_DS_CLASS_C_DEC::size_type
+    PB_DS_CLASS_C_DEC::
+    get_new_size_for_arbitrary(size_type size) const
+    {
+      size_type ret = min_size;
+      while (ret < size)
+	ret *= factor;
+      return ret;
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    notify_grow_resize()
+    {
+      _GLIBCXX_DEBUG_ONLY(assert_valid();)
+      _GLIBCXX_DEBUG_ASSERT(m_next_grow_size >= min_size);
+      m_next_grow_size *= factor;
+      m_next_shrink_size = m_next_grow_size / ratio;
+      _GLIBCXX_DEBUG_ONLY(assert_valid();)
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    notify_shrink_resize()
+    {
+      _GLIBCXX_DEBUG_ONLY(assert_valid();)
+      m_next_shrink_size /= factor;
+      if (m_next_shrink_size == 1)
+	m_next_shrink_size = 0;
+
+      m_next_grow_size =
+	std::max(m_next_grow_size / factor, static_cast<size_type>(min_size));
+      _GLIBCXX_DEBUG_ONLY(assert_valid();)
+    }
+
+    PB_DS_CLASS_T_DEC
+    inline void
+    PB_DS_CLASS_C_DEC::
+    notify_arbitrary(size_type actual_size)
+    {
+      m_next_grow_size = actual_size;
+      m_next_shrink_size = m_next_grow_size / ratio;
+      _GLIBCXX_DEBUG_ONLY(assert_valid();)
+    }
+
+#ifdef _GLIBCXX_DEBUG
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    assert_valid() const
+    {
+      _GLIBCXX_DEBUG_ASSERT(m_next_shrink_size == 0 ||
+		       m_next_shrink_size*  ratio == m_next_grow_size);
+
+      _GLIBCXX_DEBUG_ASSERT(m_next_grow_size >= min_size);
+    }
+#endif 
+
+#ifdef PB_DS_BINARY_HEAP_TRACE_
+    PB_DS_CLASS_T_DEC
+    void
+    PB_DS_CLASS_C_DEC::
+    trace() const
+    {
+      std::cerr << "shrink = " << m_next_shrink_size <<
+	" grow = " << m_next_grow_size << std::endl;
+    }
+#endif 
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp

@@ -0,0 +1,178 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file split_join_fn_imps.hpp
+ * Contains an implementation class for a binary_heap.
+ */
+
+PB_DS_CLASS_T_DEC
+template<typename Pred>
+void
+PB_DS_CLASS_C_DEC::
+split(Pred pred, PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ONLY(assert_valid();)
+
+    typedef
+    typename entry_pred<
+    value_type,
+    Pred,
+    simple_value,
+    Allocator>::type
+    pred_t;
+
+  const size_type left = partition(pred_t(pred));
+
+  _GLIBCXX_DEBUG_ASSERT(m_size >= left);
+
+  const size_type ersd = m_size - left;
+
+  _GLIBCXX_DEBUG_ASSERT(m_size >= ersd);
+
+  const size_type actual_size =
+    resize_policy::get_new_size_for_arbitrary(left);
+
+  const size_type other_actual_size =
+    other.get_new_size_for_arbitrary(ersd);
+
+  entry_pointer a_entries = NULL;
+  entry_pointer a_other_entries = NULL;
+
+  try
+    {
+      a_entries = s_entry_allocator.allocate(actual_size);
+
+      a_other_entries = s_entry_allocator.allocate(other_actual_size);
+    }
+  catch(...)
+    {
+      if (a_entries != NULL)
+	s_entry_allocator.deallocate(a_entries, actual_size);
+
+      if (a_other_entries != NULL)
+	s_entry_allocator.deallocate(a_other_entries, other_actual_size);
+
+      __throw_exception_again;
+    };
+
+  for (size_type i = 0; i < other.m_size; ++i)
+    erase_at(other.m_a_entries, i, s_no_throw_copies_ind);
+
+  _GLIBCXX_DEBUG_ASSERT(actual_size >= left);
+  std::copy(m_a_entries, m_a_entries + left, a_entries);
+  std::copy(m_a_entries + left, m_a_entries + m_size, a_other_entries);
+
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+  s_entry_allocator.deallocate(other.m_a_entries, other.m_actual_size);
+
+  m_actual_size = actual_size;
+  other.m_actual_size = other_actual_size;
+
+  m_size = left;
+  other.m_size = ersd;
+
+  m_a_entries = a_entries;
+  other.m_a_entries = a_other_entries;
+
+  std::make_heap(m_a_entries, m_a_entries + m_size, static_cast<entry_cmp& >(*this));
+  std::make_heap(other.m_a_entries, other.m_a_entries + other.m_size, static_cast<entry_cmp& >(other));
+
+  resize_policy::notify_arbitrary(m_actual_size);
+  other.notify_arbitrary(other.m_actual_size);
+
+  _GLIBCXX_DEBUG_ONLY(assert_valid();)
+    _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
+    }
+
+PB_DS_CLASS_T_DEC
+inline void
+PB_DS_CLASS_C_DEC::
+join(PB_DS_CLASS_C_DEC& other)
+{
+  _GLIBCXX_DEBUG_ONLY(assert_valid();)
+  _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
+
+  const size_type len = m_size + other.m_size;
+  const size_type actual_size = resize_policy::get_new_size_for_arbitrary(len);
+
+  entry_pointer a_entries = NULL;
+  entry_pointer a_other_entries = NULL;
+
+  try
+    {
+      a_entries = s_entry_allocator.allocate(actual_size);
+      a_other_entries = s_entry_allocator.allocate(resize_policy::min_size);
+    }
+  catch(...)
+    {
+      if (a_entries != NULL)
+	s_entry_allocator.deallocate(a_entries, actual_size);
+
+      if (a_other_entries != NULL)
+	s_entry_allocator.deallocate(a_other_entries, resize_policy::min_size);
+
+      __throw_exception_again;
+    }
+
+  std::copy(m_a_entries, m_a_entries + m_size, a_entries);
+  std::copy(other.m_a_entries, other.m_a_entries + other.m_size, a_entries + m_size);
+
+  s_entry_allocator.deallocate(m_a_entries, m_actual_size);
+  m_a_entries = a_entries;
+  m_size = len;
+  m_actual_size = actual_size;
+
+  resize_policy::notify_arbitrary(actual_size);
+
+  std::make_heap(m_a_entries, m_a_entries + m_size, static_cast<entry_cmp& >(*this));
+
+  s_entry_allocator.deallocate(other.m_a_entries, other.m_actual_size);
+  other.m_a_entries = a_other_entries;
+  other.m_size = 0;
+  other.m_actual_size = resize_policy::min_size;
+
+  other.notify_arbitrary(resize_policy::min_size);
+
+  _GLIBCXX_DEBUG_ONLY(assert_valid();)
+  _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
+}
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/cond_dealtor.hpp

@@ -0,0 +1,131 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file cond_dealtor.hpp
+ * Contains a conditional deallocator.
+ */
+
+#ifndef PB_DS_COND_DEALTOR_HPP
+#define PB_DS_COND_DEALTOR_HPP
+
+namespace __gnu_pbds
+{
+
+  namespace detail
+  {
+
+#define PB_DS_COND_DEALTOR_CLASS_T_DEC		\
+    template<typename Entry, class Allocator>
+
+#define PB_DS_COND_DEALTOR_CLASS_C_DEC				\
+    cond_dealtor<						\
+						Entry,		\
+						Allocator>
+
+    template<typename Entry, class Allocator>
+    class cond_dealtor
+    {
+    public:
+      typedef
+      typename Allocator::template rebind<Entry>::other
+      entry_allocator;
+
+      typedef typename entry_allocator::pointer entry_pointer;
+
+    public:
+      inline
+      cond_dealtor(entry_pointer p_e);
+
+      inline
+      ~cond_dealtor();
+
+      inline void
+      set_no_action();
+
+    private:
+      entry_pointer m_p_e;
+
+      bool m_no_action_destructor;
+
+      static entry_allocator s_alloc;
+    };
+
+    PB_DS_COND_DEALTOR_CLASS_T_DEC
+    typename PB_DS_COND_DEALTOR_CLASS_C_DEC::entry_allocator
+    PB_DS_COND_DEALTOR_CLASS_C_DEC::s_alloc;
+
+    PB_DS_COND_DEALTOR_CLASS_T_DEC
+    inline
+    PB_DS_COND_DEALTOR_CLASS_C_DEC::
+    cond_dealtor(entry_pointer p_e) :
+      m_p_e(p_e),
+      m_no_action_destructor(false)
+    { }
+
+    PB_DS_COND_DEALTOR_CLASS_T_DEC
+    inline void
+    PB_DS_COND_DEALTOR_CLASS_C_DEC::
+    set_no_action()
+    {
+      m_no_action_destructor = true;
+    }
+
+    PB_DS_COND_DEALTOR_CLASS_T_DEC
+    inline
+    PB_DS_COND_DEALTOR_CLASS_C_DEC::
+    ~cond_dealtor()
+    {
+      if (m_no_action_destructor)
+        return;
+
+      s_alloc.deallocate(m_p_e, 1);
+    }
+
+#undef PB_DS_COND_DEALTOR_CLASS_T_DEC
+#undef PB_DS_COND_DEALTOR_CLASS_C_DEC
+
+  } // namespace detail
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COND_DEALTOR_HPP
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp

@@ -0,0 +1,109 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file constructors_destructor_fn_imps.hpp
+ * Contains constructors_destructor_fn_imps applicable to different containers.
+ */
+
+inline
+PB_DS_CLASS_NAME()
+{ }
+
+inline
+PB_DS_CLASS_NAME(const PB_DS_CLASS_NAME& other) 
+: base_type((const base_type&)other)
+{ }
+
+template<typename T0>
+inline
+PB_DS_CLASS_NAME(T0 t0) : base_type(t0)
+{ }
+
+template<typename T0, typename T1>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1) : base_type(t0, t1)
+{ }
+
+template<typename T0, typename T1, typename T2>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3) 
+: base_type(t0, t1, t2, t3)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) 
+: base_type(t0, t1, t2, t3, t4)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) 
+: base_type(t0, t1, t2, t3, t4, t5)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) 
+: base_type(t0, t1, t2, t3, t4, t5, t6)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6, typename T7>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) 
+: base_type(t0, t1, t2, t3, t4, t5, t6, t7)
+{ }
+
+template<typename T0, typename T1, typename T2, typename T3, typename T4,
+	 typename T5, typename T6, typename T7, typename T8>
+inline
+PB_DS_CLASS_NAME(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
+: base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8)
+{ }

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/container_base_dispatch.hpp

@@ -0,0 +1,338 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file container_base_dispatch.hpp
+ * Contains an associative container dispatching base.
+ */
+
+#ifndef PB_DS_ASSOC_CNTNR_BASE_DS_DISPATCHER_HPP
+#define PB_DS_ASSOC_CNTNR_BASE_DS_DISPATCHER_HPP
+
+#include <ext/typelist.h>
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/list_update_map_/lu_map_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/list_update_map_/lu_map_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/splay_tree_/splay_tree_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/splay_tree_/splay_tree_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+#define PB_DS_DATA_TRUE_INDICATOR
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_.hpp>
+#undef PB_DS_DATA_TRUE_INDICATOR
+
+#define PB_DS_DATA_FALSE_INDICATOR
+#include <ext/pb_ds/detail/pat_trie_/pat_trie_.hpp>
+#undef PB_DS_DATA_FALSE_INDICATOR
+
+namespace __gnu_pbds
+{
+namespace detail
+{
+  // Primary template.
+  template<typename Key, typename Mapped, typename Data_Structure_Taq,
+	   typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch;
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, list_update_tag, 
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      
+    public:
+      typedef lu_map_data_<Key, Mapped, at0t, Alloc, at1t>	type;
+    };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, list_update_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef lu_map_no_data_<Key, null_mapped_type, at0t, Alloc, at1t> type;
+    };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, pat_trie_tag, Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef pat_trie_data_<Key, Mapped, at1t, Alloc> 		type;
+    };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, pat_trie_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef pat_trie_no_data_<Key, null_mapped_type, at1t, Alloc> type;
+    };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, rb_tree_tag, Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef rb_tree_data_<Key, Mapped, at0t, at1t, Alloc> 	type;
+    };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, rb_tree_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef rb_tree_no_data_<Key, null_mapped_type, at0t, at1t, Alloc> type;
+    };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, splay_tree_tag, 
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef splay_tree_data_<Key, Mapped, at0t, at1t, Alloc> 	type;
+    };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, splay_tree_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef splay_tree_no_data_<Key, null_mapped_type, at0t, at1t, Alloc> type;
+  };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, ov_tree_tag, Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef ov_tree_data_<Key, Mapped, at0t, at1t, Alloc> 	type;
+  };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, ov_tree_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+
+    public:
+      typedef ov_tree_no_data_<Key, null_mapped_type, at0t, at1t, Alloc> type;
+  };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, cc_hash_tag, Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+
+    public:
+      typedef cc_ht_map_data_<Key, Mapped, at0t, at1t, Alloc, at3t::value, 
+			      at4t, at2t> 			type;
+  };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, cc_hash_tag, 
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+
+    public:
+      typedef cc_ht_map_no_data_<Key, null_mapped_type, at0t, at1t, Alloc, 
+				 at3t::value, at4t, at2t>    	type;
+  };
+
+  template<typename Key, typename Mapped, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, Mapped, gp_hash_tag, Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 5> 	at5;
+      typedef typename at5::type			    	at5t;
+
+    public:
+      typedef gp_ht_map_data_<Key, Mapped, at0t, at1t, Alloc, at3t::value, 
+			      at4t, at5t, at2t> 		type;
+  };
+
+  template<typename Key, typename Policy_Tl, typename Alloc>
+    struct container_base_dispatch<Key, null_mapped_type, gp_hash_tag,
+				   Policy_Tl, Alloc>
+    {
+    private:
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 0>	at0;
+      typedef typename at0::type			    	at0t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 1> 	at1;
+      typedef typename at1::type			    	at1t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 2>	at2;
+      typedef typename at2::type			    	at2t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 3>	at3;
+      typedef typename at3::type				at3t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 4> 	at4;
+      typedef typename at4::type			    	at4t;
+      typedef __gnu_cxx::typelist::at_index<Policy_Tl, 5> 	at5;
+      typedef typename at5::type			    	at5t;
+
+    public:
+      typedef gp_ht_map_no_data_<Key, null_mapped_type, at0t, at1t, Alloc,
+				 at3t::value, at4t, at5t, at2t>	type;
+  };
+} // namespace detail
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/detail/priority_queue_base_dispatch.hpp

@@ -0,0 +1,97 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file priority_queue_base_dispatch.hpp
+ * Contains an pqiative container dispatching base.
+ */
+
+#ifndef PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
+#define PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
+
+#include <ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp>
+#include <ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp>
+#include <ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp>
+#include <ext/pb_ds/detail/binary_heap_/binary_heap_.hpp>
+#include <ext/pb_ds/detail/thin_heap_/thin_heap_.hpp>
+
+namespace __gnu_pbds
+{
+    namespace detail
+    {
+
+      template<typename Value_Type, typename Cmp_Fn, typename Tag, typename Allocator>
+      struct priority_queue_base_dispatch;
+
+      template<typename Value_Type, typename Cmp_Fn, typename Allocator>
+      struct priority_queue_base_dispatch<Value_Type, Cmp_Fn, pairing_heap_tag, Allocator>
+      {
+	typedef pairing_heap_< Value_Type, Cmp_Fn, Allocator> type;
+      };
+
+      template<typename Value_Type, typename Cmp_Fn, typename Allocator>
+      struct priority_queue_base_dispatch<Value_Type, Cmp_Fn, binomial_heap_tag, Allocator>
+      {
+	typedef binomial_heap_< Value_Type, Cmp_Fn, Allocator> type;
+      };
+
+      template<typename Value_Type, typename Cmp_Fn, typename Allocator>
+      struct priority_queue_base_dispatch<Value_Type, Cmp_Fn, rc_binomial_heap_tag, Allocator>
+      {
+	typedef rc_binomial_heap_< Value_Type, Cmp_Fn, Allocator> type;
+      };
+
+      template<typename Value_Type, typename Cmp_Fn, typename Allocator>
+      struct priority_queue_base_dispatch<Value_Type, Cmp_Fn, binary_heap_tag, Allocator>
+      {
+	typedef binary_heap_< Value_Type, Cmp_Fn, Allocator> type;
+      };
+
+      template<typename Value_Type, typename Cmp_Fn, typename Allocator>
+      struct priority_queue_base_dispatch<Value_Type, Cmp_Fn, thin_heap_tag, Allocator>
+      {
+	typedef thin_heap_< Value_Type, Cmp_Fn, Allocator> type;
+      };
+
+    } // namespace detail
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/exception.hpp

@@ -0,0 +1,109 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file exception.hpp
+ * Contains exception classes.
+ */
+
+#ifndef PB_DS_EXCEPTION_HPP
+#define PB_DS_EXCEPTION_HPP
+
+#include <stdexcept>
+#include <cstdlib>
+
+namespace __gnu_pbds
+{
+  // Base class for exceptions.
+  struct container_error : public std::logic_error
+  {
+    container_error() 
+    : std::logic_error(__N("__gnu_pbds::container_error")) { }
+  };
+
+  // An entry cannot be inserted into a container object for logical
+  // reasons (not, e.g., if memory is unabvailable, in which case
+  // the allocator's exception will be thrown).
+  struct insert_error : public container_error { };
+
+  // A join cannot be performed logical reasons (i.e., the ranges of
+  // the two container objects being joined overlaps.
+  struct join_error : public container_error { };
+
+  // A container cannot be resized.
+  struct resize_error : public container_error { };
+
+#if __EXCEPTIONS
+  inline void
+  __throw_container_error(void)
+  { throw container_error(); }
+
+  inline void
+  __throw_insert_error(void)
+  { throw insert_error(); }
+
+  inline void
+  __throw_join_error(void)
+  { throw join_error(); }
+
+  inline void
+  __throw_resize_error(void)
+  { throw resize_error(); }
+#else
+  inline void
+  __throw_container_error(void)
+  { std::abort(); }
+
+  inline void
+  __throw_insert_error(void)
+  { std::abort(); }
+
+  inline void
+  __throw_join_error(void)
+  { std::abort(); }
+
+  inline void
+  __throw_resize_error(void)
+  { std::abort(); }
+#endif
+} // namespace __gnu_pbds
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/hash_policy.hpp

@@ -0,0 +1,610 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file hash_policy.hpp
+ * Contains hash-related policies.
+ */
+
+#ifndef PB_DS_HASH_POLICY_HPP
+#define PB_DS_HASH_POLICY_HPP
+
+#include <algorithm>
+#include <vector>
+#include <cmath>
+#include <ext/pb_ds/exception.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp>
+#include <ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp>
+#include <ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp>
+
+namespace __gnu_pbds
+{
+  // A null hash function, indicating that the combining hash function
+  // is actually a ranged hash function.
+  struct null_hash_fn
+  { };
+
+  // A null probe function, indicating that the combining probe
+  // function is actually a ranged probe function.
+  struct null_probe_fn
+  { };
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC linear_probe_fn<Size_Type>
+
+  // A probe sequence policy using fixed increments.
+  template<typename Size_Type = size_t>
+  class linear_probe_fn
+  {
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    // Returns the i-th offset from the hash value.
+    inline size_type
+    operator()(size_type i) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC quadratic_probe_fn<Size_Type>
+
+  // A probe sequence policy using square increments.
+  template<typename Size_Type = size_t>
+  class quadratic_probe_fn
+  {
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    // Returns the i-th offset from the hash value.
+    inline size_type
+    operator()(size_type i) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC direct_mask_range_hashing<Size_Type>
+
+  // A mask range-hashing class (uses a bit-mask).
+  template<typename Size_Type = size_t>
+  class direct_mask_range_hashing 
+  : public detail::mask_based_range_hashing<Size_Type>
+  {
+  private:
+    typedef detail::mask_based_range_hashing<Size_Type> mask_based_base;
+
+  public:
+    typedef Size_Type size_type;
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    void
+    notify_resized(size_type size);
+
+    // Transforms the __hash value hash into a ranged-hash value
+    // (using a bit-mask).
+    inline size_type
+    operator()(size_type hash) const;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC direct_mod_range_hashing<Size_Type>
+
+  // A mod range-hashing class (uses the modulo function).
+  template<typename Size_Type = size_t>
+  class direct_mod_range_hashing 
+  : public detail::mod_based_range_hashing<Size_Type>
+  {
+  public:
+    typedef Size_Type size_type;
+      
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    void
+    notify_resized(size_type size);
+      
+    // Transforms the __hash value hash into a ranged-hash value
+    // (using a modulo operation).
+    inline size_type
+    operator()(size_type hash) const;
+      
+  private:
+    typedef detail::mod_based_range_hashing<size_type> mod_based_base;
+  };
+
+#include <ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<bool External_Load_Access, typename Size_Type>
+#define PB_DS_CLASS_C_DEC hash_load_check_resize_trigger<External_Load_Access, Size_Type>
+#define PB_DS_SIZE_BASE_C_DEC detail::hash_load_check_resize_trigger_size_base<Size_Type, External_Load_Access>
+
+  // A resize trigger policy based on a load check. It keeps the
+  // load factor between some load factors load_min and load_max.
+  template<bool External_Load_Access = false, typename Size_Type = size_t>
+  class hash_load_check_resize_trigger : private PB_DS_SIZE_BASE_C_DEC
+  {
+  public:
+    typedef Size_Type size_type;
+
+    enum
+      {
+	external_load_access = External_Load_Access
+      };
+
+    // Default constructor, or constructor taking load_min and
+    // load_max load factors between which this policy will keep the
+    // actual load.
+    hash_load_check_resize_trigger(float load_min = 0.125,
+				   float load_max = 0.5);
+
+    void
+    swap(hash_load_check_resize_trigger& other);
+
+    virtual
+    ~hash_load_check_resize_trigger();
+
+    // Returns a pair of the minimal and maximal loads, respectively.
+    inline std::pair<float, float>
+    get_loads() const;
+
+    // Sets the loads through a pair of the minimal and maximal
+    // loads, respectively.
+    void
+    set_loads(std::pair<float, float> load_pair);
+
+  protected:
+    inline void
+    notify_insert_search_start();
+
+    inline void
+    notify_insert_search_collision();
+
+    inline void
+    notify_insert_search_end();
+
+    inline void
+    notify_find_search_start();
+
+    inline void
+    notify_find_search_collision();
+
+    inline void
+    notify_find_search_end();
+
+    inline void
+    notify_erase_search_start();
+
+    inline void
+    notify_erase_search_collision();
+
+    inline void
+    notify_erase_search_end();
+
+    // Notifies an element was inserted. The total number of entries
+    // in the table is num_entries.
+    inline void
+    notify_inserted(size_type num_entries);
+
+    inline void
+    notify_erased(size_type num_entries);
+
+    // Notifies the table was cleared.
+    void
+    notify_cleared();
+
+    // Notifies the table was resized as a result of this object's
+    // signifying that a resize is needed.
+    void
+    notify_resized(size_type new_size);
+
+    void
+    notify_externally_resized(size_type new_size);
+
+    inline bool
+    is_resize_needed() const;
+
+    inline bool
+    is_grow_needed(size_type size, size_type num_entries) const;
+
+  private:
+    virtual void
+    do_resize(size_type new_size);
+
+    typedef PB_DS_SIZE_BASE_C_DEC size_base;
+
+#ifdef _GLIBCXX_DEBUG
+    void
+    assert_valid() const;
+#endif 
+
+    float 	m_load_min;
+    float 	m_load_max;
+    size_type 	m_next_shrink_size;
+    size_type 	m_next_grow_size;
+    bool 	m_resize_needed;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_SIZE_BASE_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<bool External_Load_Access, typename Size_Type>
+#define PB_DS_CLASS_C_DEC cc_hash_max_collision_check_resize_trigger<External_Load_Access, Size_Type>
+
+  // A resize trigger policy based on collision checks. It keeps the
+  // simulated load factor lower than some given load factor.
+  template<bool External_Load_Access = false, typename Size_Type = size_t>
+  class cc_hash_max_collision_check_resize_trigger
+  {
+  public:
+    typedef Size_Type size_type;
+
+    enum
+      {
+	external_load_access = External_Load_Access
+      };
+
+    // Default constructor, or constructor taking load, a __load
+    // factor which it will attempt to maintain.
+    cc_hash_max_collision_check_resize_trigger(float load = 0.5);
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+    // Returns the current load.
+    inline float
+    get_load() const;
+
+    // Sets the load; does not resize the container.
+    void
+    set_load(float load);
+
+  protected:
+    inline void
+    notify_insert_search_start();
+
+    inline void
+    notify_insert_search_collision();
+
+    inline void
+    notify_insert_search_end();
+
+    inline void
+    notify_find_search_start();
+
+    inline void
+    notify_find_search_collision();
+
+    inline void
+    notify_find_search_end();
+
+    inline void
+    notify_erase_search_start();
+
+    inline void
+    notify_erase_search_collision();
+
+    inline void
+    notify_erase_search_end();
+
+    inline void
+    notify_inserted(size_type num_entries);
+
+    inline void
+    notify_erased(size_type num_entries);
+
+    void
+    notify_cleared();
+
+    // Notifies the table was resized as a result of this object's
+    // signifying that a resize is needed.
+    void
+    notify_resized(size_type new_size);
+
+    void
+    notify_externally_resized(size_type new_size);
+
+    inline bool
+    is_resize_needed() const;
+
+    inline bool
+    is_grow_needed(size_type size, size_type num_entries) const;
+
+  private:
+    void
+    calc_max_num_coll();
+
+    inline void
+    calc_resize_needed();
+
+    float 	m_load;
+    size_type 	m_size;
+    size_type 	m_num_col;
+    size_type 	m_max_col;
+    bool 	m_resize_needed;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Type>
+#define PB_DS_CLASS_C_DEC hash_exponential_size_policy<Size_Type>
+
+  // A size policy whose sequence of sizes form an exponential
+  // sequence (typically powers of 2.
+  template<typename Size_Type = size_t>
+  class hash_exponential_size_policy
+  {
+  public:
+    typedef Size_Type size_type;
+
+    // Default constructor, or onstructor taking a start_size, or
+    // constructor taking a start size and grow_factor. The policy
+    // will use the sequence of sizes start_size, start_size*
+    // grow_factor, start_size* grow_factor^2, ...
+    hash_exponential_size_policy(size_type start_size = 8,
+				 size_type grow_factor = 2);
+
+    void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    size_type
+    get_nearest_larger_size(size_type size) const;
+
+    size_type
+    get_nearest_smaller_size(size_type size) const;
+
+  private:
+    size_type m_start_size;
+    size_type m_grow_factor;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC
+#define PB_DS_CLASS_C_DEC hash_prime_size_policy
+
+  // A size policy whose sequence of sizes form a nearly-exponential
+  // sequence of primes.
+  class hash_prime_size_policy
+  {
+  public:
+    // Size type.
+    typedef size_t size_type;
+
+    // Default constructor, or onstructor taking a start_size The
+    // policy will use the sequence of sizes approximately
+    // start_size, start_size* 2, start_size* 2^2, ...
+    hash_prime_size_policy(size_type start_size = 8);
+
+    inline void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+  protected:
+    size_type
+    get_nearest_larger_size(size_type size) const;
+
+    size_type
+    get_nearest_smaller_size(size_type size) const;
+
+  private:
+    size_type m_start_size;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<typename Size_Policy, typename Trigger_Policy, bool External_Size_Access, typename Size_Type>
+
+#define PB_DS_CLASS_C_DEC hash_standard_resize_policy<Size_Policy, Trigger_Policy, External_Size_Access, Size_Type>
+
+  // A resize policy which delegates operations to size and trigger policies.
+  template<typename Size_Policy = hash_exponential_size_policy<>,
+	   typename Trigger_Policy = hash_load_check_resize_trigger<>,
+	   bool External_Size_Access = false,
+	   typename Size_Type = size_t>
+  class hash_standard_resize_policy 
+  : public Size_Policy, public Trigger_Policy
+  {
+  public:
+    typedef Size_Type 		size_type;
+    typedef Trigger_Policy 	trigger_policy;
+    typedef Size_Policy 	size_policy;
+
+    enum
+      {
+	external_size_access = External_Size_Access
+      };
+
+    // Default constructor.
+    hash_standard_resize_policy();
+
+    // constructor taking some policies r_size_policy will be copied
+    // by the Size_Policy object of this object.
+    hash_standard_resize_policy(const Size_Policy& r_size_policy);
+
+    // constructor taking some policies. r_size_policy will be
+    // copied by the Size_Policy object of this
+    // object. r_trigger_policy will be copied by the Trigger_Policy
+    // object of this object.
+    hash_standard_resize_policy(const Size_Policy& r_size_policy, 
+				const Trigger_Policy& r_trigger_policy);
+
+    virtual
+    ~hash_standard_resize_policy();
+
+    inline void
+    swap(PB_DS_CLASS_C_DEC& other);
+
+    // Access to the Size_Policy object used.
+    Size_Policy& 
+    get_size_policy();
+
+    // Const access to the Size_Policy object used.
+    const Size_Policy& 
+    get_size_policy() const;
+
+    // Access to the Trigger_Policy object used.
+    Trigger_Policy& 
+    get_trigger_policy();
+
+    // Access to the Trigger_Policy object used.
+    const Trigger_Policy& 
+    get_trigger_policy() const;
+
+    // Returns the actual size of the container.
+    inline size_type
+    get_actual_size() const;
+
+    // Resizes the container to suggested_new_size, a suggested size
+    // (the actual size will be determined by the Size_Policy
+    // object).
+    void
+    resize(size_type suggested_new_size);
+
+  protected:
+    inline void
+    notify_insert_search_start();
+
+    inline void
+    notify_insert_search_collision();
+
+    inline void
+    notify_insert_search_end();
+
+    inline void
+    notify_find_search_start();
+
+    inline void
+    notify_find_search_collision();
+
+    inline void
+    notify_find_search_end();
+
+    inline void
+    notify_erase_search_start();
+
+    inline void
+    notify_erase_search_collision();
+
+    inline void
+    notify_erase_search_end();
+
+    inline void
+    notify_inserted(size_type num_e);
+
+    inline void
+    notify_erased(size_type num_e);
+
+    void
+    notify_cleared();
+
+    void
+    notify_resized(size_type new_size);
+
+    inline bool
+    is_resize_needed() const;
+
+    // Queries what the new size should be, when the container is
+    // resized naturally. The current __size of the container is
+    // size, and the number of used entries within the container is
+    // num_used_e.
+    size_type
+    get_new_size(size_type size, size_type num_used_e) const;
+
+  private:
+    // Resizes to new_size.
+    virtual void
+    do_resize(size_type new_size);
+
+    typedef Trigger_Policy trigger_policy_base;
+
+    typedef Size_Policy size_policy_base;
+
+    size_type m_size;
+  };
+
+#include <ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/list_update_policy.hpp

@@ -0,0 +1,142 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file list_update_policy.hpp
+ * Contains policies for list update containers.
+ */
+
+#ifndef PB_DS_LU_POLICY_HPP
+#define PB_DS_LU_POLICY_HPP
+
+#include <cstdlib>
+#include <ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp>
+
+namespace __gnu_pbds
+{
+  // A null type that means that each link in a list-based container
+  // does not actually need metadata.
+  struct null_lu_metadata
+  { };
+
+#define PB_DS_CLASS_T_DEC template<typename Allocator>
+#define PB_DS_CLASS_C_DEC move_to_front_lu_policy<Allocator>
+
+  // A list-update policy that unconditionally moves elements to the
+  // front of the list.
+  template<typename Allocator = std::allocator<char> >
+  class move_to_front_lu_policy
+  {
+  public:
+    typedef Allocator allocator;
+      
+    // Metadata on which this functor operates.
+    typedef null_lu_metadata metadata_type;
+      
+    // Reference to metadata on which this functor operates.
+    typedef typename allocator::template rebind<metadata_type>::other metadata_rebind;
+    typedef typename metadata_rebind::reference metadata_reference;
+      
+    // Creates a metadata object.
+    metadata_type
+    operator()() const;
+      
+    // Decides whether a metadata object should be moved to the front
+    // of the list.
+    inline bool
+    operator()(metadata_reference r_metadata) const;
+      
+  private:
+    static null_lu_metadata s_metadata;
+  };
+  
+#include <ext/pb_ds/detail/list_update_policy/mtf_lu_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC template<size_t Max_Count, class Allocator>
+#define PB_DS_CLASS_C_DEC counter_lu_policy<Max_Count, Allocator>
+
+  // A list-update policy that moves elements to the front of the list
+  // based on the counter algorithm.
+  template<size_t Max_Count = 5, typename Allocator = std::allocator<char> >
+  class counter_lu_policy 
+  : private detail::counter_lu_policy_base<typename Allocator::size_type>
+  {
+  public:
+    typedef Allocator allocator;
+
+    enum
+      {
+	max_count = Max_Count
+      };
+
+    typedef typename allocator::size_type size_type;
+
+    // Metadata on which this functor operates.
+    typedef detail::counter_lu_metadata<size_type> metadata_type;
+
+    // Reference to metadata on which this functor operates.
+    typedef typename Allocator::template rebind<metadata_type>::other metadata_rebind;
+    typedef typename metadata_rebind::reference metadata_reference;
+
+    // Creates a metadata object.
+    metadata_type
+    operator()() const;
+
+    // Decides whether a metadata object should be moved to the front
+    // of the list.
+    bool
+    operator()(metadata_reference r_metadata) const;
+
+  private:
+    typedef detail::counter_lu_policy_base<typename Allocator::size_type> base_type;
+  };
+
+#include <ext/pb_ds/detail/list_update_policy/counter_lu_policy_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/priority_queue.hpp

@@ -0,0 +1,131 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file priority_queue.hpp
+ * Contains priority_queues.
+ */
+
+#ifndef PB_DS_PRIORITY_QUEUE_HPP
+#define PB_DS_PRIORITY_QUEUE_HPP
+
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <ext/pb_ds/detail/priority_queue_base_dispatch.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+
+namespace __gnu_pbds
+{
+  // A priority queue.
+  template<typename Value_Type, 
+	   typename Cmp_Fn = std::less<Value_Type>,
+	   typename Tag = pairing_heap_tag,
+	   typename Allocator = std::allocator<char> >
+  class priority_queue 
+    : public detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type
+  {
+  private:
+    typedef typename detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type base_type;
+
+  public:
+    typedef Value_Type 					value_type;
+    typedef Cmp_Fn 					cmp_fn;
+    typedef Tag 					container_category;
+    typedef Allocator 					allocator;
+    typedef typename allocator::size_type 		size_type;
+    typedef typename allocator::difference_type 	difference_type;
+
+    typedef typename allocator::template rebind<value_type>::other value_rebind;
+    typedef typename value_rebind::reference 		reference;
+    typedef typename value_rebind::const_reference 	const_reference;
+    typedef typename value_rebind::pointer 	   	pointer;
+    typedef typename value_rebind::const_pointer 	const_pointer;
+
+    typedef typename base_type::const_point_iterator const_point_iterator;
+    typedef typename base_type::point_iterator 		point_iterator;
+    typedef typename base_type::const_iterator 		const_iterator;
+    typedef typename base_type::iterator 		iterator;
+
+    priority_queue() { }
+
+    // Constructor taking some policy objects. r_cmp_fn will be copied
+    // by the Cmp_Fn object of the container object.
+    priority_queue(const cmp_fn& r_cmp_fn) : base_type(r_cmp_fn) { }
+
+    // Constructor taking __iterators to a range of value_types. The
+    // value_types between first_it and last_it will be inserted into
+    // the container object.
+    template<typename It>
+    priority_queue(It first_it, It last_it)
+    { base_type::copy_from_range(first_it, last_it); }
+
+    // Constructor taking __iterators to a range of value_types and
+    // some policy objects The value_types between first_it and
+    // last_it will be inserted into the container object. r_cmp_fn
+    // will be copied by the cmp_fn object of the container object.
+    template<typename It>
+    priority_queue(It first_it, It last_it, const cmp_fn& r_cmp_fn)
+    : base_type(r_cmp_fn)
+    { base_type::copy_from_range(first_it, last_it); }
+
+    priority_queue(const priority_queue& other)
+    : base_type((const base_type& )other) { }
+
+    virtual
+    ~priority_queue() { }
+
+    priority_queue& 
+    operator=(const priority_queue& other)
+    {
+      if (this !=& other)
+	{
+	  priority_queue tmp(other);
+	  swap(tmp);
+	}
+      return *this;
+    }
+
+    void
+    swap(priority_queue& other)
+    { base_type::swap(other); }
+  };
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/tag_and_trait.hpp

@@ -0,0 +1,361 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tag_and_trait.hpp
+ * Contains tags and traits, e.g., ones describing underlying
+ *    data structures.
+ */
+
+#ifndef PB_DS_TAG_AND_TRAIT_HPP
+#define PB_DS_TAG_AND_TRAIT_HPP
+
+#include <ext/pb_ds/detail/type_utils.hpp>
+
+/**
+ * @namespace __gnu_pbds
+ * @brief GNU extensions for policy-based data structures for public use.
+ */
+namespace __gnu_pbds
+{
+  // A trivial iterator tag. Signifies that the iterators has none of
+  // the STL's movement abilities.
+  struct trivial_iterator_tag
+  { };
+
+  // Prohibit moving trivial iterators.
+  typedef void trivial_iterator_difference_type;
+
+
+  // Signifies a basic invalidation guarantee that any iterator,
+  // pointer, or reference to a container object's mapped value type
+  // is valid as long as the container is not modified.
+  struct basic_invalidation_guarantee
+  { };
+
+  // Signifies an invalidation guarantee that includes all those of
+  // its base, and additionally, that any point-type iterator,
+  // pointer, or reference to a container object's mapped value type
+  // is valid as long as its corresponding entry has not be erased,
+  // regardless of modifications to the container object.
+  struct point_invalidation_guarantee : public basic_invalidation_guarantee
+  { };
+
+  // Signifies an invalidation guarantee that includes all those of
+  // its base, and additionally, that any range-type iterator
+  // (including the returns of begin() and end()) is in the correct
+  // relative positions to other range-type iterators as long as its
+  // corresponding entry has not be erased, regardless of
+  // modifications to the container object.
+  struct range_invalidation_guarantee : public point_invalidation_guarantee
+  { };
+
+
+  // A mapped-policy indicating that an associative container is a set.
+  // XXX should this be a trait of the form is_set<T> ??
+  struct null_mapped_type { };
+
+
+  // Base data structure tag.
+  struct container_tag
+  { };
+
+  // Basic associative-container.
+  struct associative_container_tag : public container_tag { };
+
+  // Basic hash.
+  struct basic_hash_tag : public associative_container_tag { };
+
+  // Collision-chaining hash.
+  struct cc_hash_tag : public basic_hash_tag { };
+
+  // General-probing hash.
+  struct gp_hash_tag : public basic_hash_tag { };
+
+  // Basic tree.
+  struct basic_tree_tag : public associative_container_tag { };
+
+  // tree.
+  struct tree_tag : public basic_tree_tag { };
+
+  // Red-black tree.
+  struct rb_tree_tag : public tree_tag { };
+
+  // Splay tree.
+  struct splay_tree_tag : public tree_tag { };
+
+  // Ordered-vector tree.
+  struct ov_tree_tag : public tree_tag { };
+
+  // trie.
+  struct trie_tag : public basic_tree_tag { };
+
+  // PATRICIA trie.
+  struct pat_trie_tag : public trie_tag { };
+
+  // List-update.
+  struct list_update_tag : public associative_container_tag { };
+
+  // Basic priority-queue.
+  struct priority_queue_tag : public container_tag { };
+
+  // Pairing-heap.
+  struct pairing_heap_tag : public priority_queue_tag { };
+
+  // Binomial-heap.
+  struct binomial_heap_tag : public priority_queue_tag { };
+
+  // Redundant-counter binomial-heap.
+  struct rc_binomial_heap_tag : public priority_queue_tag { };
+
+  // Binary-heap (array-based).
+  struct binary_heap_tag : public priority_queue_tag { };
+
+  // Thin heap.
+  struct thin_heap_tag : public priority_queue_tag { };
+
+
+  template<typename Tag>
+  struct container_traits_base;
+
+  template<>
+  struct container_traits_base<cc_hash_tag>
+  {
+    typedef cc_hash_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<gp_hash_tag>
+  {
+    typedef gp_hash_tag container_category;
+    typedef basic_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+	erase_can_throw = false,
+	split_join_can_throw = false,
+	reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<rb_tree_tag>
+  {
+    typedef rb_tree_tag container_category;
+    typedef range_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = true,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = true
+      };
+  };
+
+  template<>
+  struct container_traits_base<splay_tree_tag>
+  {
+    typedef splay_tree_tag container_category;
+    typedef range_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = true,
+        erase_can_throw = false,
+        split_join_can_throw = false,
+        reverse_iteration = true
+      };
+  };
+
+  template<>
+  struct container_traits_base<ov_tree_tag>
+  {
+    typedef ov_tree_tag container_category;
+    typedef basic_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = true,
+        erase_can_throw = true,
+        split_join_can_throw = true,
+        reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<pat_trie_tag>
+  {
+    typedef pat_trie_tag container_category;
+    typedef range_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = true,
+        erase_can_throw = false,
+        split_join_can_throw = true,
+        reverse_iteration = true
+      };
+  };
+
+  template<>
+  struct container_traits_base<list_update_tag>
+  {
+    typedef list_update_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = false
+      };
+  };
+
+
+  template<>
+  struct container_traits_base<pairing_heap_tag>
+  {
+    typedef pairing_heap_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<thin_heap_tag>
+  {
+    typedef thin_heap_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<binomial_heap_tag>
+  {
+    typedef binomial_heap_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<rc_binomial_heap_tag>
+  {
+    typedef rc_binomial_heap_tag container_category;
+    typedef point_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = false,
+        reverse_iteration = false
+      };
+  };
+
+  template<>
+  struct container_traits_base<binary_heap_tag>
+  {
+    typedef binary_heap_tag container_category;
+    typedef basic_invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+        order_preserving = false,
+        erase_can_throw = false,
+	split_join_can_throw = true,
+        reverse_iteration = false
+      };
+  };
+
+  
+  // See Matt Austern for the name, S. Meyers MEFC++ #2, others.
+  template<typename Cntnr>
+  struct container_traits 
+  : public container_traits_base<typename Cntnr::container_category>
+  {
+    typedef Cntnr container_type;
+    typedef typename Cntnr::container_category container_category;
+    typedef container_traits_base<container_category> base_type;
+    typedef typename base_type::invalidation_guarantee invalidation_guarantee;
+
+    enum
+      {
+	order_preserving = base_type::order_preserving,
+	erase_can_throw = base_type::erase_can_throw,
+	split_join_can_throw = base_type::split_join_can_throw,
+	reverse_iteration = base_type::reverse_iteration
+      };
+  };
+} // namespace __gnu_pbds
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/tree_policy.hpp

@@ -0,0 +1,168 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file tree_policy.hpp
+ * Contains tree-related policies.
+ */
+
+#ifndef PB_DS_TREE_POLICY_HPP
+#define PB_DS_TREE_POLICY_HPP
+
+#include <iterator>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp>
+
+namespace __gnu_pbds
+{
+  // A null node updator, indicating that no node updates are required.
+  template<typename Const_Node_Iterator,
+	   typename Node_Iterator,
+	   typename Cmp_Fn,
+	   typename Allocator>
+  struct null_tree_node_update
+  { };
+
+#define PB_DS_CLASS_T_DEC \
+  template<typename Const_Node_Iterator, class Node_Iterator, class Cmp_Fn, class Allocator>
+
+#define PB_DS_CLASS_C_DEC \
+  tree_order_statistics_node_update<Const_Node_Iterator, Node_Iterator, Cmp_Fn, Allocator>
+
+#define PB_DS_BASE_C_DEC						\
+  detail::basic_tree_policy_base<Const_Node_Iterator, Node_Iterator, Allocator>
+
+  // Functor updating ranks of entrees.
+  template<typename Const_Node_Iterator, typename Node_Iterator, 
+	   typename Cmp_Fn, typename Allocator>
+  class tree_order_statistics_node_update : private PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    typedef Cmp_Fn cmp_fn;
+    typedef Allocator allocator;
+    typedef typename allocator::size_type size_type;
+    typedef typename base_type::key_type key_type;
+    typedef typename base_type::const_key_reference const_key_reference;
+
+    typedef size_type metadata_type;
+    typedef Const_Node_Iterator const_node_iterator;
+    typedef Node_Iterator node_iterator;
+    typedef typename const_node_iterator::value_type const_iterator;
+    typedef typename node_iterator::value_type iterator;
+
+    // Finds an entry by __order. Returns a const_iterator to the
+    // entry with the __order order, or a const_iterator to the
+    // container object's end if order is at least the size of the
+    // container object.
+    inline const_iterator
+    find_by_order(size_type order) const;
+
+    // Finds an entry by __order. Returns an iterator to the entry
+    // with the __order order, or an iterator to the container
+    // object's end if order is at least the size of the container
+    // object.
+    inline iterator
+    find_by_order(size_type order);
+
+    // Returns the order of a key within a sequence. For exapmle, if
+    // r_key is the smallest key, this method will return 0; if r_key
+    // is a key between the smallest and next key, this method will
+    // return 1; if r_key is a key larger than the largest key, this
+    // method will return the size of r_c.
+    inline size_type
+    order_of_key(const_key_reference r_key) const;
+
+  private:
+    // Const reference to the container's value-type.
+    typedef typename base_type::const_reference const_reference;
+
+    // Const pointer to the container's value-type.
+    typedef typename base_type::const_pointer const_pointer;
+
+    typedef typename allocator::template rebind<metadata_type>::other metadata_rebind;
+    // Const metadata reference.
+    typedef typename metadata_rebind::const_reference const_metadata_reference;
+
+    // Metadata reference.
+    typedef typename metadata_rebind::reference metadata_reference;
+
+    // Returns the const_node_iterator associated with the tree's root node.
+    virtual const_node_iterator
+    node_begin() const = 0;
+
+    // Returns the node_iterator associated with the tree's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    // Returns the const_node_iterator associated with a just-after leaf node.
+    virtual const_node_iterator
+    node_end() const = 0;
+
+    // Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    // Access to the cmp_fn object.
+    virtual cmp_fn& 
+    get_cmp_fn() = 0;
+
+  protected:
+    // Updates the rank of a node through a node_iterator node_it;
+    // end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator node_it, const_node_iterator end_nd_it) const;
+
+    virtual
+    ~tree_order_statistics_node_update();
+  };
+
+#include <ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_BASE_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif 

mingw/lib/gcc/mingw32/4.3.3/include/c++/ext/pb_ds/trie_policy.hpp

@@ -0,0 +1,361 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License.  This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file trie_policy.hpp
+ * Contains trie-related policies.
+ */
+
+#ifndef PB_DS_TRIE_POLICY_HPP
+#define PB_DS_TRIE_POLICY_HPP
+
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/trie_policy/trie_policy_base.hpp>
+
+namespace __gnu_pbds
+{
+  // A null node updator, indicating that no node updates are required.
+  template<typename Const_Node_Iterator,
+	   typename Node_Iterator,
+	   typename E_Access_Traits,
+	   typename Allocator>
+  struct null_trie_node_update
+  { };
+
+#define PB_DS_CLASS_T_DEC						\
+  template<typename String, typename String::value_type Min_E_Val, typename String::value_type Max_E_Val, bool Reverse, typename Allocator>
+
+#define PB_DS_CLASS_C_DEC						\
+  string_trie_e_access_traits<String, Min_E_Val,Max_E_Val,Reverse,Allocator>
+
+  // Element access traits for string types.
+  template<typename String = std::string,
+	   typename String::value_type Min_E_Val = detail::__numeric_traits<typename String::value_type>::__min, 
+	   typename String::value_type Max_E_Val = detail::__numeric_traits<typename String::value_type>::__max, 
+	   bool Reverse = false,
+	   typename Allocator = std::allocator<char> >
+  struct string_trie_e_access_traits
+  {
+  public:
+    typedef typename Allocator::size_type size_type;
+    typedef String key_type;
+    typedef typename Allocator::template rebind<key_type>::other key_rebind;
+    typedef typename key_rebind::const_reference const_key_reference;
+
+    enum
+      {
+	reverse = Reverse
+      };
+
+    // Element const iterator type.
+    typedef typename detail::__conditional_type<Reverse, typename String::const_reverse_iterator, typename String::const_iterator>::__type const_iterator;
+
+    // Element type.
+    typedef typename std::iterator_traits<const_iterator>::value_type e_type;
+
+    enum
+      {
+	min_e_val = Min_E_Val,
+	max_e_val = Max_E_Val,
+	max_size = max_e_val - min_e_val + 1
+      };
+    PB_DS_STATIC_ASSERT(min_max_size, max_size >= 2);
+
+    // Returns a const_iterator to the first element of
+    // const_key_reference agumnet.
+    inline static const_iterator
+    begin(const_key_reference);
+
+    // Returns a const_iterator to the after-last element of
+    // const_key_reference argument.
+    inline static const_iterator
+    end(const_key_reference);
+
+    // Maps an element to a position.
+    inline static size_type
+    e_pos(e_type e);
+
+  private:
+
+    inline static const_iterator
+    begin_imp(const_key_reference, detail::false_type);
+
+    inline static const_iterator
+    begin_imp(const_key_reference, detail::true_type);
+
+    inline static const_iterator
+    end_imp(const_key_reference, detail::false_type);
+
+    inline static const_iterator
+    end_imp(const_key_reference, detail::true_type);
+
+    static detail::integral_constant<int, Reverse> s_rev_ind;
+  };
+
+#include <ext/pb_ds/detail/trie_policy/string_trie_e_access_traits_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_T_DEC \
+  template<typename Const_Node_Iterator,typename Node_Iterator,class E_Access_Traits, typename Allocator>
+
+#define PB_DS_CLASS_C_DEC \
+  trie_prefix_search_node_update<Const_Node_Iterator, Node_Iterator, E_Access_Traits,Allocator>
+
+#define PB_DS_BASE_C_DEC \
+  detail::trie_policy_base<Const_Node_Iterator,Node_Iterator,E_Access_Traits, Allocator>
+
+  // A node updator that allows tries to be searched for the range of
+  // values that match a certain prefix.
+  template<typename Const_Node_Iterator,
+	   typename Node_Iterator,
+	   typename E_Access_Traits,
+	   typename Allocator>
+  class trie_prefix_search_node_update : private PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    typedef typename base_type::key_type key_type;
+    typedef typename base_type::const_key_reference const_key_reference;
+
+    // Element access traits.
+    typedef E_Access_Traits e_access_traits;
+
+    // Const element iterator.
+    typedef typename e_access_traits::const_iterator const_e_iterator;
+
+    // Allocator type.
+    typedef Allocator allocator;
+
+    // Size type.
+    typedef typename allocator::size_type size_type;
+    typedef detail::null_node_metadata metadata_type;
+    typedef Const_Node_Iterator const_node_iterator;
+    typedef Node_Iterator node_iterator;
+    typedef typename const_node_iterator::value_type const_iterator;
+    typedef typename node_iterator::value_type iterator;
+
+    // Finds the const iterator range corresponding to all values
+    // whose prefixes match r_key.
+    std::pair<const_iterator, const_iterator>
+    prefix_range(const_key_reference) const;
+
+    // Finds the iterator range corresponding to all values whose
+    // prefixes match r_key.
+    std::pair<iterator, iterator>
+    prefix_range(const_key_reference);
+
+    // Finds the const iterator range corresponding to all values
+    // whose prefixes match [b, e).
+    std::pair<const_iterator, const_iterator>
+    prefix_range(const_e_iterator, const_e_iterator) const;
+
+    // Finds the iterator range corresponding to all values whose
+    // prefixes match [b, e).
+    std::pair<iterator, iterator>
+    prefix_range(const_e_iterator, const_e_iterator);
+
+  protected:
+    // Called to update a node's metadata.
+    inline void
+    operator()(node_iterator node_it, const_node_iterator end_nd_it) const;
+
+  private:
+    // Returns the const iterator associated with the just-after last element.
+    virtual const_iterator
+    end() const = 0;
+
+    // Returns the iterator associated with the just-after last element.
+    virtual iterator
+    end() = 0;
+
+    // Returns the const_node_iterator associated with the trie's root node.
+    virtual const_node_iterator
+    node_begin() const = 0;
+
+    // Returns the node_iterator associated with the trie's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    // Returns the const_node_iterator associated with a just-after leaf node.
+    virtual const_node_iterator
+    node_end() const = 0;
+
+    // Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    // Access to the cmp_fn object.
+    virtual const e_access_traits& 
+    get_e_access_traits() const = 0;
+
+    node_iterator
+    next_child(node_iterator, const_e_iterator, const_e_iterator, 
+	       node_iterator, const e_access_traits&);
+  };
+
+#include <ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp>
+
+#undef PB_DS_CLASS_C_DEC
+
+#define PB_DS_CLASS_C_DEC \
+  trie_order_statistics_node_update<Const_Node_Iterator, Node_Iterator,E_Access_Traits, Allocator>
+
+  // Functor updating ranks of entrees.
+  template<typename Const_Node_Iterator,
+	   typename Node_Iterator,
+	   typename E_Access_Traits,
+	   typename Allocator>
+  class trie_order_statistics_node_update : private PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    typedef E_Access_Traits e_access_traits;
+    typedef typename e_access_traits::const_iterator const_e_iterator;
+    typedef Allocator allocator;
+    typedef typename allocator::size_type size_type;
+    typedef typename base_type::key_type key_type;
+    typedef typename base_type::const_key_reference const_key_reference;
+
+    typedef size_type metadata_type;
+    typedef Const_Node_Iterator const_node_iterator;
+    typedef Node_Iterator node_iterator;
+    typedef typename const_node_iterator::value_type const_iterator;
+    typedef typename node_iterator::value_type iterator;
+
+    // Finds an entry by __order. Returns a const_iterator to the
+    // entry with the __order order, or a const_iterator to the
+    // container object's end if order is at least the size of the
+    // container object.
+    inline const_iterator
+    find_by_order(size_type) const;
+
+    // Finds an entry by __order. Returns an iterator to the entry
+    // with the __order order, or an iterator to the container
+    // object's end if order is at least the size of the container
+    // object.
+    inline iterator
+    find_by_order(size_type);
+
+    // Returns the order of a key within a sequence. For exapmle, if
+    // r_key is the smallest key, this method will return 0; if r_key
+    // is a key between the smallest and next key, this method will
+    // return 1; if r_key is a key larger than the largest key, this
+    // method will return the size of r_c.
+    inline size_type
+    order_of_key(const_key_reference) const;
+
+    // Returns the order of a prefix within a sequence. For exapmle,
+    // if [b, e] is the smallest prefix, this method will return 0; if
+    // r_key is a key between the smallest and next key, this method
+    // will return 1; if r_key is a key larger than the largest key,
+    // this method will return the size of r_c.
+    inline size_type
+    order_of_prefix(const_e_iterator, const_e_iterator) const;
+
+  private:
+    typedef typename base_type::const_reference const_reference;
+    typedef typename base_type::const_pointer const_pointer;
+
+    typedef typename Allocator::template rebind<metadata_type>::other metadata_rebind;
+    typedef typename metadata_rebind::const_reference const_metadata_reference;
+    typedef typename metadata_rebind::reference metadata_reference;
+
+    // Returns true if the container is empty.
+    virtual bool
+    empty() const = 0;
+
+    // Returns the iterator associated with the trie's first element.
+    virtual iterator
+    begin() = 0;
+
+    // Returns the iterator associated with the trie's
+    // just-after-last element.
+    virtual iterator
+    end() = 0;
+
+    // Returns the const_node_iterator associated with the trie's root node.
+    virtual const_node_iterator
+    node_begin() const = 0;
+
+    // Returns the node_iterator associated with the trie's root node.
+    virtual node_iterator
+    node_begin() = 0;
+
+    // Returns the const_node_iterator associated with a just-after
+    // leaf node.
+    virtual const_node_iterator
+    node_end() const = 0;
+
+    // Returns the node_iterator associated with a just-after leaf node.
+    virtual node_iterator
+    node_end() = 0;
+
+    // Access to the cmp_fn object.
+    virtual e_access_traits& 
+    get_e_access_traits() = 0;
+
+  protected:
+    // Updates the rank of a node through a node_iterator node_it;
+    // end_nd_it is the end node iterator.
+    inline void
+    operator()(node_iterator, const_node_iterator) const;
+
+    // Destructor.
+    virtual
+    ~trie_order_statistics_node_update();
+  };
+
+#include <ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp>
+
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_BASE_C_DEC
+
+} // namespace __gnu_pbds
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cstdbool

@@ -0,0 +1,45 @@
+// TR1 cstdbool -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cstdbool
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDBOOL
+#define _GLIBCXX_TR1_CSTDBOOL 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+#if _GLIBCXX_HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDBOOL

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cstdint

@@ -0,0 +1,81 @@
+// TR1 cstdint -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cstdint
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDINT
+#define _GLIBCXX_TR1_CSTDINT 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <bits/c++config.h>
+
+// For 8.22.1/1 (see C99, Notes 219, 220, 222)
+# if _GLIBCXX_HAVE_STDINT_H
+#  ifndef __STDC_LIMIT_MACROS
+#   define _UNDEF__STDC_LIMIT_MACROS
+#   define __STDC_LIMIT_MACROS
+#  endif
+#  ifndef __STDC_CONSTANT_MACROS
+#   define _UNDEF__STDC_CONSTANT_MACROS
+#   define __STDC_CONSTANT_MACROS
+#  endif
+#  include <stdint.h>
+#  ifdef _UNDEF__STDC_LIMIT_MACROS
+#   undef __STDC_LIMIT_MACROS
+#   undef _UNDEF__STDC_LIMIT_MACROS
+#  endif
+#  ifdef _UNDEF__STDC_CONSTANT_MACROS
+#   undef __STDC_CONSTANT_MACROS
+#   undef _UNDEF__STDC_CONSTANT_MACROS
+#  endif
+# endif
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdint>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdint>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDINT
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cstdio

@@ -0,0 +1,59 @@
+// TR1 cstdio -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cstdio
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDIO
+#define _GLIBCXX_TR1_CSTDIO 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cstdio>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdio>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdio>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDIO

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cstdlib

@@ -0,0 +1,59 @@
+// TR1 cstdlib -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cstdlib
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CSTDLIB
+#define _GLIBCXX_TR1_CSTDLIB 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cstdlib>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cstdlib>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cstdlib>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_CSTDLIB

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/ctgmath

@@ -0,0 +1,39 @@
+// TR1 ctgmath -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/ctgmath
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CTGMATH
+#define _GLIBCXX_TR1_CTGMATH 1
+
+#include <tr1/cmath>
+
+#endif // _GLIBCXX_TR1_CTGMATH

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/ctime

@@ -0,0 +1,39 @@
+// TR1 ctime -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/ctime
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CTIME
+#define _GLIBCXX_TR1_CTIME 1
+
+#include <ctime>
+
+#endif // _GLIBCXX_TR1_CTIME

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/ctype.h

@@ -0,0 +1,39 @@
+// TR1 ctype.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/ctype.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_CTYPE_H
+#define _TR1_CTYPE_H 1
+
+#include <tr1/cctype>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cwchar

@@ -0,0 +1,59 @@
+// TR1 cwchar -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cwchar
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CWCHAR
+#define _GLIBCXX_TR1_CWCHAR 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cwchar>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cwchar>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cwchar>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_CWCHAR

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/cwctype

@@ -0,0 +1,59 @@
+// TR1 cwctype -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/cwctype
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_CWCTYPE
+#define _GLIBCXX_TR1_CWCTYPE 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cwctype>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/cwctype>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/cwctype>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_CWCTYPE

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/ell_integral.tcc

@@ -0,0 +1,753 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/ell_integral.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1)  B. C. Carlson Numer. Math. 33, 1 (1979)
+//   (2)  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+//   (3)  The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (4)  Numerical Recipes in C, 2nd ed, by W. H. Press, S. A. Teukolsky,
+//        W. T. Vetterling, B. P. Flannery, Cambridge University Press
+//        (1992), pp. 261-269
+
+#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+    /**
+     *   @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$
+     *          of the first kind.
+     * 
+     *   The Carlson elliptic function of the first kind is defined by:
+     *   @f[
+     *       R_F(x,y,z) = \frac{1}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}}
+     *   @f]
+     *
+     *   @param  __x  The first of three symmetric arguments.
+     *   @param  __y  The second of three symmetric arguments.
+     *   @param  __z  The third of three symmetric arguments.
+     *   @return  The Carlson elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rf(const _Tp __x, const _Tp __y, const _Tp __z)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rf."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim)
+        std::__throw_domain_error(__N("Argument too small in __ellint_rf"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(24);
+          const _Tp __c2 = _Tp(1) / _Tp(10);
+          const _Tp __c3 = _Tp(3) / _Tp(44);
+          const _Tp __c4 = _Tp(1) / _Tp(14);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn) / _Tp(3);
+              __xndev = 2 - (__mu + __xn) / __mu;
+              __yndev = 2 - (__mu + __yn) / __mu;
+              __zndev = 2 - (__mu + __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
+          const _Tp __e3 = __xndev * __yndev * __zndev;
+          const _Tp __s  = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
+                   + __c4 * __e3;
+
+          return __s / std::sqrt(__mu);
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the first kind
+     *          @f$ K(k) @f$ by series expansion.
+     * 
+     *   The complete elliptic integral of the first kind is defined as
+     *   @f[
+     *     K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
+     *                              {\sqrt{1 - k^2sin^2\theta}}
+     *   @f]
+     * 
+     *   This routine is not bad as long as |k| is somewhat smaller than 1
+     *   but is not is good as the Carlson elliptic integral formulation.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1_series(const _Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk / _Tp(4);
+      _Tp __sum = _Tp(1) + __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          __term *= (2 * __i - 1) * __kk / (2 * __i);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * __sum;
+    }
+
+
+    /**
+     *   @brief  Return the complete elliptic integral of the first kind
+     *           @f$ K(k) @f$ using the Carlson formulation.
+     * 
+     *   The complete elliptic integral of the first kind is defined as
+     *   @f[
+     *     K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
+     *                                           {\sqrt{1 - k^2 sin^2\theta}}
+     *   @f]
+     *   where @f$ F(k,\phi) @f$ is the incomplete elliptic integral of the
+     *   first kind.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1(const _Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) >= _Tp(1))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
+    }
+
+
+    /**
+     *   @brief  Return the incomplete elliptic integral of the first kind
+     *           @f$ F(k,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the first kind is defined as
+     *   @f[
+     *     F(k,\phi) = \int_0^{\phi}\frac{d\theta}
+     *                                   {\sqrt{1 - k^2 sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the first kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_1(const _Tp __k, const _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_1."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __c = std::cos(__phi_red);
+
+          const _Tp __F = __s
+                        * __ellint_rf(__c * __c,
+                                _Tp(1) - __k * __k * __s * __s, _Tp(1));
+
+          if (__n == 0)
+            return __F;
+          else
+            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the second kind
+     *          @f$ E(k) @f$ by series expansion.
+     * 
+     *   The complete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   This routine is not bad as long as |k| is somewhat smaller than 1
+     *   but is not is good as the Carlson elliptic integral formulation.
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2_series(const _Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk;
+      _Tp __sum = __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          const _Tp __i2m = 2 * __i - 1;
+          const _Tp __i2 = 2 * __i;
+          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term / __i2m;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function of the second kind
+     *           @f$ R_D(x,y,z) = R_J(x,y,z,z) @f$ where
+     *           @f$ R_J(x,y,z,p) @f$ is the Carlson elliptic function
+     *           of the third kind.
+     * 
+     *   The Carlson elliptic function of the second kind is defined by:
+     *   @f[
+     *       R_D(x,y,z) = \frac{3}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{3/2}}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first of two symmetric arguments.
+     *   @param  __y  The second of two symmetric arguments.
+     *   @param  __z  The third argument.
+     *   @return  The Carlson elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rd(const _Tp __x, const _Tp __y, const _Tp __z)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
+      const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rd."));
+      else if (__x + __y < __lolim || __z < __lolim)
+        std::__throw_domain_error(__N("Argument too small "
+                                      "in __ellint_rd."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(6);
+          const _Tp __c3 = _Tp(9) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              _Tp __xnroot = std::sqrt(__xn);
+              _Tp __ynroot = std::sqrt(__yn);
+              _Tp __znroot = std::sqrt(__zn);
+              _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                           + __ynroot * __znroot;
+              __sigma += __power4 / (__znroot * (__zn + __lambda));
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+          _Tp __ea = __xndev * __yndev;
+          _Tp __eb = __zndev * __zndev;
+          _Tp __ec = __ea - __eb;
+          _Tp __ed = __ea - _Tp(6) * __eb;
+          _Tp __ef = __ed + __ec + __ec;
+          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
+                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
+                                   / _Tp(2));
+          _Tp __s2 = __zndev
+                   * (__c2 * __ef
+                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea));
+
+          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
+                                        / (__mu * std::sqrt(__mu));
+        }
+    }
+
+
+    /**
+     *   @brief  Return the complete elliptic integral of the second kind
+     *           @f$ E(k) @f$ using the Carlson formulation.
+     * 
+     *   The complete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the complete elliptic function.
+     *   @return  The complete elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2(const _Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) == 1)
+        return _Tp(1);
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __comp_ellint_2."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the incomplete elliptic integral of the second kind
+     *           @f$ E(k,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the second kind is defined as
+     *   @f[
+     *     E(k,\phi) = \int_0^{\phi} \sqrt{1 - k^2 sin^2\theta}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the second kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_2(const _Tp __k, const _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_2."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __E = __s
+                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        - __kk * __sss
+                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        / _Tp(3);
+
+          if (__n == 0)
+            return __E;
+          else
+            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function
+     *           @f$ R_C(x,y) = R_F(x,y,y) @f$ where @f$ R_F(x,y,z) @f$
+     *           is the Carlson elliptic function of the first kind.
+     * 
+     *   The Carlson elliptic function is defined by:
+     *   @f[
+     *       R_C(x,y) = \frac{1}{2} \int_0^\infty
+     *                 \frac{dt}{(t + x)^{1/2}(t + y)}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first argument.
+     *   @param  __y  The second argument.
+     *   @return  The Carlson elliptic function.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rc(const _Tp __x, const _Tp __y)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rc."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(7);
+          const _Tp __c2 = _Tp(9) / _Tp(22);
+          const _Tp __c3 = _Tp(3) / _Tp(10);
+          const _Tp __c4 = _Tp(3) / _Tp(8);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __sn;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
+              __sn = (__yn + __mu) / __mu - _Tp(2);
+              if (std::abs(__sn) < __errtol)
+                break;
+              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
+                             + __yn;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+            }
+
+          _Tp __s = __sn * __sn
+                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
+
+          return (_Tp(1) + __s) / std::sqrt(__mu);
+        }
+    }
+
+
+    /**
+     *   @brief  Return the Carlson elliptic function @f$ R_J(x,y,z,p) @f$
+     *           of the third kind.
+     * 
+     *   The Carlson elliptic function of the third kind is defined by:
+     *   @f[
+     *       R_J(x,y,z,p) = \frac{3}{2} \int_0^\infty
+     *       \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}(t + p)}
+     *   @f]
+     *
+     *   Based on Carlson's algorithms:
+     *   -  B. C. Carlson Numer. Math. 33, 1 (1979)
+     *   -  B. C. Carlson, Special Functions of Applied Mathematics (1977)
+     *   -  Numerical Recipes in C, 2nd ed, pp. 261-269,
+     *      by Press, Teukolsky, Vetterling, Flannery (1992)
+     *
+     *   @param  __x  The first of three symmetric arguments.
+     *   @param  __y  The second of three symmetric arguments.
+     *   @param  __z  The third of three symmetric arguments.
+     *   @param  __p  The fourth argument.
+     *   @return  The Carlson elliptic function of the fourth kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_rj(const _Tp __x, const _Tp __y, const _Tp __z, const _Tp __p)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
+      const _Tp __uplim = _Tp(0.3L)
+                        * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(__N("Argument less than zero "
+                                      "in __ellint_rj."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim || __p < __lolim)
+        std::__throw_domain_error(__N("Argument too small "
+                                      "in __ellint_rj"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(3);
+          const _Tp __c3 = _Tp(3) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __pn = __p;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+
+          _Tp __lambda, __mu;
+          _Tp __xndev, __yndev, __zndev, __pndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              __pndev = (__mu - __pn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              __epsilon = std::max(__epsilon, std::abs(__pndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
+                                + __xnroot * __ynroot * __znroot;
+              const _Tp __alpha2 = __alpha1 * __alpha1;
+              const _Tp __beta = __pn * (__pn + __lambda)
+                                      * (__pn + __lambda);
+              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+              __pn = __c0 * (__pn + __lambda);
+            }
+
+          _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev;
+          _Tp __eb = __xndev * __yndev * __zndev;
+          _Tp __ec = __pndev * __pndev;
+          _Tp __e2 = __ea - _Tp(3) * __ec;
+          _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec);
+          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
+                            - _Tp(3) * __c4 * __e3 / _Tp(2));
+          _Tp __s2 = __eb * (__c2 / _Tp(2)
+                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
+          _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3)
+                   - __c2 * __pndev * __ec;
+
+          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
+                                             / (__mu * std::sqrt(__mu));
+        }
+    }
+
+
+    /**
+     *   @brief Return the complete elliptic integral of the third kind
+     *          @f$ \Pi(k,\nu) = \Pi(k,\nu,\pi/2) @f$ using the
+     *          Carlson formulation.
+     * 
+     *   The complete elliptic integral of the third kind is defined as
+     *   @f[
+     *     \Pi(k,\nu) = \int_0^{\pi/2}
+     *                   \frac{d\theta}
+     *                 {(1 - \nu \sin^2\theta)\sqrt{1 - k^2 \sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __nu  The second argument of the elliptic function.
+     *   @return  The complete elliptic function of the third kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_3(const _Tp __k, const _Tp __nu)
+    {
+
+      if (__isnan(__k) || __isnan(__nu))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__nu == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __comp_ellint_3."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __nu
+               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) + __nu)
+               / _Tp(3);
+        }
+    }
+
+
+    /**
+     *   @brief Return the incomplete elliptic integral of the third kind
+     *          @f$ \Pi(k,\nu,\phi) @f$ using the Carlson formulation.
+     * 
+     *   The incomplete elliptic integral of the third kind is defined as
+     *   @f[
+     *     \Pi(k,\nu,\phi) = \int_0^{\phi}
+     *                       \frac{d\theta}
+     *                            {(1 - \nu \sin^2\theta)
+     *                             \sqrt{1 - k^2 \sin^2\theta}}
+     *   @f]
+     * 
+     *   @param  __k  The argument of the elliptic function.
+     *   @param  __nu  The second argument of the elliptic function.
+     *   @param  __phi  The integral limit argument of the elliptic function.
+     *   @return  The elliptic function of the third kind.
+     */
+    template<typename _Tp>
+    _Tp
+    __ellint_3(const _Tp __k, const _Tp __nu, const _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in __ellint_3."));
+      else
+        {
+          //  Reduce phi to -pi/2 < phi < +pi/2.
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __Pi = __s
+                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                         - __nu * __sss
+                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
+                                       _Tp(1) + __nu * __ss) / _Tp(3);
+
+          if (__n == 0)
+            return __Pi;
+          else
+            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
+        }
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/inttypes.h

@@ -0,0 +1,39 @@
+// TR1 inttypes.h -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/inttypes.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_INTTYPES_H
+#define _GLIBCXX_TR1_INTTYPES_H 1
+
+#include <tr1/cinttypes>
+
+#endif // _GLIBCXX_TR1_INTTYPES_H

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/legendre_function.tcc

@@ -0,0 +1,310 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/legendre_function.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 8, pp. 331-341
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 252-254
+
+#ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
+#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
+
+#include "special_function_util.h"
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+    /**
+     *   @brief  Return the Legendre polynomial by recursion on order
+     *           @f$ l @f$.
+     * 
+     *   The Legendre function of @f$ l @f$ and @f$ x @f$,
+     *   @f$ P_l(x) @f$, is defined by:
+     *   @f[
+     *     P_l(x) = \frac{1}{2^l l!}\frac{d^l}{dx^l}(x^2 - 1)^{l}
+     *   @f]
+     * 
+     *   @param  l  The order of the Legendre polynomial.  @f$l >= 0@f$.
+     *   @param  x  The argument of the Legendre polynomial.  @f$|x| <= 1@f$.
+     */
+    template<typename _Tp>
+    _Tp
+    __poly_legendre_p(const unsigned int __l, const _Tp __x)
+    {
+
+      if ((__x < _Tp(-1)) || (__x > _Tp(+1)))
+        std::__throw_domain_error(__N("Argument out of range"
+                                      " in __poly_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == +_Tp(1))
+        return +_Tp(1);
+      else if (__x == -_Tp(1))
+        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
+      else
+        {
+          _Tp __p_lm2 = _Tp(1);
+          if (__l == 0)
+            return __p_lm2;
+
+          _Tp __p_lm1 = __x;
+          if (__l == 1)
+            return __p_lm1;
+
+          _Tp __p_l = 0;
+          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
+            {
+              //  This arrangement is supposed to be better for roundoff
+              //  protection, Arfken, 2nd Ed, Eq 12.17a.
+              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
+                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
+              __p_lm2 = __p_lm1;
+              __p_lm1 = __p_l;
+            }
+
+          return __p_l;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the associated Legendre function by recursion
+     *           on @f$ l @f$.
+     * 
+     *   The associated Legendre function is derived from the Legendre function
+     *   @f$ P_l(x) @f$ by the Rodrigues formula:
+     *   @f[
+     *     P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x)
+     *   @f]
+     * 
+     *   @param  l  The order of the associated Legendre function.
+     *              @f$ l >= 0 @f$.
+     *   @param  m  The order of the associated Legendre function.
+     *              @f$ m <= l @f$.
+     *   @param  x  The argument of the associated Legendre function.
+     *              @f$ |x| <= 1 @f$.
+     */
+    template<typename _Tp>
+    _Tp
+    __assoc_legendre_p(const unsigned int __l, const unsigned int __m,
+                       const _Tp __x)
+    {
+
+      if (__x < _Tp(-1) || __x > _Tp(+1))
+        std::__throw_domain_error(__N("Argument out of range"
+                                      " in __assoc_legendre_p."));
+      else if (__m > __l)
+        std::__throw_domain_error(__N("Degree out of range"
+                                      " in __assoc_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__m == 0)
+        return __poly_legendre_p(__l, __x);
+      else
+        {
+          _Tp __p_mm = _Tp(1);
+          if (__m > 0)
+            {
+              //  Two square roots seem more accurate more of the time
+              //  than just one.
+              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
+              _Tp __fact = _Tp(1);
+              for (unsigned int __i = 1; __i <= __m; ++__i)
+                {
+                  __p_mm *= -__fact * __root;
+                  __fact += _Tp(2);
+                }
+            }
+          if (__l == __m)
+            return __p_mm;
+
+          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
+          if (__l == __m + 1)
+            return __p_mp1m;
+
+          _Tp __p_lm2m = __p_mm;
+          _Tp __P_lm1m = __p_mp1m;
+          _Tp __p_lm = _Tp(0);
+          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
+            {
+              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
+                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
+              __p_lm2m = __P_lm1m;
+              __P_lm1m = __p_lm;
+            }
+
+          return __p_lm;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the spherical associated Legendre function.
+     * 
+     *   The spherical associated Legendre function of @f$ l @f$, @f$ m @f$,
+     *   and @f$ \theta @f$ is defined as @f$ Y_l^m(\theta,0) @f$ where
+     *   @f[
+     *      Y_l^m(\theta,\phi) = (-1)^m[\frac{(2l+1)}{4\pi}
+     *                                  \frac{(l-m)!}{(l+m)!}]
+     *                     P_l^m(\cos\theta) \exp^{im\phi}
+     *   @f]
+     *   is the spherical harmonic function and @f$ P_l^m(x) @f$ is the
+     *   associated Legendre function.
+     * 
+     *   This function differs from the associated Legendre function by
+     *   argument (@f$x = \cos(\theta)@f$) and by a normalization factor
+     *   but this factor is rather large for large @f$ l @f$ and @f$ m @f$
+     *   and so this function is stable for larger differences of @f$ l @f$
+     *   and @f$ m @f$.
+     * 
+     *   @param  l  The order of the spherical associated Legendre function.
+     *              @f$ l >= 0 @f$.
+     *   @param  m  The order of the spherical associated Legendre function.
+     *              @f$ m <= l @f$.
+     *   @param  theta  The radian angle argument of the spherical associated
+     *                  Legendre function.
+     */
+    template <typename _Tp>
+    _Tp
+    __sph_legendre(const unsigned int __l, const unsigned int __m,
+                   const _Tp __theta)
+    {
+      if (__isnan(__theta))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+
+      const _Tp __x = std::cos(__theta);
+
+      if (__l < __m)
+        {
+          std::__throw_domain_error(__N("Bad argument "
+                                        "in __sph_legendre."));
+        }
+      else if (__m == 0)
+        {
+          _Tp __P = __poly_legendre_p(__l, __x);
+          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
+                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          __P *= __fact;
+          return __P;
+        }
+      else if (__x == _Tp(1) || __x == -_Tp(1))
+        {
+          //  m > 0 here
+          return _Tp(0);
+        }
+      else
+        {
+          // m > 0 and |x| < 1 here
+
+          // Starting value for recursion.
+          // Y_m^m(x) = sqrt( (2m+1)/(4pi m) gamma(m+1/2)/gamma(m) )
+          //             (-1)^m (1-x^2)^(m/2) / pi^(1/4)
+          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
+#if _GLIBCXX_USE_C99_MATH_TR1
+          const _Tp __lncirc = std::tr1::log1p(-__x * __x);
+#else
+          const _Tp __lncirc = std::log(_Tp(1) - __x * __x);
+#endif
+          //  Gamma(m+1/2) / Gamma(m)
+#if _GLIBCXX_USE_C99_MATH_TR1
+          const _Tp __lnpoch = std::tr1::lgamma(_Tp(__m + _Tp(0.5L)))
+                             - std::tr1::lgamma(_Tp(__m));
+#else
+          const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L)))
+                             - __log_gamma(_Tp(__m));
+#endif
+          const _Tp __lnpre_val =
+                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
+                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
+          _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
+                   / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
+          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;
+
+          if (__l == __m)
+            {
+              return __y_mm;
+            }
+          else if (__l == __m + 1)
+            {
+              return __y_mp1m;
+            }
+          else
+            {
+              _Tp __y_lm = _Tp(0);
+
+              // Compute Y_l^m, l > m+1, upward recursion on l.
+              for ( int __ll = __m + 2; __ll <= __l; ++__ll)
+                {
+                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
+                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
+                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
+                                                       * _Tp(2 * __ll - 1));
+                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
+                                                                / _Tp(2 * __ll - 3));
+                  __y_lm = (__x * __y_mp1m * __fact1
+                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
+                  __y_mm = __y_mp1m;
+                  __y_mp1m = __y_lm;
+                }
+
+              return __y_lm;
+            }
+        }
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/limits.h

@@ -0,0 +1,39 @@
+// TR1 limits.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/limits.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_LIMITS_H
+#define _TR1_LIMITS_H 1
+
+#include <tr1/climits>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/math.h

@@ -0,0 +1,191 @@
+// TR1 math.h -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/math.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_MATH_H
+#define _GLIBCXX_TR1_MATH_H 1
+
+#include <tr1/cmath>
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+using std::tr1::acos;
+using std::tr1::acosh;
+using std::tr1::asin;
+using std::tr1::asinh;
+using std::tr1::atan;
+using std::tr1::atan2;
+using std::tr1::atanh;
+using std::tr1::cbrt;
+using std::tr1::ceil;
+using std::tr1::copysign;
+using std::tr1::cos;
+using std::tr1::cosh;
+using std::tr1::erf;
+using std::tr1::erfc;
+using std::tr1::exp;
+using std::tr1::exp2;
+using std::tr1::expm1;
+using std::tr1::fabs;
+using std::tr1::fdim;
+using std::tr1::floor;
+using std::tr1::fma;
+using std::tr1::fmax;
+using std::tr1::fmin;
+using std::tr1::fmod;
+using std::tr1::frexp;
+using std::tr1::hypot;
+using std::tr1::ilogb;
+using std::tr1::ldexp;
+using std::tr1::lgamma;
+using std::tr1::llrint;
+using std::tr1::llround;
+using std::tr1::log;
+using std::tr1::log10;
+using std::tr1::log1p;
+using std::tr1::log2;
+using std::tr1::logb;
+using std::tr1::lrint;
+using std::tr1::lround;
+using std::tr1::nearbyint;
+using std::tr1::nextafter;
+using std::tr1::nexttoward;
+using std::tr1::pow;
+using std::tr1::remainder;
+using std::tr1::remquo;
+using std::tr1::rint;
+using std::tr1::round;
+using std::tr1::scalbln;
+using std::tr1::scalbn;
+using std::tr1::sin;
+using std::tr1::sinh;
+using std::tr1::sqrt;
+using std::tr1::tan;
+using std::tr1::tanh;
+using std::tr1::tgamma;
+using std::tr1::trunc;
+
+#endif
+
+using std::tr1::assoc_laguerref;
+using std::tr1::assoc_laguerre;
+using std::tr1::assoc_laguerrel;
+
+using std::tr1::assoc_legendref;
+using std::tr1::assoc_legendre;
+using std::tr1::assoc_legendrel;
+
+using std::tr1::betaf;
+using std::tr1::beta;
+using std::tr1::betal;
+
+using std::tr1::comp_ellint_1f;
+using std::tr1::comp_ellint_1;
+using std::tr1::comp_ellint_1l;
+
+using std::tr1::comp_ellint_2f;
+using std::tr1::comp_ellint_2;
+using std::tr1::comp_ellint_2l;
+
+using std::tr1::comp_ellint_3f;
+using std::tr1::comp_ellint_3;
+using std::tr1::comp_ellint_3l;
+
+using std::tr1::conf_hypergf;
+using std::tr1::conf_hyperg;
+using std::tr1::conf_hypergl;
+
+using std::tr1::cyl_bessel_if;
+using std::tr1::cyl_bessel_i;
+using std::tr1::cyl_bessel_il;
+
+using std::tr1::cyl_bessel_jf;
+using std::tr1::cyl_bessel_j;
+using std::tr1::cyl_bessel_jl;
+
+using std::tr1::cyl_bessel_kf;
+using std::tr1::cyl_bessel_k;
+using std::tr1::cyl_bessel_kl;
+
+using std::tr1::cyl_neumannf;
+using std::tr1::cyl_neumann;
+using std::tr1::cyl_neumannl;
+
+using std::tr1::ellint_1f;
+using std::tr1::ellint_1;
+using std::tr1::ellint_1l;
+
+using std::tr1::ellint_2f;
+using std::tr1::ellint_2;
+using std::tr1::ellint_2l;
+
+using std::tr1::ellint_3f;
+using std::tr1::ellint_3;
+using std::tr1::ellint_3l;
+
+using std::tr1::expintf;
+using std::tr1::expint;
+using std::tr1::expintl;
+
+using std::tr1::hermitef;
+using std::tr1::hermite;
+using std::tr1::hermitel;
+
+using std::tr1::hypergf;
+using std::tr1::hyperg;
+using std::tr1::hypergl;
+
+using std::tr1::laguerref;
+using std::tr1::laguerre;
+using std::tr1::laguerrel;
+
+using std::tr1::legendref;
+using std::tr1::legendre;
+using std::tr1::legendrel;
+
+using std::tr1::riemann_zetaf;
+using std::tr1::riemann_zeta;
+using std::tr1::riemann_zetal;
+
+using std::tr1::sph_besself;
+using std::tr1::sph_bessel;
+using std::tr1::sph_bessell;
+
+using std::tr1::sph_legendref;
+using std::tr1::sph_legendre;
+using std::tr1::sph_legendrel;
+
+using std::tr1::sph_neumannf;
+using std::tr1::sph_neumann;
+using std::tr1::sph_neumannl;
+
+#endif // _GLIBCXX_TR1_MATH_H

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/memory

@@ -0,0 +1,74 @@
+// <tr1/memory> -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1/memory
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_MEMORY
+#define _GLIBCXX_TR1_MEMORY 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <memory>
+#include <exception>        	// std::exception
+#include <typeinfo>         	// std::type_info in get_deleter
+#include <bits/stl_algobase.h>  // std::swap
+#include <iosfwd>           	// std::basic_ostream
+#include <ext/atomicity.h>
+#include <ext/concurrence.h>
+#include <bits/functexcept.h>
+#include <bits/stl_function.h> 	// std::less
+#include <debug/debug.h>
+#include <tr1/type_traits>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/boost_sp_counted_base.h>
+#  include <tr1/boost_sp_shared_count.h>
+#  include <tr1_impl/boost_shared_ptr.h>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/boost_sp_counted_base.h>
+#  include <tr1/boost_sp_shared_count.h>
+#  include <tr1_impl/boost_shared_ptr.h>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_MEMORY

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/modified_bessel_func.tcc

@@ -0,0 +1,441 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/modified_bessel_func.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland.
+//
+// References:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 9, pp. 355-434, Section 10 pp. 435-478
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky,
+//       W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992),
+//       2nd ed, pp. 246-249.
+
+#ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
+#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
+
+#include "special_function_util.h"
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+    /**
+     *   @brief  Compute the modified Bessel functions @f$ I_\nu(x) @f$ and
+     *           @f$ K_\nu(x) @f$ and their first derivatives
+     *           @f$ I'_\nu(x) @f$ and @f$ K'_\nu(x) @f$ respectively.
+     *           These four functions are computed together for numerical
+     *           stability.
+     *
+     *   @param  __nu  The order of the Bessel functions.
+     *   @param  __x   The argument of the Bessel functions.
+     *   @param  __Inu  The output regular modified Bessel function.
+     *   @param  __Knu  The output irregular modified Bessel function.
+     *   @param  __Ipnu  The output derivative of the regular
+     *                   modified Bessel function.
+     *   @param  __Kpnu  The output derivative of the irregular
+     *                   modified Bessel function.
+     */
+    template <typename _Tp>
+    void
+    __bessel_ik(const _Tp __nu, const _Tp __x,
+                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Inu = _Tp(1);
+              __Ipnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0);
+            }
+          __Knu = std::numeric_limits<_Tp>::infinity();
+          __Kpnu = -std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+
+      const int __nl = static_cast<int>(__nu + _Tp(0.5L));
+
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __h = __nu * __xi;
+      if ( __h < __fp_min )
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for ( __i = 1; __i <= __max_iter; ++__i )
+        {
+          __b += __xi2;
+          __d = _Tp(1) / (__b + __d);
+          __c = __b + _Tp(1) / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(__N("Argument x too large "
+                                       "in __bessel_jn; "
+                                       "try asymptotic expansion."));
+      _Tp __Inul = __fp_min;
+      _Tp __Ipnul = __h * __Inul;
+      _Tp __Inul1 = __Inul;
+      _Tp __Ipnu1 = __Ipnul;
+      _Tp __fact = __nu * __xi;
+      for (int __l = __nl; __l >= 1; --__l)
+        {
+          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
+          __fact -= __xi;
+          __Ipnul = __fact * __Inutemp + __Inul;
+          __Inul = __Inutemp;
+        }
+      _Tp __f = __Ipnul / __Inul;
+      _Tp __Kmu, __Knu1;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          const _Tp __fact = (std::abs(__pimu) < __eps
+                            ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          const _Tp __fact2 = (std::abs(__e) < __eps
+                            ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = __fact
+                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          _Tp __sum = __ff;
+          __e = std::exp(__e);
+          _Tp __p = __e / (_Tp(2) * __gampl);
+          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
+          _Tp __c = _Tp(1);
+          __d = __x2 * __x2;
+          _Tp __sum1 = __p;
+          int __i;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / __i;
+              __p /= __i - __mu;
+              __q /= __i + __mu;
+              const _Tp __del = __c * __ff;
+              __sum += __del; 
+              const _Tp __del1 = __c * (__p - __i * __ff);
+              __sum1 += __del1;
+              if (std::abs(__del) < __eps * std::abs(__sum))
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(__N("Bessel k series failed to converge "
+                                           "in __bessel_jn."));
+          __Kmu = __sum;
+          __Knu1 = __sum1 * __xi2;
+        }
+      else
+        {
+          _Tp __b = _Tp(2) * (_Tp(1) + __x);
+          _Tp __d = _Tp(1) / __b;
+          _Tp __delh = __d;
+          _Tp __h = __delh;
+          _Tp __q1 = _Tp(0);
+          _Tp __q2 = _Tp(1);
+          _Tp __a1 = _Tp(0.25L) - __mu2;
+          _Tp __q = __c = __a1;
+          _Tp __a = -__a1;
+          _Tp __s = _Tp(1) + __q * __delh;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a -= 2 * (__i - 1);
+              __c = -__a * __c / __i;
+              const _Tp __qnew = (__q1 - __b * __q2) / __a;
+              __q1 = __q2;
+              __q2 = __qnew;
+              __q += __c * __qnew;
+              __b += _Tp(2);
+              __d = _Tp(1) / (__b + __a * __d);
+              __delh = (__b * __d - _Tp(1)) * __delh;
+              __h += __delh;
+              const _Tp __dels = __q * __delh;
+              __s += __dels;
+              if ( std::abs(__dels / __s) < __eps )
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(__N("Steed's method failed "
+                                           "in __bessel_jn."));
+          __h = __a1 * __h;
+          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
+                * std::exp(-__x) / __s;
+          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
+        }
+
+      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
+      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
+      __Inu = __Inumu * __Inul1 / __Inul;
+      __Ipnu = __Inumu * __Ipnu1 / __Inul;
+      for ( __i = 1; __i <= __nl; ++__i )
+        {
+          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
+          __Kmu = __Knu1;
+          __Knu1 = __Knutemp;
+        }
+      __Knu = __Kmu;
+      __Kpnu = __nu * __xi * __Kmu - __Knu1;
+  
+      return;
+    }
+
+
+    /**
+     *   @brief  Return the regular modified Bessel function of order
+     *           \f$ \nu \f$: \f$ I_{\nu}(x) \f$.
+     *
+     *   The regular modified cylindrical Bessel function is:
+     *   @f[
+     *    I_{\nu}(x) = \sum_{k=0}^{\infty}
+     *              \frac{(x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
+     *   @f]
+     *
+     *   @param  __nu  The order of the regular modified Bessel function.
+     *   @param  __x   The argument of the regular modified Bessel function.
+     *   @return  The output regular modified Bessel function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_i(const _Tp __nu, const _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_bessel_i."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __I_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Return the irregular modified Bessel function
+     *           \f$ K_{\nu}(x) \f$ of order \f$ \nu \f$.
+     *
+     *   The irregular modified Bessel function is defined by:
+     *   @f[
+     *      K_{\nu}(x) = \frac{\pi}{2}
+     *                   \frac{I_{-\nu}(x) - I_{\nu}(x)}{\sin \nu\pi}
+     *   @f]
+     *   where for integral \f$ \nu = n \f$ a limit is taken:
+     *   \f$ lim_{\nu \to n} \f$.
+     *
+     *   @param  __nu  The order of the irregular modified Bessel function.
+     *   @param  __x   The argument of the irregular modified Bessel function.
+     *   @return  The output irregular modified Bessel function.
+     */
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_k(const _Tp __nu, const _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(__N("Bad argument "
+                                      "in __cyl_bessel_k."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __K_nu;
+        }
+    }
+
+
+    /**
+     *   @brief  Compute the spherical modified Bessel functions
+     *           @f$ i_n(x) @f$ and @f$ k_n(x) @f$ and their first
+     *           derivatives @f$ i'_n(x) @f$ and @f$ k'_n(x) @f$
+     *           respectively.
+     *
+     *   @param  __n  The order of the modified spherical Bessel function.
+     *   @param  __x  The argument of the modified spherical Bessel function.
+     *   @param  __i_n  The output regular modified spherical Bessel function.
+     *   @param  __k_n  The output irregular modified spherical
+     *                  Bessel function.
+     *   @param  __ip_n  The output derivative of the regular modified
+     *                   spherical Bessel function.
+     *   @param  __kp_n  The output derivative of the irregular modified
+     *                   spherical Bessel function.
+     */
+    template <typename _Tp>
+    void
+    __sph_bessel_ik(const unsigned int __n, const _Tp __x,
+                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+
+      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+
+      __i_n = __factor * __I_nu;
+      __k_n = __factor * __K_nu;
+      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
+      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
+
+      return;
+    }
+
+
+    /**
+     *   @brief  Compute the Airy functions
+     *           @f$ Ai(x) @f$ and @f$ Bi(x) @f$ and their first
+     *           derivatives @f$ Ai'(x) @f$ and @f$ Bi(x) @f$
+     *           respectively.
+     *
+     *   @param  __n  The order of the Airy functions.
+     *   @param  __x  The argument of the Airy functions.
+     *   @param  __i_n  The output Airy function.
+     *   @param  __k_n  The output Airy function.
+     *   @param  __ip_n  The output derivative of the Airy function.
+     *   @param  __kp_n  The output derivative of the Airy function.
+     */
+    template <typename _Tp>
+    void
+    __airy(const _Tp __x,
+           _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
+    {
+      const _Tp __absx = std::abs(__x);
+      const _Tp __rootx = std::sqrt(__absx);
+      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
+
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x > _Tp(0))
+        {
+          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+
+          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Ai = __rootx * __K_nu
+               / (__numeric_constants<_Tp>::__sqrt3()
+                * __numeric_constants<_Tp>::__pi());
+          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
+                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
+
+          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Aip = -__x * __K_nu
+                / (__numeric_constants<_Tp>::__sqrt3()
+                 * __numeric_constants<_Tp>::__pi());
+          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
+                      + _Tp(2) * __I_nu
+                      / __numeric_constants<_Tp>::__sqrt3());
+        }
+      else if (__x < _Tp(0))
+        {
+          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
+
+          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Ai = __rootx * (__J_nu
+                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+          __Bi = -__rootx * (__N_nu
+                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+
+          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
+                          + __J_nu) / _Tp(2);
+          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
+                          - __N_nu) / _Tp(2);
+        }
+      else
+        {
+          //  Reference:
+          //    Abramowitz & Stegun, page 446 section 10.4.4 on Airy functions.
+          //  The number is Ai(0) = 3^{-2/3}/\Gamma(2/3).
+          __Ai = _Tp(0.35502805388781723926L);
+          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
+
+          //  Reference:
+          //    Abramowitz & Stegun, page 446 section 10.4.5 on Airy functions.
+          //  The number is Ai'(0) = -3^{-1/3}/\Gamma(1/3).
+          __Aip = -_Tp(0.25881940379280679840L);
+          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
+        }
+
+      return;
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/poly_hermite.tcc

@@ -0,0 +1,129 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/poly_hermite.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications, Section 22 pp. 773-802
+
+#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
+#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+    /**
+     *   @brief This routine returns the Hermite polynomial
+     *          of order n: \f$ H_n(x) \f$ by recursion on n.
+     * 
+     *   The Hermite polynomial is defined by:
+     *   @f[
+     *     H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
+     *   @f]
+     *
+     *   @param __n The order of the Hermite polynomial.
+     *   @param __x The argument of the Hermite polynomial.
+     *   @return The value of the Hermite polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    _Tp
+    __poly_hermite_recursion(const unsigned int __n, const _Tp __x)
+    {
+      //  Compute H_0.
+      _Tp __H_0 = 1;
+      if (__n == 0)
+        return __H_0;
+
+      //  Compute H_1.
+      _Tp __H_1 = 2 * __x;
+      if (__n == 1)
+        return __H_1;
+
+      //  Compute H_n.
+      _Tp __H_n, __H_nm1, __H_nm2;
+      unsigned int __i;
+      for  (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
+        {
+          __H_n = 2 * (__x * __H_nm1 + (__i - 1) * __H_nm2);
+          __H_nm2 = __H_nm1;
+          __H_nm1 = __H_n;
+        }
+
+      return __H_n;
+    }
+
+
+    /**
+     *   @brief This routine returns the Hermite polynomial
+     *          of order n: \f$ H_n(x) \f$.
+     * 
+     *   The Hermite polynomial is defined by:
+     *   @f[
+     *     H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
+     *   @f]
+     *
+     *   @param __n The order of the Hermite polynomial.
+     *   @param __x The argument of the Hermite polynomial.
+     *   @return The value of the Hermite polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __poly_hermite(const unsigned int __n, const _Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __poly_hermite_recursion(__n, __x);
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/poly_laguerre.tcc

@@ -0,0 +1,334 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/poly_laguerre.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications,
+//       Section 13, pp. 509-510, Section 22 pp. 773-802
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+
+#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
+#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial 
+     *          of order @f$ n @f$, degree @f$ \alpha @f$ for large n.
+     *   Abramowitz & Stegun, 13.5.21
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     *
+     *  This is from the GNU Scientific Library.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_large_n(const unsigned __n, const _Tpa __alpha1,
+                            const _Tp __x)
+    {
+      const _Tp __a = -_Tp(__n);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
+      const _Tp __cos2th = __x / __eta;
+      const _Tp __sin2th = _Tp(1) - __cos2th;
+      const _Tp __th = std::acos(std::sqrt(__cos2th));
+      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
+                        * __numeric_constants<_Tp>::__pi_2()
+                        * __eta * __eta * __cos2th * __sin2th;
+
+#if _GLIBCXX_USE_C99_MATH_TR1
+      const _Tp __lg_b = std::tr1::lgamma(_Tp(__n) + __b);
+      const _Tp __lnfact = std::tr1::lgamma(_Tp(__n + 1));
+#else
+      const _Tp __lg_b = __log_gamma(_Tp(__n) + __b);
+      const _Tp __lnfact = __log_gamma(_Tp(__n + 1));
+#endif
+
+      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
+                      * std::log(_Tp(0.25L) * __x * __eta);
+      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
+      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
+                      + __pre_term1 - __pre_term2;
+      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
+      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
+                              * (_Tp(2) * __th
+                               - std::sin(_Tp(2) * __th))
+                               + __numeric_constants<_Tp>::__pi_4());
+      _Tp __ser = __ser_term1 + __ser_term2;
+
+      return std::exp(__lnpre) * __ser;
+    }
+
+
+    /**
+     *  @brief  Evaluate the polynomial based on the confluent hypergeometric
+     *          function in a safe way, with no restriction on the arguments.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *  This function assumes x != 0.
+     *
+     *  This is from the GNU Scientific Library.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_hyperg(const unsigned int __n, const _Tpa __alpha1,
+			   const _Tp __x)
+    {
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __mx = -__x;
+      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
+                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
+      //  Get |x|^n/n!
+      _Tp __tc = _Tp(1);
+      const _Tp __ax = std::abs(__x);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __tc *= (__ax / __k);
+
+      _Tp __term = __tc * __tc_sgn;
+      _Tp __sum = __term;
+      for (int __k = int(__n) - 1; __k >= 0; --__k)
+        {
+          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
+                  * _Tp(__k + 1) / __mx;
+          __sum += __term;
+        }
+
+      return __sum;
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial 
+     *          of order @f$ n @f$, degree @f$ \alpha @f$: @f$ L_n^\alpha(x) @f$
+     *          by recursion.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     */
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_recursion(const unsigned int __n,
+                              const _Tpa __alpha1, const _Tp __x)
+    {
+      //   Compute l_0.
+      _Tp __l_0 = _Tp(1);
+      if  (__n == 0)
+        return __l_0;
+
+      //  Compute l_1^alpha.
+      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
+      if  (__n == 1)
+        return __l_1;
+
+      //  Compute l_n^alpha by recursion on n.
+      _Tp __l_n2 = __l_0;
+      _Tp __l_n1 = __l_1;
+      _Tp __l_n = _Tp(0);
+      for  (unsigned int __nn = 2; __nn <= __n; ++__nn)
+        {
+            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
+                  * __l_n1 / _Tp(__nn)
+                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
+            __l_n2 = __l_n1;
+            __l_n1 = __l_n;
+        }
+
+      return __l_n;
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial
+     *          of order n, degree @f$ \alpha @f$: @f$ L_n^alpha(x) @f$.
+     *
+     *   The associated Laguerre function is defined by
+     *   @f[
+     *       L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
+     *                       _1F_1(-n; \alpha + 1; x)
+     *   @f]
+     *   where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
+     *   @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre function.
+     *   @param __alpha The degree of the Laguerre function.
+     *   @param __x The argument of the Laguerre function.
+     *   @return The value of the Laguerre function of order n,
+     *           degree @f$ \alpha @f$, and argument x.
+     */
+    template<typename _Tpa, typename _Tp>
+    inline _Tp
+    __poly_laguerre(const unsigned int __n, const _Tpa __alpha1,
+                    const _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(__N("Negative argument "
+                                      "in __poly_laguerre."));
+      //  Return NaN on NaN input.
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n == 0)
+        return _Tp(1);
+      else if (__n == 1)
+        return _Tp(1) + _Tp(__alpha1) - __x;
+      else if (__x == _Tp(0))
+        {
+          _Tp __prod = _Tp(__alpha1) + _Tp(1);
+          for (unsigned int __k = 2; __k <= __n; ++__k)
+            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
+          return __prod;
+        }
+      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
+            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
+        return __poly_laguerre_large_n(__n, __alpha1, __x);
+      else if (_Tp(__alpha1) >= _Tp(0)
+           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
+        return __poly_laguerre_recursion(__n, __alpha1, __x);
+      else
+        return __poly_laguerre_hyperg(__n, __alpha1, __x);
+    }
+
+
+    /**
+     *   @brief This routine returns the associated Laguerre polynomial
+     *          of order n, degree m: @f$ L_n^m(x) @f$.
+     *
+     *   The associated Laguerre polynomial is defined for integral
+     *   @f$ \alpha = m @f$ by:
+     *   @f[
+     *       L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
+     *   @f]
+     *   where the Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre polynomial.
+     *   @param __m The degree of the Laguerre polynomial.
+     *   @param __x The argument of the Laguerre polynomial.
+     *   @return The value of the associated Laguerre polynomial of order n,
+     *           degree m, and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __assoc_laguerre(const unsigned int __n, const unsigned int __m,
+                     const _Tp __x)
+    {
+      return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x);
+    }
+
+
+    /**
+     *   @brief This routine returns the Laguerre polynomial
+     *          of order n: @f$ L_n(x) @f$.
+     *
+     *   The Laguerre polynomial is defined by:
+     *   @f[
+     *       L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
+     *   @f]
+     *
+     *   @param __n The order of the Laguerre polynomial.
+     *   @param __x The argument of the Laguerre polynomial.
+     *   @return The value of the Laguerre polynomial of order n
+     *           and argument x.
+     */
+    template<typename _Tp>
+    inline _Tp
+    __laguerre(const unsigned int __n, const _Tp __x)
+    {
+      return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x);
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/random

@@ -0,0 +1,71 @@
+// random number generation -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1/random
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_RANDOM
+#define _GLIBCXX_TR1_RANDOM 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <iosfwd>
+#include <limits>
+#include <ext/type_traits.h>
+#include <ext/numeric_traits.h>
+#include <bits/concept_check.h>
+#include <debug/debug.h>
+#include <tr1/type_traits>
+#include <tr1/cmath>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/random>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/random>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_RANDOM

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/regex

@@ -0,0 +1,68 @@
+// class template regex -*- C++ -*-
+
+// Copyright (C) 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/**
+ * @file tr1/regex
+ * @author Stephen M. Webb  <stephen.webb@bregmasoft.ca>
+ * This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_REGEX
+#define _GLIBCXX_TR1_REGEX 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <algorithm>
+#include <bitset>
+#include <iterator>
+#include <locale>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <utility>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/regex>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/regex>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_REGEX

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/riemann_zeta.tcc

@@ -0,0 +1,440 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006, 2007, 2008
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/riemann_zeta.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on:
+//   (1) Handbook of Mathematical Functions,
+//       Ed. by Milton Abramowitz and Irene A. Stegun,
+//       Dover Publications, New-York, Section 5, pp. 807-808.
+//   (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl
+//   (3) Gamma, Exploring Euler's Constant, Julian Havil,
+//       Princeton, 2003.
+
+#ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC
+#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
+
+#include "special_function_util.h"
+
+namespace std
+{
+namespace tr1
+{
+
+  // [5.2] Special functions
+
+  // Implementation-space details.
+  namespace __detail
+  {
+
+    /**
+     *   @brief  Compute the Riemann zeta function @f$ \zeta(s) @f$
+     *           by summation for s > 1.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_sum(const _Tp __s)
+    {
+      //  A user shouldn't get to this.
+      if (__s < _Tp(1))
+        std::__throw_domain_error(__N("Bad argument in zeta sum."));
+
+      const unsigned int max_iter = 10000;
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __k = 1; __k < max_iter; ++__k)
+        {
+          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            {
+              break;
+            }
+          __zeta += __term;
+        }
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Evaluate the Riemann zeta function @f$ \zeta(s) @f$
+     *           by an alternate series for s > 0.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_alt(const _Tp __s)
+    {
+      _Tp __sgn = _Tp(1);
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __i = 1; __i < 10000000; ++__i)
+        {
+          _Tp __term = __sgn / std::pow(__i, __s);
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __zeta += __term;
+          __sgn *= _Tp(-1);
+        }
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Evaluate the Riemann zeta function by series for all s != 1.
+     *           Convergence is great until largish negative numbers.
+     *           Then the convergence of the > 0 sum gets better.
+     *
+     *   The series is:
+     *    \f[
+     *      \zeta(s) = \frac{1}{1-2^{1-s}}
+     *                 \sum_{n=0}^{\infty} \frac{1}{2^{n+1}}
+     *                 \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (k+1)^{-s}
+     *    \f]
+     *   Havil 2003, p. 206.
+     *
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_glob(const _Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      //  Max e exponent before overflow.
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+      //  This series works until the binomial coefficient blows up
+      //  so use reflection.
+      if (__s < _Tp(0))
+        {
+#if _GLIBCXX_USE_C99_MATH_TR1
+          if (std::tr1::fmod(__s,_Tp(2)) == _Tp(0))
+            return _Tp(0);
+          else
+#endif
+            {
+              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
+              __zeta *= std::pow(_Tp(2)
+                     * __numeric_constants<_Tp>::__pi(), __s)
+                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                     * std::exp(std::tr1::lgamma(_Tp(1) - __s))
+#else
+                     * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                     / __numeric_constants<_Tp>::__pi();
+              return __zeta;
+            }
+        }
+
+      _Tp __num = _Tp(0.5L);
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+#if _GLIBCXX_USE_C99_MATH_TR1
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
+#else
+              _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
+                              - __log_gamma(_Tp(1 + __j))
+                              - __log_gamma(_Tp(1 + __i - __j));
+#endif
+              if (__bincoeff > __max_bincoeff)
+                {
+                  //  This only gets hit for x << 0.
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term *= __num;
+          __zeta += __term;
+          if (std::abs(__term/__zeta) < __eps)
+            break;
+          __num *= _Tp(0.5L);
+        }
+
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Compute the Riemann zeta function @f$ \zeta(s) @f$
+     *           using the product over prime factors.
+     *    \f[
+     *      \zeta(s) = \Pi_{i=1}^\infty \frac{1}{1 - p_i^{-s}}
+     *    \f]
+     *    where @f$ {p_i} @f$ are the prime numbers.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_product(const _Tp __s)
+    {
+      static const _Tp __prime[] = {
+        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
+        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
+        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
+        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
+      };
+      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
+
+      _Tp __zeta = _Tp(1);
+      for (unsigned int __i = 0; __i < __num_primes; ++__i)
+        {
+          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
+          __zeta *= __fact;
+          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+
+      __zeta = _Tp(1) / __zeta;
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Return the Riemann zeta function @f$ \zeta(s) @f$.
+     * 
+     *   The Riemann zeta function is defined by:
+     *    \f[
+     *      \zeta(s) = \sum_{k=1}^{\infty} k^{-s} for s > 1
+     *                 \frac{(2\pi)^s}{pi} sin(\frac{\pi s}{2})
+     *                 \Gamma (1 - s) \zeta (1 - s) for s < 1
+     *    \f]
+     *   For s < 1 use the reflection formula:
+     *    \f[
+     *      \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s)
+     *    \f]
+     */
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta(const _Tp __s)
+    {
+      if (__isnan(__s))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__s == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__s < -_Tp(19))
+        {
+          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
+          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
+                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                 * std::exp(std::tr1::lgamma(_Tp(1) - __s))
+#else
+                 * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                 / __numeric_constants<_Tp>::__pi();
+          return __zeta;
+        }
+      else if (__s < _Tp(20))
+        {
+          //  Global double sum or McLaurin?
+          bool __glob = true;
+          if (__glob)
+            return __riemann_zeta_glob(__s);
+          else
+            {
+              if (__s > _Tp(1))
+                return __riemann_zeta_sum(__s);
+              else
+                {
+                  _Tp __zeta = std::pow(_Tp(2)
+                                * __numeric_constants<_Tp>::__pi(), __s)
+                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+#if _GLIBCXX_USE_C99_MATH_TR1
+                             * std::tr1::tgamma(_Tp(1) - __s)
+#else
+                             * std::exp(__log_gamma(_Tp(1) - __s))
+#endif
+                             * __riemann_zeta_sum(_Tp(1) - __s);
+                  return __zeta;
+                }
+            }
+        }
+      else
+        return __riemann_zeta_product(__s);
+    }
+
+
+    /**
+     *   @brief  Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
+     *           for all s != 1 and x > -1.
+     * 
+     *   The Hurwitz zeta function is defined by:
+     *   @f[
+     *     \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
+     *   @f]
+     *   The Riemann zeta function is a special case:
+     *   @f[
+     *     \zeta(s) = \zeta(1,s)
+     *   @f]
+     * 
+     *   This functions uses the double sum that converges for s != 1
+     *   and x > -1:
+     *   @f[
+     *     \zeta(x,s) = \frac{1}{s-1}
+     *                \sum_{n=0}^{\infty} \frac{1}{n + 1}
+     *                \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (x+k)^{-s}
+     *   @f]
+     */
+    template<typename _Tp>
+    _Tp
+    __hurwitz_zeta_glob(const _Tp __a, const _Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      //  Max e exponent before overflow.
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+#if _GLIBCXX_USE_C99_MATH_TR1
+              _Tp __bincoeff =  std::tr1::lgamma(_Tp(1 + __i))
+                              - std::tr1::lgamma(_Tp(1 + __j))
+                              - std::tr1::lgamma(_Tp(1 + __i - __j));
+#else
+              _Tp __bincoeff =  __log_gamma(_Tp(1 + __i))
+                              - __log_gamma(_Tp(1 + __j))
+                              - __log_gamma(_Tp(1 + __i - __j));
+#endif
+              if (__bincoeff > __max_bincoeff)
+                {
+                  //  This only gets hit for x << 0.
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term /= _Tp(__i + 1);
+          if (std::abs(__term / __zeta) < __eps)
+            break;
+          __zeta += __term;
+        }
+
+      __zeta /= __s - _Tp(1);
+
+      return __zeta;
+    }
+
+
+    /**
+     *   @brief  Return the Hurwitz zeta function @f$ \zeta(x,s) @f$
+     *           for all s != 1 and x > -1.
+     * 
+     *   The Hurwitz zeta function is defined by:
+     *   @f[
+     *     \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s}
+     *   @f]
+     *   The Riemann zeta function is a special case:
+     *   @f[
+     *     \zeta(s) = \zeta(1,s)
+     *   @f]
+     */
+    template<typename _Tp>
+    inline _Tp
+    __hurwitz_zeta(const _Tp __a, const _Tp __s)
+    {
+      return __hurwitz_zeta_glob(__a, __s);
+    }
+
+  } // namespace std::tr1::__detail
+}
+}
+
+#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/special_function_util.h

@@ -0,0 +1,149 @@
+// Special functions -*- C++ -*-
+
+// Copyright (C) 2006
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/special_function_util.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
+//
+// ISO C++ 14882 TR1: 5.2  Special functions
+//
+
+// Written by Edward Smith-Rowland based on numerous mathematics books.
+
+#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
+
+namespace std
+{
+namespace tr1
+{
+
+  namespace __detail
+  {
+
+    /// A class to encapsulate type dependent floating point
+    /// constants.  Not everything will be able to be expressed as
+    /// type logic.
+    template<typename _Tp>
+    struct __floating_point_constant
+    {
+      static const _Tp __value;
+    };
+
+
+    /// A structure for numeric constants.
+    template<typename _Tp>
+      struct __numeric_constants
+      {
+        ///  Constant @f$ \pi @f$.
+        static _Tp __pi() throw()
+        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
+        ///  Constant @f$ \pi / 2 @f$.
+        static _Tp __pi_2() throw()
+        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
+        ///  Constant @f$ \pi / 3 @f$.
+        static _Tp __pi_3() throw()
+        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
+        ///  Constant @f$ \pi / 4 @f$.
+        static _Tp __pi_4() throw()
+        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
+        ///  Constant @f$ 1 / \pi @f$.
+        static _Tp __1_pi() throw()
+        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
+        ///  Constant @f$ 2 / \sqrt(\pi) @f$.
+        static _Tp __2_sqrtpi() throw()
+        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
+        ///  Constant @f$ \sqrt(2) @f$.
+        static _Tp __sqrt2() throw()
+        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
+        ///  Constant @f$ \sqrt(3) @f$.
+        static _Tp __sqrt3() throw()
+        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
+        ///  Constant @f$ \sqrt(\pi/2) @f$.
+        static _Tp __sqrtpio2() throw()
+        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
+        ///  Constant @f$ 1 / sqrt(2) @f$.
+        static _Tp __sqrt1_2() throw()
+        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
+        ///  Constant @f$ \log(\pi) @f$.
+        static _Tp __lnpi() throw()
+        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
+        ///  Constant Euler's constant @f$ \gamma_E @f$.
+        static _Tp __gamma_e() throw()
+        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
+        ///  Constant Euler-Mascheroni @f$ e @f$
+        static _Tp __euler() throw()
+        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
+      };
+
+
+#if _GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+
+    /// This is a wrapper for the isnan function. Otherwise, for NaN,
+    /// all comparisons result in false. If/when we build a std::isnan
+    /// out of intrinsics, this will disappear completely in favor of
+    /// std::isnan.
+    template<typename _Tp>
+    inline bool __isnan(const _Tp __x)
+    {
+      return std::isnan(__x);
+    }
+
+#else
+
+    template<typename _Tp>
+    inline bool __isnan(const _Tp __x)
+    {
+      return __builtin_isnan(__x);
+    }
+
+    template<>
+    inline bool __isnan<float>(const float __x)
+    {
+      return __builtin_isnanf(__x);
+    }
+
+    template<>
+    inline bool __isnan<long double>(const long double __x)
+    {
+      return __builtin_isnanl(__x);
+    }
+
+#endif
+
+  } // namespace __detail
+
+}
+}
+
+#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/stdarg.h

@@ -0,0 +1,39 @@
+// TR1 stdarg.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/stdarg.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDARG_H
+#define _TR1_STDARG_H 1
+
+#include <tr1/cstdarg>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/stdbool.h

@@ -0,0 +1,39 @@
+// TR1 stdbool.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/stdbool.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDBOOL_H
+#define _TR1_STDBOOL_H 1
+
+#include <tr1/cstdbool>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/stdint.h

@@ -0,0 +1,39 @@
+// TR1 stdint.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/stdint.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDINT_H
+#define _TR1_STDINT_H 1
+
+#include <tr1/cstdint>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/stdio.h

@@ -0,0 +1,39 @@
+// TR1 stdio.h -*- C++ -*-
+
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/stdio.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _TR1_STDIO_H
+#define _TR1_STDIO_H 1
+
+#include <tr1/cstdio>
+
+#endif

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/stdlib.h

@@ -0,0 +1,57 @@
+// TR1 stdlib.h -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/stdlib.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_STDLIB_H
+#define _GLIBCXX_TR1_STDLIB_H 1
+
+#include <tr1/cstdlib>
+
+#if _GLIBCXX_HOSTED
+
+#if _GLIBCXX_USE_C99
+
+using std::tr1::atoll;
+using std::tr1::strtoll;
+using std::tr1::strtoull;
+
+using std::tr1::abs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
+using std::tr1::div;
+#endif
+
+#endif
+
+#endif
+
+#endif // _GLIBCXX_TR1_STDLIB_H
+

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/tgmath.h

@@ -0,0 +1,39 @@
+// TR1 tgmath.h -*- C++ -*-
+
+// Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/tgmath.h
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_TGMATH_H
+#define _GLIBCXX_TR1_TGMATH_H 1
+
+#include <tr1/ctgmath>
+
+#endif // _GLIBCXX_TR1_TGMATH_H

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/tuple

@@ -0,0 +1,427 @@
+// class template tuple -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/tuple
+*  This is a TR1 C++ Library header.
+*/
+
+// Chris Jefferson <chris@bubblescope.net>
+// Variadic Templates support by Douglas Gregor <doug.gregor@gmail.com>
+
+#ifndef _GLIBCXX_TR1_TUPLE
+#define _GLIBCXX_TR1_TUPLE 1
+
+#pragma GCC system_header
+
+#include <utility>
+
+namespace std
+{
+namespace tr1
+{
+  // Adds a const reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_c_ref
+    { typedef const _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_c_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  // Adds a reference to a non-reference type.
+  template<typename _Tp>
+    struct __add_ref
+    { typedef _Tp& type; };
+
+  template<typename _Tp>
+    struct __add_ref<_Tp&>
+    { typedef _Tp& type; };
+
+  /**
+   * Contains the actual implementation of the @c tuple template, stored
+   * as a recursive inheritance hierarchy from the first element (most
+   * derived class) to the last (least derived class). The @c Idx
+   * parameter gives the 0-based index of the element stored at this
+   * point in the hierarchy; we use it to implement a constant-time
+   * get() operation.
+   */
+  template<int _Idx, typename... _Elements>
+    struct _Tuple_impl; 
+
+  /**
+   * Zero-element tuple implementation. This is the basis case for the 
+   * inheritance recursion.
+   */
+  template<int _Idx>
+    struct _Tuple_impl<_Idx> { };
+
+  /**
+   * Recursive tuple implementation. Here we store the @c Head element
+   * and derive from a @c Tuple_impl containing the remaining elements
+   * (which contains the @c Tail).
+   */
+  template<int _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>
+    {
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      
+      _Head _M_head;
+      
+      _Inherited&       _M_tail()       { return *this; }
+      const _Inherited& _M_tail() const { return *this; }
+      
+      _Tuple_impl() : _Inherited(), _M_head() { }
+      
+      explicit 
+      _Tuple_impl(typename __add_c_ref<_Head>::type __head,
+		  typename __add_c_ref<_Tail>::type... __tail)
+      : _Inherited(__tail...), _M_head(__head) { }
+
+      template<typename... _UElements>
+      _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+
+      _Tuple_impl(const _Tuple_impl& __in)
+      : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+     
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+	  _M_head = __in._M_head;
+	  _M_tail() = __in._M_tail();
+	  return *this;
+	}
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+	_M_head = __in._M_head;
+	_M_tail() = __in._M_tail();
+	return *this;
+      }
+    };
+
+  template<typename... _Elements> 
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_Elements>::type... __elements)
+      : _Inherited(__elements...) { }
+
+      template<typename... _UElements>
+        tuple(const tuple<_UElements...>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename... _UElements>
+        tuple&
+        operator=(const tuple<_UElements...>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+    };
+
+  template<> class tuple<> { };
+
+  // 2-element tuple, with construction and assignment from a pair.
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+    public:
+      tuple() : _Inherited() { }
+
+      explicit
+      tuple(typename __add_c_ref<_T1>::type __a1,
+	    typename __add_c_ref<_T2>::type __a2)
+      : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const tuple<_U1, _U2>& __in)
+	: _Inherited(__in) { }
+
+      tuple(const tuple& __in)
+      : _Inherited(__in) { }
+
+      template<typename _U1, typename _U2>
+        tuple(const pair<_U1, _U2>& __in)
+	: _Inherited(_Tuple_impl<0, 
+		     typename __add_c_ref<_U1>::type,
+		     typename __add_c_ref<_U2>::type>(__in.first, 
+						      __in.second))
+        { }
+  
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+	  static_cast<_Inherited&>(*this) = __in;
+	  return *this;
+	}
+
+      tuple&
+      operator=(const tuple& __in)
+      {
+	static_cast<_Inherited&>(*this) = __in;
+	return *this;
+      }
+
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+	  this->_M_head = __in.first;
+	  this->_M_tail()._M_head = __in.second;
+	  return *this;
+	}
+    };
+
+  
+  /// Gives the type of the ith element of a given tuple type.
+  template<int __i, typename _Tp>
+    struct tuple_element;
+
+  /**
+   * Recursive case for tuple_element: strip off the first element in
+   * the tuple and retrieve the (i-1)th element of the remaining tuple.
+   */
+  template<int __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+  /**
+   * Basis case for tuple_element: The first element is the one we're seeking.
+   */
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+  /// Finds the size of a given tuple type.
+  template<typename _Tp>
+    struct tuple_size;
+
+  /// class tuple_size
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...> >
+    {
+      static const int value = sizeof...(_Elements);
+    };
+
+  template<typename... _Elements>
+    const int tuple_size<tuple<_Elements...> >::value;
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_ref<_Head>::type
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  template<int __i, typename _Head, typename... _Tail>
+    inline typename __add_c_ref<_Head>::type
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
+    {
+      return __t._M_head;
+    }
+
+  // Return a reference (const reference) to the ith element of a tuple.
+  // Any const or non-const ref elements are returned with their original type.
+  template<int __i, typename... _Elements>
+    inline typename __add_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(tuple<_Elements...>& __t)
+    { 
+      return __get_helper<__i>(__t); 
+    }
+
+  template<int __i, typename... _Elements>
+    inline typename __add_c_ref<
+                      typename tuple_element<__i, tuple<_Elements...> >::type
+                    >::type
+    get(const tuple<_Elements...>& __t)
+    {
+      return __get_helper<__i>(__t);
+    }
+
+  // This class helps construct the various comparison operations on tuples
+  template<int __check_equal_size, int __i, int __j,
+	   typename _Tp, typename _Up>
+    struct __tuple_compare;
+
+  template<int __i, int __j, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __j, _Tp, _Up>
+    {
+      static bool __eq(const _Tp& __t, const _Up& __u)
+      {
+	return (get<__i>(__t) == get<__i>(__u) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u));
+      }
+     
+      static bool __less(const _Tp& __t, const _Up& __u)
+      {
+	return ((get<__i>(__t) < get<__i>(__u))
+		|| !(get<__i>(__u) < get<__i>(__t)) &&
+		__tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u));
+      }
+    };
+
+  template<int __i, typename _Tp, typename _Up>
+    struct __tuple_compare<0, __i, __i, _Tp, _Up>
+    {
+      static bool __eq(const _Tp&, const _Up&)
+      { return true; }
+     
+      static bool __less(const _Tp&, const _Up&)
+      { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator==(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    bool
+    operator<(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    {
+      typedef tuple<_TElements...> _Tp;
+      typedef tuple<_UElements...> _Up;
+      return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
+	      0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator!=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator>(const tuple<_TElements...>& __t,
+	      const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator<=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    inline bool
+    operator>=(const tuple<_TElements...>& __t,
+	       const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+  // Helper which adds a reference to a type when given a reference_wrapper
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename... _Elements>
+    inline tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+    make_tuple(_Elements... __args)
+    {
+      typedef tuple<typename __strip_reference_wrapper<_Elements>::__type...>
+        __result_type;
+      return __result_type(__args...);
+    }
+
+  template<typename... _Elements>
+    inline tuple<_Elements&...>
+    tie(_Elements&... __args)
+    {
+      return tuple<_Elements&...>(__args...);
+    }
+
+  // A class (and instance) which can be used in 'tie' when an element
+  // of a tuple is not required
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      _Swallow_assign&
+      operator=(const _Tp&)
+      { return *this; }
+  };
+
+  // TODO: Put this in some kind of shared file.
+  namespace
+  {
+    _Swallow_assign ignore;
+  }; // anonymous namespace
+}
+}
+
+#endif // _GLIBCXX_TR1_TUPLE

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/type_traits

@@ -0,0 +1,249 @@
+// TR1 type_traits -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/type_traits
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_TYPE_TRAITS
+#define _GLIBCXX_TR1_TYPE_TRAITS 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <cstddef>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/type_traits>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/type_traits>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+namespace std
+{
+namespace tr1
+{
+#define _DEFINE_SPEC_HELPER(_Spec)                 \
+  template<>                                       \
+    struct _Spec                                   \
+    : public true_type { };
+
+#define _DEFINE_SPEC(_Trait, _Type)                \
+  _DEFINE_SPEC_HELPER(_Trait<_Type>)               \
+  _DEFINE_SPEC_HELPER(_Trait<_Type const>)         \
+  _DEFINE_SPEC_HELPER(_Trait<_Type volatile>)      \
+  _DEFINE_SPEC_HELPER(_Trait<_Type const volatile>)
+
+  template<typename>
+    struct is_reference
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_reference<_Tp&>
+    : public true_type { };
+
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp) || is_void<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_constructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_copy
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_assign
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_trivial_destructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_constructor
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_copy
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename _Tp>
+    struct has_nothrow_assign
+    : public integral_constant<bool, is_pod<_Tp>::value>
+    { };
+
+  template<typename>
+    struct is_signed
+    : public false_type { };
+  _DEFINE_SPEC(is_signed, signed char)
+  _DEFINE_SPEC(is_signed, short)
+  _DEFINE_SPEC(is_signed, int)
+  _DEFINE_SPEC(is_signed, long)
+  _DEFINE_SPEC(is_signed, long long)
+
+  template<typename>
+    struct is_unsigned
+    : public false_type { };
+  _DEFINE_SPEC(is_unsigned, unsigned char)
+  _DEFINE_SPEC(is_unsigned, unsigned short)
+  _DEFINE_SPEC(is_unsigned, unsigned int)
+  _DEFINE_SPEC(is_unsigned, unsigned long)
+  _DEFINE_SPEC(is_unsigned, unsigned long long)
+
+  template<typename _Base, typename _Derived>
+    struct __is_base_of_helper
+    {
+      typedef typename remove_cv<_Base>::type    _NoCv_Base;
+      typedef typename remove_cv<_Derived>::type _NoCv_Derived;
+      static const bool __value = (is_same<_Base, _Derived>::value
+				   || (__is_base_of(_Base, _Derived)
+				       && !is_same<_NoCv_Base,
+				                   _NoCv_Derived>::value));
+    };
+ 
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool,
+			       __is_base_of_helper<_Base, _Derived>::__value>
+    { };
+
+  template<typename _From, typename _To>
+    struct __is_convertible_simple
+    : public __sfinae_types
+    {
+    private:
+      static __one __test(_To);
+      static __two __test(...);
+      static _From __makeFrom();
+    
+    public:
+      static const bool __value = sizeof(__test(__makeFrom())) == 1;
+    };
+
+  template<typename _Tp>
+    struct add_reference;
+
+  template<typename _Tp>
+    struct __is_int_or_cref
+    {
+      typedef typename remove_reference<_Tp>::type __rr_Tp;
+      static const bool __value = (is_integral<_Tp>::value
+				   || (is_integral<__rr_Tp>::value
+				       && is_const<__rr_Tp>::value
+				       && !is_volatile<__rr_Tp>::value));
+    };
+
+  template<typename _From, typename _To,
+	   bool = (is_void<_From>::value || is_void<_To>::value
+		   || is_function<_To>::value || is_array<_To>::value
+		   // This special case is here only to avoid warnings.	
+		   || (is_floating_point<typename
+		       remove_reference<_From>::type>::value
+		       && __is_int_or_cref<_To>::__value))>
+    struct __is_convertible_helper
+    {
+      // "An imaginary lvalue of type From...".
+      static const bool __value = (__is_convertible_simple<typename
+				   add_reference<_From>::type, _To>::__value);
+    };
+
+  template<typename _From, typename _To>
+    struct __is_convertible_helper<_From, _To, true>
+    { static const bool __value = (is_void<_To>::value
+				   || (__is_int_or_cref<_To>::__value
+				       && !is_void<_From>::value)); };
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public integral_constant<bool,
+			       __is_convertible_helper<_From, _To>::__value>
+    { };
+
+  // reference modifications [4.7.2].
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp     type; };
+
+  // NB: Careful with reference to void.
+  template<typename _Tp, bool = (is_void<_Tp>::value
+				 || is_reference<_Tp>::value)>
+    struct __add_reference_helper
+    { typedef _Tp&    type; };
+
+  template<typename _Tp>
+    struct __add_reference_helper<_Tp, true>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct add_reference
+    : public __add_reference_helper<_Tp>
+    { };
+
+  // other transformations [4.8].
+  template<std::size_t _Len, std::size_t _Align>
+    struct aligned_storage
+    { 
+      union type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__((_Align)))) { } __align; 
+      };
+    };
+
+#undef _DEFINE_SPEC_HELPER
+#undef _DEFINE_SPEC
+}
+}
+
+#endif // _GLIBCXX_TR1_TYPE_TRAITS

mingw/lib/gcc/mingw32/4.3.3/include/c++/tr1/unordered_map

@@ -0,0 +1,66 @@
+// TR1 unordered_map -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/** @file tr1/unordered_map
+ *  This is a TR1 C++ Library header. 
+ */
+
+#ifndef _GLIBCXX_TR1_UNORDERED_MAP
+#define _GLIBCXX_TR1_UNORDERED_MAP 1
+
+#pragma GCC system_header
+
+#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
+#  error TR1 header cannot be included from C++0x header
+#endif
+
+#include <utility>
+#include <bits/stl_algobase.h>
+#include <bits/allocator.h>
+#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
+#include <bits/stringfwd.h>
+#include <tr1/type_traits>
+#include <tr1/functional_hash.h>
+#include <tr1/hashtable.h>
+
+#if defined(_GLIBCXX_INCLUDE_AS_TR1)
+#  include <tr1_impl/unordered_map>
+#else
+#  define _GLIBCXX_INCLUDE_AS_TR1
+#  define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
+#  define _GLIBCXX_END_NAMESPACE_TR1 }
+#  define _GLIBCXX_TR1 tr1::
+#  include <tr1_impl/unordered_map>
+#  undef _GLIBCXX_TR1
+#  undef _GLIBCXX_END_NAMESPACE_TR1
+#  undef _GLIBCXX_BEGIN_NAMESPACE_TR1
+#  undef _GLIBCXX_INCLUDE_AS_TR1
+#endif
+
+#endif // _GLIBCXX_TR1_UNORDERED_MAP