namespace boost {
  typedef unspecified char16;
  typedef unspecified char32;
}

namespace boost {
  namespace unicode {
    template<typename Range1, typename Range2> 
      tuple< sub_range< Range1 >, sub_range< Range1 >, sub_range< Range2 >, sub_range< Range2 > > 
      cat_limits(Range1 &&, Range2 &&);
    template<typename Range1, typename Range2, typename OutputIterator, 
             typename... T> 
      OutputIterator 
      composed_concat(const Range1 &, const Range2 &, OutputIterator, 
                      const T &...);
    template<typename Range1, typename Range2, typename OutputIterator, 
             typename... T> 
      OutputIterator 
      decomposed_concat(const Range1 &, const Range2 &, OutputIterator, 
                        const T &...);
    namespace adaptors {
      template<typename Range1, typename Range2, typename... T> 
        result_of::composed_concat< Range1, Range2 >::type 
        composed_concat(Range1 &&, Range2 &&, const T &...);
      template<typename Range1, typename Range2, typename... T> 
        result_of::decomposed_concat< Range1, Range2 >::type 
        decomposed_concat(Range1 &&, Range2 &&, const T &...);
    }
  }
}

namespace boost {
  namespace unicode {
    typedef converter_codecvt< wchar_t, utf_boundary, utf_transcoder< char >, utf_combine_boundary, multi_converter< converted_converter< utf_decoder, normalizer >, utf_encoder< wchar_t > >> utf_u8_normalize_codecvt;
    typedef converter_codecvt< wchar_t, utf_boundary, utf_transcoder< char >, utf_boundary, utf_transcoder< wchar_t >> utf_u8_codecvt;
  }
}

namespace boost {
  namespace unicode {
    struct combine_boundary;
    struct combine_sorter;
    typedef mpl::int_< 31 > combining_max;
    typedef unspecified combine_segmenter;
    typedef unspecified u8_combine_boundary;
    typedef unspecified u8_combine_segmenter;
    typedef unspecified u16_combine_boundary;
    typedef unspecified u16_combine_segmenter;
    typedef unspecified utf_combine_boundary;
    typedef unspecified utf_combine_segmenter;
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator combine_sort(const Range &, OutputIterator, const T &);
    namespace adaptors {
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::combine_segmenter > 
        combine_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u8_combine_segmenter > 
        u8_combine_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u16_combine_segmenter > 
        u16_combine_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::utf_combine_segmenter > 
        utf_combine_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::combine_sorter > 
        combine_sort(Range &&, const T &);
    }
  }
}

