namespace std {
              typedef long unsigned int size_t;
              }
              typedef unsigned char uint8_t;
               namespace std __attribute__ ((__visibility__ ("default"))) {
                 template<typename _CharT>     struct char_traits;
              template<typename>     class allocator;
                 template<typename _CharT, typename _Traits = char_traits<_CharT>,            typename _Alloc = allocator<_CharT> >     class basic_string;
               typedef basic_string<char> string;
                template<typename _Tp, typename _Alloc>     struct _Vector_base     {
            };
              template<typename _Tp, typename _Alloc = std::allocator<_Tp> >     class vector : protected _Vector_base<_Tp, _Alloc>     {
                  };
               template<typename _Tp, std::size_t _Nm>     struct __array_traits     {
              typedef _Tp _Type[_Nm];
            };
              template<typename _Tp, std::size_t _Nm>     struct array     {
                typedef std::__array_traits<_Tp, _Nm> _AT_Type;
              typename _AT_Type::_Type _M_elems;
          };
            namespace Xefis {
           }
            namespace SI {
            typedef std::vector<uint8_t> Blob;
            class Value {
         public:     virtual std::vector<std::string> const&  supported_units() const = 0;
            virtual void  parse (std::string const&) = 0;
            virtual void  parse_blob (Blob const&) = 0;
            virtual std::string  stringify() const = 0;
            virtual Blob  binarify() const = 0;
            virtual double  floatize (std::string unit) const = 0;
       };
            template<class tValueType>  class TypedValue: public Value  {
          public:   typedef tValueType ValueType;
           public:   virtual ValueType   si_units() const noexcept = 0;
             virtual void   set_si_units (ValueType) = 0;
           void   parse_blob (Blob const&) override;
           Blob   binarify() const override;
        };
                 template<class tValueType, class tDerived>  class LinearValue:   public TypedValue<tValueType>  {
        };
           class Time: public LinearValue<double, Time> {
         std::vector<std::string> const&  supported_units() const override;
         ValueType  si_units() const noexcept override;
         void  set_si_units (ValueType) override;
         void  parse (std::string const&) override;
         std::string  stringify() const override;
         double  floatize (std::string unit) const override;
       };
            inline constexpr Time operator"" _ms (unsigned long long ms) {
       }
          }
              using namespace SI;
               class __attribute__((visibility("default"))) QObject {
                };
                 namespace xf = Xefis;
              class __attribute__((visibility("default"))) QDomNode {
          };
              class __attribute__((visibility("default"))) QDomElement : public QDomNode {
          };
              namespace Xefis {
          class ModuleManager;
           class Noncopyable {
       };
           class Module: private Noncopyable {
          public:       Module (ModuleManager*, QDomElement const& config);
       };
              class SmootherBase {
          protected:     virtual void  set_smoothing_time_impl (int milliseconds) noexcept = 0;
       };
               template<class tValueType>  class Smoother: public SmootherBase  {
           public:    Smoother (Time smoothing_time = 1_ms, Time precision = 1_ms) noexcept;
           protected:   void   set_smoothing_time_impl (int milliseconds) noexcept override;
        };
               class PCA9685:  public QObject,  public xf::Module {
         static constexpr unsigned int Channels = 16;
          struct Channel  {
        Time smoothing_time = 1_ms;
        xf::Smoother<double> smoother = smoothing_time;
       };
           public:   PCA9685 (xf::ModuleManager*, QDomElement const& config);
         std::array<Channel, Channels> _channels;
        };
             PCA9685::PCA9685 (xf::ModuleManager* module_manager, QDomElement const& config):  Module (module_manager, config) {