namespace boost {
  namespace unicode {
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator compose(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator decompose(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator normalize(const Range &, OutputIterator, const T &);
    namespace adaptors {
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::composer > 
        compose(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::decomposer > 
        decompose(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::normalizer > 
        normalize(Range &&, const T &);
    }
  }
}

namespace boost {
  namespace unicode {
    namespace ucd {
      struct unichar_compose_data_entry;

      const unichar_compose_data_entry __uni_compose_entry;
      const size_t __uni_compose_entry_size;
    }
  }
}

BOOST_UNICODE_OPTION(o)

namespace boost {
  namespace unicode {
    struct decomposer;
    struct composer;
    typedef unspecified normalizer;
  }
}

namespace boost {
  namespace unicode {
    struct grapheme_boundary;

    typedef unspecified grapheme_segmenter;
    typedef unspecified u8_grapheme_boundary;
    typedef unspecified u8_grapheme_segmenter;
    typedef unspecified u16_grapheme_boundary;
    typedef unspecified u16_grapheme_segmenter;
    typedef unspecified utf_grapheme_boundary;
    typedef unspecified utf_grapheme_segmenter;
    namespace adaptors {
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::grapheme_segmenter > 
        grapheme_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u8_grapheme_segmenter > 
        u8_grapheme_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u16_grapheme_segmenter > 
        u16_grapheme_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::utf_grapheme_segmenter > 
        utf_grapheme_segment(Range &&, const T &);
    }
  }
}

namespace boost {
  namespace unicode {
    struct hangul_decomposer;
    struct hangul_composer;
  }
}

namespace boost {
  namespace algorithm {
    template<typename F, typename B> struct boundary_finder;
    template<typename F, typename B> 
      boundary_finder< F, B > make_boundary_finder(F f, B b);
  }
  namespace unicode {
    template<typename Match, typename Comp = is_equal> struct simple_finder;
    template<typename F, typename B> struct boundary_finder;
    template<typename Match, typename Comp> 
      simple_finder< Match, Comp > 
      make_simple_finder(const Match & match, Comp comp = Comp());
    template<typename Match> 
      simple_finder< Match > make_simple_finder(const Match & match);
    template<typename F, typename B> 
      boundary_finder< F, B > make_boundary_finder(F f, B b);
  }
}

namespace boost {
  namespace unicode {
    template<typename Sequence> struct static_u8_encode;
    template<typename Sequence> struct static_u16_encode;
  }
}

namespace boost {
  namespace unicode {
    template<char32 I> struct static_u8_encoder;
    template<char32 I> struct static_u16_encoder;
  }
}

namespace boost {
  namespace unicode {
    template<char32 I> struct string_cp;
  }
}

namespace boost {
  namespace unicode {
    bool is_high_surrogate(char32 v);
    bool is_low_surrogate(char32 v);
    bool is_surrogate(char32 v);
  }
}

namespace boost {
  namespace unicode {
    namespace ucd {
      struct block;
      const char * as_string(block::type);
    }
  }
}

BOOST_UNICODE_UCD_VERSION
BOOST_UNICODE_UCD_VERSION_MAJOR
BOOST_UNICODE_UCD_VERSION_MINOR

namespace boost {
  namespace unicode {
    namespace ucd {
      category::type get_category(char32 ch);
      bidi_class::type get_bidi_class(char32 ch);
      line_break::type get_line_break(char32 ch);
      grapheme_cluster_break::type get_grapheme_cluster_break(char32 ch);
      word_break::type get_word_break(char32 ch);
      sentence_break::type get_sentence_break(char32 ch);
      decomposition_type::type get_decomposition_type(char32);
      int get_combining_class(char32);
      iterator_range< const char32 * > get_decomposition(char32);
      block::type get_block(char32);
    }
  }
}

namespace boost {
  namespace unicode {
    namespace ucd {
      struct category;
      struct bidi_class;
      struct line_break;
      struct decomposition_type;
      struct grapheme_cluster_break;
      struct word_break;
      struct sentence_break;
      const char * as_string(category::type);
      const char * as_string(bidi_class::type);
      const char * as_string(line_break::type);
      const char * as_string(decomposition_type::type);
      const char * as_string(grapheme_cluster_break::type);
      const char * as_string(word_break::type);
      const char * as_string(sentence_break::type);
    }
  }
}

namespace boost {
  namespace unicode {
    typedef unspecified u8_segmenter;
    typedef unspecified u16_segmenter;
    typedef unspecified utf_segmenter;
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u8_encode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u16_encode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator latin1_encode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u8_decode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator u16_decode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator utf_decode(const Range &, OutputIterator, const T &);
    template<typename ValueType, typename Range, typename OutputIterator, 
             typename... T> 
      OutputIterator utf_encode(const Range &, OutputIterator, const T &);
    template<typename ValueType, typename Range, typename OutputIterator, 
             typename... T> 
      OutputIterator utf_transcode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator 
      locale_utf_transcode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator 
      utf_locale_transcode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator locale_decode(const Range &, OutputIterator, const T &);
    template<typename Range, typename OutputIterator, typename... T> 
      OutputIterator locale_encode(const Range &, OutputIterator, const T &);
    namespace adaptors {
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::u8_encoder > 
        u8_encode(Range &&, const T &);
      template<typename OutputIterator, typename... T> 
        boost::convert_output_iterator< OutputIterator, boost::unicode::u8_encoder > 
        u8_encode_output(OutputIterator, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::u16_encoder > 
        u16_encode(Range &&, const T &);
      template<typename OutputIterator, typename... T> 
        boost::convert_output_iterator< OutputIterator, boost::unicode::u16_encoder > 
        u16_encode_output(OutputIterator, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::latin1_encoder > 
        latin1_encode(Range &&, const T &);
      template<typename OutputIterator, typename... T> 
        boost::convert_output_iterator< OutputIterator, boost::unicode::latin1_encoder > 
        latin1_encode_output(OutputIterator, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::u8_decoder > 
        u8_decode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u8_segmenter > 
        u8_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::u16_decoder > 
        u16_decode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::u16_segmenter > 
        u16_segment(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::utf_decoder > 
        utf_decode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::segmented_range< Range, boost::unicode::utf_segmenter > 
        utf_segment(Range &&, const T &);
      template<typename ValueType, typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::utf_encoder< ValueType > > 
        utf_encode(Range &&, const T &);
      template<typename ValueType, typename OutputIterator, typename... T> 
        boost::convert_output_iterator< OutputIterator, boost::unicode::utf_encoder< ValueType > > 
        utf_encode_output(OutputIterator, const T &);
      template<typename ValueType, typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::utf_transcoder< ValueType > > 
        utf_transcode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::locale_utf_transcoder > 
        locale_utf_transcode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::utf_locale_transcoder > 
        utf_locale_transcode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::locale_decoder > 
        locale_decode(Range &&, const T &);
      template<typename Range, typename... T> 
        boost::converted_range< Range, boost::unicode::locale_encoder > 
        locale_encode(Range &&, const T &);
    }
  }
}

namespace boost {
  namespace unicode {
    struct u16_encoder;
    struct u16_decoder;
    struct u16_boundary;
    struct u8_encoder;
    struct u8_decoder;
    struct u8_boundary;
    template<typename ValueType> struct utf_encoder;
    struct utf_decoder;
    struct utf_boundary;
    template<typename ValueType> struct utf_transcoder;
    struct locale_utf_transcoder;
    struct utf_locale_transcoder;
    typedef unspecified latin1_encoder;
    typedef unspecified locale_decoder;
    typedef unspecified locale_encoder;
  }
}