WARNING! The OProfile kernel driver reports sample buffer overflows.
Such overflows can result in incorrect sample attribution, invalid sample
files and other symptoms.  See the oprofiled.log for details.
You should adjust your sampling frequency to eliminate (or at least minimize)
these overflows.
/* 
 * Command line: opannotate /usr/local/bin/gtk-gnash --source --threshold 2 --merge=tid 
 * 
 * Interpretation of command line:
 * Output annotated source file with samples
 * Output files where samples count reach 2% of the samples
 * 
 * CPU: P4 / Xeon, speed 2794.97 MHz (estimated)
 * Counted GLOBAL_POWER_EVENTS events (time during which processor is not stopped) with a unit mask of 0x01 (mandatory) count 100000
 */
/* 
 * Total samples for file : "/usr/include/agg2/agg_span_gradient.h"
 * 
 *  21283  8.9714
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_SPAN_GRADIENT_INCLUDED
               :#define AGG_SPAN_GRADIENT_INCLUDED
               :
               :#include <math.h>
               :#include <stdlib.h>
               :#include <string.h>
               :#include "agg_basics.h"
               :#include "agg_math.h"
               :#include "agg_array.h"
               :
               :
               :namespace agg
               :{
               :
               :    enum gradient_subpixel_scale_e
               :    {
               :        gradient_subpixel_shift = 4,                              //-----gradient_subpixel_shift
               :        gradient_subpixel_scale = 1 << gradient_subpixel_shift,   //-----gradient_subpixel_scale
               :        gradient_subpixel_mask  = gradient_subpixel_scale - 1     //-----gradient_subpixel_mask
               :    };
               :
               :
               :
               :    //==========================================================span_gradient
               :    template<class ColorT,
               :             class Interpolator,
               :             class GradientF, 
               :             class ColorF>
               :    class span_gradient
               :    {
               :    public:
               :        typedef Interpolator interpolator_type;
               :        typedef ColorT color_type;
               :
               :        enum downscale_shift_e
               :        {
               :            downscale_shift = interpolator_type::subpixel_shift - 
               :                              gradient_subpixel_shift
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_gradient() {}
               :
               :        //--------------------------------------------------------------------
               :        span_gradient(interpolator_type& inter,
               :                      const GradientF& gradient_function,
               :                      const ColorF& color_function,
               :                      double d1, double d2) : 
               :            m_interpolator(&inter),
               :            m_gradient_function(&gradient_function),
               :            m_color_function(&color_function),
               :            m_d1(iround(d1 * gradient_subpixel_scale)),
     2 8.4e-04 :            m_d2(iround(d2 * gradient_subpixel_scale))
               :        {}
               :
               :        //--------------------------------------------------------------------
               :        interpolator_type& interpolator() { return *m_interpolator; }
               :        const GradientF& gradient_function() const { return *m_gradient_function; }
               :        const ColorF& color_function() const { return *m_color_function; }
               :        double d1() const { return double(m_d1) / gradient_subpixel_scale; }
               :        double d2() const { return double(m_d2) / gradient_subpixel_scale; }
               :
               :        //--------------------------------------------------------------------
               :        void interpolator(interpolator_type& i) { m_interpolator = &i; }
               :        void gradient_function(const GradientF& gf) { m_gradient_function = &gf; }
               :        void color_function(const ColorF& cf) { m_color_function = &cf; }
               :        void d1(double v) { m_d1 = iround(v * gradient_subpixel_scale); }
               :        void d2(double v) { m_d2 = iround(v * gradient_subpixel_scale); }
               :
               :        //--------------------------------------------------------------------
               :        void prepare() {}
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {   
    34  0.0143 :            int dd = m_d2 - m_d1;
     5  0.0021 :            if(dd < 1) dd = 1;
    75  0.0316 :            m_interpolator->begin(x+0.5, y+0.5, len);
   464  0.1956 :            do
               :            {
               :                m_interpolator->coordinates(&x, &y);
               :                int d = m_gradient_function->calculate(x >> downscale_shift, 
   537  0.2264 :                                                       y >> downscale_shift, m_d2);
  1688  0.7115 :                d = ((d - m_d1) * (int)m_color_function->size()) / dd;
 16453  6.9354 :                if(d < 0) d = 0;
   514  0.2167 :                if(d >= (int)m_color_function->size()) d = m_color_function->size() - 1;
  1023  0.4312 :                *span++ = (*m_color_function)[d];
    24  0.0101 :                ++(*m_interpolator);
               :            }
               :            while(--len);
               :        }
               :
               :    private:
               :        interpolator_type* m_interpolator;
               :        const GradientF*   m_gradient_function;
               :        const ColorF*      m_color_function;
               :        int                m_d1;
               :        int                m_d2;
               :    };
               :
               :
               :
               :
               :    //=====================================================gradient_linear_color
               :    template<class ColorT> 
               :    struct gradient_linear_color
               :    {
               :        typedef ColorT color_type;
               :
               :        gradient_linear_color() {}
               :        gradient_linear_color(const color_type& c1, const color_type& c2, 
               :                              unsigned size = 256) :
               :            m_c1(c1), m_c2(c2), m_size(size) {}
               :
               :        unsigned size() const { return m_size; }
               :        color_type operator [] (unsigned v) const 
               :        {
               :            return m_c1.gradient(m_c2, double(v) / double(m_size - 1));
               :        }
               :
               :        void colors(const color_type& c1, const color_type& c2, unsigned size = 256)
               :        {
               :            m_c1 = c1;
               :            m_c2 = c2;
               :            m_size = size;
               :        }
               :
               :        color_type m_c1;
               :        color_type m_c2;
               :        unsigned m_size;
               :    };
               :
               :
               :
               :
               :
               :
               :    //==========================================================gradient_circle
               :    class gradient_circle
               :    {
               :        // Actually the same as radial. Just for compatibility
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int)
               :        {
               :            return int(fast_sqrt(x*x + y*y));
               :        }
               :    };
               :
               :
               :    //==========================================================gradient_radial
               :    class gradient_radial
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int)
               :        {
   464  0.1956 :            return int(fast_sqrt(x*x + y*y));
               :        }
               :    };
               :
               :    //========================================================gradient_radial_d
               :    class gradient_radial_d
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int)
               :        {
               :            return uround(sqrt(double(x)*double(x) + double(y)*double(y)));
               :        }
               :    };
               :
               :    //====================================================gradient_radial_focus
               :    class gradient_radial_focus
               :    {
               :    public:
               :        //---------------------------------------------------------------------
               :        gradient_radial_focus() : 
               :            m_r(100 * gradient_subpixel_scale), 
               :            m_fx(0), 
               :            m_fy(0)
               :        {
               :            update_values();
               :        }
               :
               :        //---------------------------------------------------------------------
               :        gradient_radial_focus(double r, double fx, double fy) : 
               :            m_r (iround(r  * gradient_subpixel_scale)), 
               :            m_fx(iround(fx * gradient_subpixel_scale)), 
               :            m_fy(iround(fy * gradient_subpixel_scale))
               :        {
               :            update_values();
               :        }
               :
               :        //---------------------------------------------------------------------
               :        void init(double r, double fx, double fy)
               :        {
               :            m_r  = iround(r  * gradient_subpixel_scale);
               :            m_fx = iround(fx * gradient_subpixel_scale);
               :            m_fy = iround(fy * gradient_subpixel_scale);
               :            update_values();
               :        }
               :
               :        //---------------------------------------------------------------------
               :        double radius()  const { return double(m_r)  / gradient_subpixel_scale; }
               :        double focus_x() const { return double(m_fx) / gradient_subpixel_scale; }
               :        double focus_y() const { return double(m_fy) / gradient_subpixel_scale; }
               :
               :        //---------------------------------------------------------------------
               :        int calculate(int x, int y, int) const
               :        {
               :            double dx = x - m_fx;
               :            double dy = y - m_fy;
               :            double d2 = dx * m_fy - dy * m_fx;
               :            double d3 = m_r2 * (dx * dx + dy * dy) - d2 * d2;
               :            return iround((dx * m_fx + dy * m_fy + sqrt(fabs(d3))) * m_mul);
               :        }
               :
               :    private:
               :        //---------------------------------------------------------------------
               :        void update_values()
               :        {
               :            // Calculate the invariant values. In case the focal center
               :            // lies exactly on the gradient circle the divisor degenerates
               :            // into zero. In this case we just move the focal center by
               :            // one subpixel unit possibly in the direction to the origin (0,0)
               :            // and calculate the values again.
               :            //-------------------------
               :            m_r2  = double(m_r)  * double(m_r);
               :            m_fx2 = double(m_fx) * double(m_fx);
               :            m_fy2 = double(m_fy) * double(m_fy);
               :            double d = (m_r2 - (m_fx2 + m_fy2));
               :            if(d == 0)
               :            {
               :                if(m_fx) { if(m_fx < 0) ++m_fx; else --m_fx; }
               :                if(m_fy) { if(m_fy < 0) ++m_fy; else --m_fy; }
               :                m_fx2 = double(m_fx) * double(m_fx);
               :                m_fy2 = double(m_fy) * double(m_fy);
               :                d = (m_r2 - (m_fx2 + m_fy2));
               :            }
               :            m_mul = m_r / d;
               :        }
               :
               :        int    m_r;
               :        int    m_fx;
               :        int    m_fy;
               :        double m_r2;
               :        double m_fx2;
               :        double m_fy2;
               :        double m_mul;
               :    };
               :
               :
               :    //==============================================================gradient_x
               :    class gradient_x
               :    {
               :    public:
               :        static int calculate(int x, int, int) { return x; }
               :    };
               :
               :
               :    //==============================================================gradient_y
               :    class gradient_y
               :    {
               :    public:
               :        static int calculate(int, int y, int) { return y; }
               :    };
               :
               :    //========================================================gradient_diamond
               :    class gradient_diamond
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int) 
               :        { 
               :            int ax = abs(x);
               :            int ay = abs(y);
               :            return ax > ay ? ax : ay; 
               :        }
               :    };
               :
               :    //=============================================================gradient_xy
               :    class gradient_xy
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int d) 
               :        { 
               :            return abs(x) * abs(y) / d; 
               :        }
               :    };
               :
               :    //========================================================gradient_sqrt_xy
               :    class gradient_sqrt_xy
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int) 
               :        { 
               :            return fast_sqrt(abs(x) * abs(y)); 
               :        }
               :    };
               :
               :    //==========================================================gradient_conic
               :    class gradient_conic
               :    {
               :    public:
               :        static AGG_INLINE int calculate(int x, int y, int d) 
               :        { 
               :            return uround(fabs(atan2(double(y), double(x))) * double(d) / pi);
               :        }
               :    };
               :
               :    //=================================================gradient_repeat_adaptor
               :    template<class GradientF> class gradient_repeat_adaptor
               :    {
               :    public:
               :        gradient_repeat_adaptor(const GradientF& gradient) : 
               :            m_gradient(&gradient) {}
               :
               :        AGG_INLINE int calculate(int x, int y, int d) const
               :        {
               :            int ret = m_gradient->calculate(x, y, d) % d;
               :            if(ret < 0) ret += d;
               :            return ret;
               :        }
               :
               :    private:
               :        const GradientF* m_gradient;
               :    };
               :
               :    //================================================gradient_reflect_adaptor
               :    template<class GradientF> class gradient_reflect_adaptor
               :    {
               :    public:
               :        gradient_reflect_adaptor(const GradientF& gradient) : 
               :            m_gradient(&gradient) {}
               :
               :        AGG_INLINE int calculate(int x, int y, int d) const
               :        {
               :            int d2 = d << 1;
               :            int ret = m_gradient->calculate(x, y, d) % d2;
               :            if(ret <  0) ret += d2;
               :            if(ret >= d) ret  = d2 - ret;
               :            return ret;
               :        }
               :
               :    private:
               :        const GradientF* m_gradient;
               :    };
               :
               :
               :}
               :
               :#endif
/* 
 * Total samples for file : "/usr/include/agg2/agg_rasterizer_cells_aa.h"
 * 
 *  17503  7.3780
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               ://
               :// The author gratefully acknowleges the support of David Turner, 
               :// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
               :// libray - in producing this work. See http://www.freetype.org for details.
               ://
               ://----------------------------------------------------------------------------
               ://
               :// Adaptation for 32-bit screen coordinates has been sponsored by 
               :// Liberty Technology Systems, Inc., visit http://lib-sys.com
               ://
               :// Liberty Technology Systems, Inc. is the provider of
               :// PostScript and PDF technology for software developers.
               :// 
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
               :#define AGG_RASTERIZER_CELLS_AA_INCLUDED
               :
               :#include <string.h>
               :#include <math.h>
               :#include "agg_math.h"
               :#include "agg_array.h"
               :
               :
               :namespace agg
               :{
               :
               :    //-----------------------------------------------------rasterizer_cells_aa
               :    // An internal class that implements the main rasterization algorithm.
               :    // Used in the rasterizer. Should not be used direcly.
               :    template<class Cell> class rasterizer_cells_aa
               :    {
               :        enum cell_block_scale_e
               :        {
               :            cell_block_shift = 12,
               :            cell_block_size  = 1 << cell_block_shift,
               :            cell_block_mask  = cell_block_size - 1,
               :            cell_block_pool  = 256,
               :            cell_block_limit = 1024
               :        };
               :
               :        struct sorted_y
               :        {
               :            unsigned start;
               :            unsigned num;
               :        };
               :
               :    public:
               :        typedef Cell cell_type;
               :        typedef rasterizer_cells_aa<Cell> self_type;
               :
               :        ~rasterizer_cells_aa();
               :        rasterizer_cells_aa();
               :
               :        void reset();
               :        void style(const cell_type& style_cell);
               :        void line(int x1, int y1, int x2, int y2);
               :
     4  0.0017 :        int min_x() const { return m_min_x; }
               :        int min_y() const { return m_min_y; }
     5  0.0021 :        int max_x() const { return m_max_x; }
               :        int max_y() const { return m_max_y; }
               :
               :        void sort_cells();
               :
               :        unsigned total_cells() const 
               :        {
               :            return m_num_cells;
               :        }
               :
               :        unsigned scanline_num_cells(unsigned y) const 
               :        { 
    41  0.0173 :            return m_sorted_y[y - m_min_y].num; 
               :        }
               :
               :        const cell_type* const* scanline_cells(unsigned y) const
               :        { 
   130  0.0548 :            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start; 
               :        }
               :
               :        bool sorted() const { return m_sorted; }
               :
               :    private:
               :        rasterizer_cells_aa(const self_type&);
               :        const self_type& operator = (const self_type&);
               :
               :        void set_curr_cell(int x, int y);
               :        void add_curr_cell();
               :        void render_hline(int ey, int x1, int y1, int x2, int y2);
               :        void allocate_block();
               :        
               :    private:
               :        unsigned                m_num_blocks;
               :        unsigned                m_max_blocks;
               :        unsigned                m_curr_block;
               :        unsigned                m_num_cells;
               :        cell_type**             m_cells;
               :        cell_type*              m_curr_cell_ptr;
               :        pod_vector<cell_type*>  m_sorted_cells;
               :        pod_vector<sorted_y>    m_sorted_y;
               :        cell_type               m_curr_cell;
               :        cell_type               m_style_cell;
               :        int                     m_min_x;
               :        int                     m_min_y;
               :        int                     m_max_x;
               :        int                     m_max_y;
               :        bool                    m_sorted;
               :    };
               :
               :
               :
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
     5  0.0021 :    rasterizer_cells_aa<Cell>::~rasterizer_cells_aa() /* agg::rasterizer_cells_aa<agg::cell_aa>::~rasterizer_cells_aa() total:     16  0.0067 */
               :    {
     1 4.2e-04 :        if(m_num_blocks)
               :        {
     3  0.0013 :            cell_type** ptr = m_cells + m_num_blocks - 1;
     3  0.0013 :            while(m_num_blocks--)
               :            {
     1 4.2e-04 :                pod_allocator<cell_type>::deallocate(*ptr, cell_block_size);
               :                ptr--;
               :            }
               :            pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
               :        }
     2 8.4e-04 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
               :    rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
               :        m_num_blocks(0),
               :        m_max_blocks(0),
               :        m_curr_block(0),
               :        m_num_cells(0),
               :        m_cells(0),
               :        m_curr_cell_ptr(0),
               :        m_sorted_cells(),
               :        m_sorted_y(),
               :        m_min_x(0x7FFFFFFF),
               :        m_min_y(0x7FFFFFFF),
               :        m_max_x(-0x7FFFFFFF),
               :        m_max_y(-0x7FFFFFFF),
     2 8.4e-04 :        m_sorted(false)
               :    {
               :        m_style_cell.initial();
               :        m_curr_cell.initial();
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
               :    void rasterizer_cells_aa<Cell>::reset()
               :    {
     1 4.2e-04 :        m_num_cells = 0; 
     1 4.2e-04 :        m_curr_block = 0;
               :        m_curr_cell.initial();
               :        m_style_cell.initial();
     1 4.2e-04 :        m_sorted = false;
     1 4.2e-04 :        m_min_x =  0x7FFFFFFF;
               :        m_min_y =  0x7FFFFFFF;
     1 4.2e-04 :        m_max_x = -0x7FFFFFFF;
     1 4.2e-04 :        m_max_y = -0x7FFFFFFF;
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
    47  0.0198 :    AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell() /* agg::rasterizer_cells_aa<agg::cell_aa>::add_curr_cell() total:    234  0.0986 */
               :    {
   338  0.1425 :        if(m_curr_cell.area | m_curr_cell.cover)
               :        {
   180  0.0759 :            if((m_num_cells & cell_block_mask) == 0)
               :            {
    29  0.0122 :                if(m_num_blocks >= cell_block_limit) return;
    11  0.0046 :                allocate_block();
               :            }
   899  0.3790 :            *m_curr_cell_ptr++ = m_curr_cell;
   119  0.0502 :            ++m_num_cells;
               :        }
    15  0.0063 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
               :    AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
               :    {
   435  0.1834 :        if(m_curr_cell.not_equal(x, y, m_style_cell))
               :        {
    13  0.0055 :            add_curr_cell();
               :            m_curr_cell.style(m_style_cell);
    74  0.0312 :            m_curr_cell.x     = x;
   123  0.0518 :            m_curr_cell.y     = y;
    24  0.0101 :            m_curr_cell.cover = 0;
   124  0.0523 :            m_curr_cell.area  = 0;
               :        }
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
   283  0.1193 :    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey,  /* agg::rasterizer_cells_aa<agg::cell_style_aa>::render_hline(int, int, int, int, int)   1374  0.5792, agg::rasterizer_cells_aa<agg::cell_aa>::render_hline(int, int, int, int, int)   1775  0.7482, total:   3149  1.3274 */
               :                                                            int x1, int y1, 
               :                                                            int x2, int y2)
               :    {
    38  0.0160 :        int ex1 = x1 >> poly_subpixel_shift;
    58  0.0244 :        int ex2 = x2 >> poly_subpixel_shift;
    33  0.0139 :        int fx1 = x1 & poly_subpixel_mask;
    52  0.0219 :        int fx2 = x2 & poly_subpixel_mask;
               :
               :        int delta, p, first, dx;
               :        int incr, lift, mod, rem;
               :
               :        //trivial case. Happens often
    38  0.0160 :        if(y1 == y2)
               :        {
               :            set_curr_cell(ex2, ey);
               :            return;
               :        }
               :
               :        //everything is located in a single cell.  That is easy!
   100  0.0422 :        if(ex1 == ex2)
               :        {
   177  0.0746 :            delta = y2 - y1;
   137  0.0577 :            m_curr_cell.cover += delta;
   240  0.1012 :            m_curr_cell.area  += (fx1 + fx2) * delta;
               :            return;
               :        }
               :
               :        //ok, we'll have to render a run of adjacent cells on the same
               :        //hline...
   332  0.1399 :        p     = (poly_subpixel_scale - fx1) * (y2 - y1);
               :        first = poly_subpixel_scale;
               :        incr  = 1;
               :
               :        dx = x2 - x1;
               :
   121  0.0510 :        if(dx < 0)
               :        {
   136  0.0573 :            p     = fx1 * (y2 - y1);
               :            first = 0;
               :            incr  = -1;
   224  0.0944 :            dx    = -dx;
               :        }
               :
               :        delta = p / dx;
    67  0.0282 :        mod   = p % dx;
               :
   923  0.3891 :        if(mod < 0)
               :        {
   105  0.0443 :            delta--;
    21  0.0089 :            mod += dx;
               :        }
               :
    76  0.0320 :        m_curr_cell.cover += delta;
    49  0.0207 :        m_curr_cell.area  += (fx1 + first) * delta;
               :
    61  0.0257 :        ex1 += incr;
               :        set_curr_cell(ex1, ey);
    29  0.0122 :        y1  += delta;
               :
    32  0.0135 :        if(ex1 != ex2)
               :        {
    66  0.0278 :            p     = poly_subpixel_scale * (y2 - y1 + delta);
               :            lift  = p / dx;
    24  0.0101 :            rem   = p % dx;
               :
   333  0.1404 :            if (rem < 0)
               :            {
    35  0.0148 :                lift--;
     5  0.0021 :                rem += dx;
               :            }
               :
    33  0.0139 :            mod -= dx;
               :
    29  0.0122 :            while (ex1 != ex2)
               :            {
               :                delta = lift;
               :                mod  += rem;
   170  0.0717 :                if(mod >= 0)
               :                {
    74  0.0312 :                    mod -= dx;
    35  0.0148 :                    delta++;
               :                }
               :
    26  0.0110 :                m_curr_cell.cover += delta;
    25  0.0105 :                m_curr_cell.area  += poly_subpixel_scale * delta;
     4  0.0017 :                y1  += delta;
               :                ex1 += incr;
               :                set_curr_cell(ex1, ey);
               :            }
               :        }
   145  0.0611 :        delta = y2 - y1;
    19  0.0080 :        m_curr_cell.cover += delta;
   153  0.0645 :        m_curr_cell.area  += (fx2 + poly_subpixel_scale - first) * delta;
   138  0.0582 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
               :    AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
               :    { 
               :        m_style_cell.style(style_cell); 
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
   348  0.1467 :    void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2) /* agg::rasterizer_cells_aa<agg::cell_aa>::line(int, int, int, int)   4108  1.7316, agg::rasterizer_cells_aa<agg::cell_style_aa>::line(int, int, int, int)   3801  1.6022, total:   7909  3.3339 */
               :    {
               :        enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
               :
    37  0.0156 :        int dx = x2 - x1;
               :
    21  0.0089 :        if(dx >= dx_limit || dx <= -dx_limit)
               :        {
               :            int cx = (x1 + x2) >> 1;
               :            int cy = (y1 + y2) >> 1;
               :
               :            // Bail if values are so large they are likely to wrap
               :            if ((abs(x1) >= INT_MAX/2) || (abs(y1) >= INT_MAX/2) ||
               :                (abs(x2) >= INT_MAX/2) || (abs(y2) >= INT_MAX/2))
               :                    return;
               :
               :            line(x1, y1, cx, cy);
               :            line(cx, cy, x2, y2);
               :        }
               :
   107  0.0451 :        int dy = y2 - y1;
    35  0.0148 :        int ex1 = x1 >> poly_subpixel_shift;
    16  0.0067 :        int ex2 = x2 >> poly_subpixel_shift;
    11  0.0046 :        int ey1 = y1 >> poly_subpixel_shift;
     7  0.0030 :        int ey2 = y2 >> poly_subpixel_shift;
    19  0.0080 :        int fy1 = y1 & poly_subpixel_mask;
    12  0.0051 :        int fy2 = y2 & poly_subpixel_mask;
               :
               :        int x_from, x_to;
               :        int p, rem, mod, lift, delta, first, incr;
               :
    41  0.0173 :        if(ex1 < m_min_x) m_min_x = ex1;
    52  0.0219 :        if(ex1 > m_max_x) m_max_x = ex1;
    63  0.0266 :        if(ey1 < m_min_y) m_min_y = ey1;
    39  0.0164 :        if(ey1 > m_max_y) m_max_y = ey1;
    40  0.0169 :        if(ex2 < m_min_x) m_min_x = ex2;
   103  0.0434 :        if(ex2 > m_max_x) m_max_x = ex2;
   146  0.0615 :        if(ey2 < m_min_y) m_min_y = ey2;
   145  0.0611 :        if(ey2 > m_max_y) m_max_y = ey2;
               :
               :        set_curr_cell(ex1, ey1);
               :
               :        //everything is on a single hline
    64  0.0270 :        if(ey1 == ey2)
               :        {
   205  0.0864 :            render_hline(ey1, x1, fy1, x2, fy2);
    13  0.0055 :            return;
               :        }
               :
               :        //Vertical line - we have to calculate start and end cells,
               :        //and then - the common values of the area and coverage for
               :        //all cells of the line. We know exactly there's only one 
               :        //cell, so, we don't have to call render_hline().
               :        incr  = 1;
    20  0.0084 :        if(dx == 0)
               :        {
               :            int ex = x1 >> poly_subpixel_shift;
    18  0.0076 :            int two_fx = (x1 - (ex << poly_subpixel_shift)) << 1;
               :            int area;
               :
               :            first = poly_subpixel_scale;
    32  0.0135 :            if(dy < 0)
               :            {
               :                first = 0;
               :                incr  = -1;
               :            }
               :
               :            x_from = x1;
               :
               :            //render_hline(ey1, x_from, fy1, x_from, first);
     2 8.4e-04 :            delta = first - fy1;
               :            m_curr_cell.cover += delta;
    26  0.0110 :            m_curr_cell.area  += two_fx * delta;
               :
     2 8.4e-04 :            ey1 += incr;
               :            set_curr_cell(ex, ey1);
               :
               :            delta = first + first - poly_subpixel_scale;
     6  0.0025 :            area = two_fx * delta;
    49  0.0207 :            while(ey1 != ey2)
               :            {
               :                //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
     8  0.0034 :                m_curr_cell.cover = delta;
    29  0.0122 :                m_curr_cell.area  = area;
               :                ey1 += incr;
               :                set_curr_cell(ex, ey1);
               :            }
               :            //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
    38  0.0160 :            delta = fy2 - poly_subpixel_scale + first;
     7  0.0030 :            m_curr_cell.cover += delta;
    13  0.0055 :            m_curr_cell.area  += two_fx * delta;
               :            return;
               :        }
               :
               :        //ok, we have to render several hlines
    97  0.0409 :        p     = (poly_subpixel_scale - fy1) * dx;
               :        first = poly_subpixel_scale;
               :
    41  0.0173 :        if(dy < 0)
               :        {
   103  0.0434 :            p     = fy1 * dx;
               :            first = 0;
               :            incr  = -1;
    19  0.0080 :            dy    = -dy;
               :        }
               :
               :        delta = p / dy;
    32  0.0135 :        mod   = p % dy;
               :
   547  0.2306 :        if(mod < 0)
               :        {
    67  0.0282 :            delta--;
     7  0.0030 :            mod += dy;
               :        }
               :
    35  0.0148 :        x_from = x1 + delta;
    73  0.0308 :        render_hline(ey1, x1, fy1, x_from, first);
               :
    23  0.0097 :        ey1 += incr;
    16  0.0067 :        set_curr_cell(x_from >> poly_subpixel_shift, ey1);
               :
    24  0.0101 :        if(ey1 != ey2)
               :        {
    54  0.0228 :            p     = poly_subpixel_scale * dx;
               :            lift  = p / dy;
    15  0.0063 :            rem   = p % dy;
               :
   253  0.1066 :            if(rem < 0)
               :            {
    35  0.0148 :                lift--;
     1 4.2e-04 :                rem += dy;
               :            }
     8  0.0034 :            mod -= dy;
               :
   135  0.0569 :            while(ey1 != ey2)
               :            {
               :                delta = lift;
               :                mod  += rem;
   163  0.0687 :                if (mod >= 0)
               :                {
   144  0.0607 :                    mod -= dy;
    38  0.0160 :                    delta++;
               :                }
               :
    13  0.0055 :                x_to = x_from + delta;
               :                render_hline(ey1, x_from, poly_subpixel_scale - first, x_to, first);
               :                x_from = x_to;
               :
               :                ey1 += incr;
               :                set_curr_cell(x_from >> poly_subpixel_shift, ey1);
               :            }
               :        }
   256  0.1079 :        render_hline(ey1, x_from, poly_subpixel_scale - first, x2, fy2);
   109  0.0459 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
    24  0.0101 :    void rasterizer_cells_aa<Cell>::allocate_block() /* agg::rasterizer_cells_aa<agg::cell_style_aa>::allocate_block()     17  0.0072, agg::rasterizer_cells_aa<agg::cell_aa>::allocate_block()     62  0.0261, total:     79  0.0333 */
               :    {
    24  0.0101 :        if(m_curr_block >= m_num_blocks)
               :        {
     1 4.2e-04 :            if(m_num_blocks >= m_max_blocks)
               :            {
               :                cell_type** new_cells = 
               :                    pod_allocator<cell_type*>::allocate(m_max_blocks + 
               :                                                        cell_block_pool);
               :
               :                if(m_cells)
               :                {
               :                    memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_type*));
               :                    pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
               :                }
               :                m_cells = new_cells;
               :                m_max_blocks += cell_block_pool;
               :            }
               :
     1 4.2e-04 :            m_cells[m_num_blocks++] = 
               :                pod_allocator<cell_type>::allocate(cell_block_size);
               :
               :        }
    19  0.0080 :        m_curr_cell_ptr = m_cells[m_curr_block++];
     2 8.4e-04 :    }
               :
               :
               :
               :    //------------------------------------------------------------------------
               :    template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
               :    {
     4  0.0017 :        T temp = *a;
   440  0.1855 :        *a = *b;
   160  0.0674 :        *b = temp;
               :    }
               :
               :
               :    //------------------------------------------------------------------------
               :    enum
               :    {
               :        qsort_threshold = 9
               :    };
               :
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell>
    91  0.0384 :    void qsort_cells(Cell** start, unsigned num) /* void agg::qsort_cells<agg::cell_aa>(agg::cell_aa**, unsigned int)   1862  0.7849, void agg::qsort_cells<agg::cell_style_aa>(agg::cell_style_aa**, unsigned int)   1806  0.7613, total:   3668  1.5462 */
               :    {
               :        Cell**  stack[80];
               :        Cell*** top; 
               :        Cell**  limit;
               :        Cell**  base;
               :
   104  0.0438 :        limit = start + num;
               :        base  = start;
               :        top   = stack;
               :
               :        for (;;)
               :        {
    69  0.0291 :            int len = int(limit - base);
               :
               :            Cell** i;
               :            Cell** j;
               :            Cell** pivot;
               :
    36  0.0152 :            if(len > qsort_threshold)
               :            {
               :                // we use base + len/2 as the pivot
    54  0.0228 :                pivot = base + len / 2;
               :                swap_cells(base, pivot);
               :
     1 4.2e-04 :                i = base + 1;
     9  0.0038 :                j = limit - 1;
               :
               :                // now ensure that *i <= *base <= *j 
    30  0.0126 :                if((*j)->x < (*i)->x)
               :                {
               :                    swap_cells(i, j);
               :                }
               :
    45  0.0190 :                if((*base)->x < (*i)->x)
               :                {
               :                    swap_cells(base, i);
               :                }
               :
    21  0.0089 :                if((*j)->x < (*base)->x)
               :                {
               :                    swap_cells(base, j);
               :                }
               :
               :                for(;;)
               :                {
               :                    int x = (*base)->x;
   236  0.0995 :                    do i++; while( (*i)->x < x );
   280  0.1180 :                    do j--; while( x < (*j)->x );
               :
    96  0.0405 :                    if(i > j)
               :                    {
               :                        break;
               :                    }
               :
               :                    swap_cells(i, j);
               :                }
               :
               :                swap_cells(base, j);
               :
               :                // now, push the largest sub-array
    20  0.0084 :                if(j - base > limit - i)
               :                {
     5  0.0021 :                    top[0] = base;
    14  0.0059 :                    top[1] = j;
               :                    base   = i;
               :                }
               :                else
               :                {
     3  0.0013 :                    top[0] = i;
    22  0.0093 :                    top[1] = limit;
               :                    limit  = j;
               :                }
     5  0.0021 :                top += 2;
               :            }
               :            else
               :            {
               :                // the sub-array is small, perform insertion sort
               :                j = base;
    25  0.0105 :                i = j + 1;
               :
   907  0.3823 :                for(; i < limit; j = i, i++)
               :                {
   536  0.2259 :                    for(; j[1]->x < (*j)->x; j--)
               :                    {
               :                        swap_cells(j + 1, j);
    84  0.0354 :                        if (j == base)
               :                        {
               :                            break;
               :                        }
               :                    }
               :                }
               :
   218  0.0919 :                if(top > stack)
               :                {
    11  0.0046 :                    top  -= 2;
    44  0.0185 :                    base  = top[0];
    25  0.0105 :                    limit = top[1];
               :                }
               :                else
               :                {
               :                    break;
               :                }
               :            }
               :        }
    73  0.0308 :    }
               :
               :
               :    //------------------------------------------------------------------------
               :    template<class Cell> 
    40  0.0169 :    void rasterizer_cells_aa<Cell>::sort_cells() /* agg::rasterizer_cells_aa<agg::cell_style_aa>::sort_cells()   1281  0.5400, agg::rasterizer_cells_aa<agg::cell_aa>::sort_cells()   1544  0.6508, total:   2825  1.1908 */
               :    {
    12  0.0051 :        if(m_sorted) return; //Perform sort only the first time.
               :
               :        add_curr_cell();
    10  0.0042 :        m_curr_cell.x     = 0x7FFFFFFF;
     1 4.2e-04 :        m_curr_cell.y     = 0x7FFFFFFF;
     2 8.4e-04 :        m_curr_cell.cover = 0;
               :        m_curr_cell.area  = 0;
               :
     1 4.2e-04 :        if(m_num_cells == 0) return;
               :
               :// DBG: Check to see if min/max works well.
               ://for(unsigned nc = 0; nc < m_num_cells; nc++)
               ://{
               ://    cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
               ://    if(cell->x < m_min_x || 
               ://       cell->y < m_min_y || 
               ://       cell->x > m_max_x || 
               ://       cell->y > m_max_y)
               ://    {
               ://        cell = cell; // Breakpoint here
               ://    }
               ://}
               :        // Allocate the array of cell pointers
               :        m_sorted_cells.allocate(m_num_cells, 16);
               :
               :        // Allocate and zero the Y array
     1 4.2e-04 :        m_sorted_y.allocate(m_max_y - m_min_y + 1, 16);
               :        m_sorted_y.zero();
               :
               :        // Create the Y-histogram (count the numbers of cells for each Y)
    10  0.0042 :        cell_type** block_ptr = m_cells;
               :        cell_type*  cell_ptr;
     2 8.4e-04 :        unsigned nb = m_num_cells >> cell_block_shift;
               :        unsigned i;
    11  0.0046 :        while(nb--)
               :        {
               :            cell_ptr = *block_ptr++;
               :            i = cell_block_size;
     6  0.0025 :            while(i--) 
               :            {
     4  0.0017 :                m_sorted_y[cell_ptr->y - m_min_y].start++;
               :                ++cell_ptr;
               :            }
               :        }
               :
               :        cell_ptr = *block_ptr++;
               :        i = m_num_cells & cell_block_mask;
   484  0.2040 :        while(i--) 
               :        {
    13  0.0055 :            m_sorted_y[cell_ptr->y - m_min_y].start++;
   120  0.0506 :            ++cell_ptr;
               :        }
               :
               :        // Convert the Y-histogram into the array of starting indexes
               :        unsigned start = 0;
    54  0.0228 :        for(i = 0; i < m_sorted_y.size(); i++)
               :        {
               :            unsigned v = m_sorted_y[i].start;
    16  0.0067 :            m_sorted_y[i].start = start;
               :            start += v;
               :        }
               :
               :        // Fill the cell pointer array sorted by Y
               :        block_ptr = m_cells;
               :        nb = m_num_cells >> cell_block_shift;
    44  0.0185 :        while(nb--)
               :        {
               :            cell_ptr = *block_ptr++;
               :            i = cell_block_size;
     7  0.0030 :            while(i--) 
               :            {
               :                sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
     8  0.0034 :                m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
     5  0.0021 :                ++curr_y.num;
     5  0.0021 :                ++cell_ptr;
               :            }
               :        }
               :        
     3  0.0013 :        cell_ptr = *block_ptr++;
     5  0.0021 :        i = m_num_cells & cell_block_mask;
    53  0.0223 :        while(i--) 
               :        {
     2 8.4e-04 :            sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
   468  0.1973 :            m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
   499  0.2103 :            ++curr_y.num;
   232  0.0978 :            ++cell_ptr;
               :        }
               :
               :        // Finally arrange the X-arrays
   106  0.0447 :        for(i = 0; i < m_sorted_y.size(); i++)
               :        {
               :            const sorted_y& curr_y = m_sorted_y[i];
    53  0.0223 :            if(curr_y.num)
               :            {
    81  0.0341 :                qsort_cells(m_sorted_cells.data() + curr_y.start, curr_y.num);
               :            }
               :        }
    34  0.0143 :        m_sorted = true;
    10  0.0042 :    }
               :
               :
               :
               :    //------------------------------------------------------scanline_hit_test
               :    class scanline_hit_test
               :    {
               :    public:
               :        scanline_hit_test(int x) : m_x(x), m_hit(false) {}
               :
               :        void reset_spans() {}
               :        void finalize(int) {}
               :        void add_cell(int x, int)
               :        {
               :            if(m_x == x) m_hit = true;
               :        }
               :        void add_span(int x, int len, int)
               :        {
               :            if(m_x >= x && m_x < x+len) m_hit = true;
               :        }
               :        unsigned num_spans() const { return 1; }
               :        bool hit() const { return m_hit; }
               :
               :    private:
               :        int  m_x;
               :        bool m_hit;
               :    };
               :
               :
               :}
               :
               :#endif
/* 
 * Total samples for file : "/usr/include/agg2/agg_pixfmt_rgba.h"
 * 
 *  16530  6.9679
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               ://
               :// Adaptation for high precision colors has been sponsored by 
               :// Liberty Technology Systems, Inc., visit http://lib-sys.com
               ://
               :// Liberty Technology Systems, Inc. is the provider of
               :// PostScript and PDF technology for software developers.
               :// 
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_PIXFMT_RGBA_INCLUDED
               :#define AGG_PIXFMT_RGBA_INCLUDED
               :
               :#include <string.h>
               :#include <math.h>
               :#include "agg_basics.h"
               :#include "agg_color_rgba.h"
               :#include "agg_rendering_buffer.h"
               :
               :namespace agg
               :{
               :
               :    //=========================================================multiplier_rgba
               :    template<class ColorT, class Order> struct multiplier_rgba
               :    {
               :        typedef typename ColorT::value_type value_type;
               :        typedef typename ColorT::calc_type calc_type;
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void premultiply(value_type* p)
               :        {
               :            calc_type a = p[Order::A];
               :            if(a < ColorT::base_mask)
               :            {
               :                if(a == 0)
               :                {
               :                    p[Order::R] = p[Order::G] = p[Order::B] = 0;
               :                    return;
               :                }
               :                p[Order::R] = value_type((p[Order::R] * a + ColorT::base_mask) >> ColorT::base_shift);
               :                p[Order::G] = value_type((p[Order::G] * a + ColorT::base_mask) >> ColorT::base_shift);
               :                p[Order::B] = value_type((p[Order::B] * a + ColorT::base_mask) >> ColorT::base_shift);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void demultiply(value_type* p)
               :        {
               :            calc_type a = p[Order::A];
               :            if(a < ColorT::base_mask)
               :            {
               :                if(a == 0)
               :                {
               :                    p[Order::R] = p[Order::G] = p[Order::B] = 0;
               :                    return;
               :                }
               :                calc_type r = (calc_type(p[Order::R]) * ColorT::base_mask) / a;
               :                calc_type g = (calc_type(p[Order::G]) * ColorT::base_mask) / a;
               :                calc_type b = (calc_type(p[Order::B]) * ColorT::base_mask) / a;
               :                p[Order::R] = value_type((r > ColorT::base_mask) ? ColorT::base_mask : r);
               :                p[Order::G] = value_type((g > ColorT::base_mask) ? ColorT::base_mask : g);
               :                p[Order::B] = value_type((b > ColorT::base_mask) ? ColorT::base_mask : b);
               :            }
               :        }
               :    };
               :
               :    //=====================================================apply_gamma_dir_rgba
               :    template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgba
               :    {
               :    public:
               :        typedef typename ColorT::value_type value_type;
               :
               :        apply_gamma_dir_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
               :
               :        AGG_INLINE void operator () (value_type* p)
               :        {
               :            p[Order::R] = m_gamma.dir(p[Order::R]);
               :            p[Order::G] = m_gamma.dir(p[Order::G]);
               :            p[Order::B] = m_gamma.dir(p[Order::B]);
               :        }
               :
               :    private:
               :        const GammaLut& m_gamma;
               :    };
               :
               :    //=====================================================apply_gamma_inv_rgba
               :    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgba
               :    {
               :    public:
               :        typedef typename ColorT::value_type value_type;
               :
               :        apply_gamma_inv_rgba(const GammaLut& gamma) : m_gamma(gamma) {}
               :
               :        AGG_INLINE void operator () (value_type* p)
               :        {
               :            p[Order::R] = m_gamma.inv(p[Order::R]);
               :            p[Order::G] = m_gamma.inv(p[Order::G]);
               :            p[Order::B] = m_gamma.inv(p[Order::B]);
               :        }
               :
               :    private:
               :        const GammaLut& m_gamma;
               :    };
               :
               :
               :    
               :
               :
               :
               :
               :
               :
               :
               :    //=============================================================blender_rgba
               :    template<class ColorT, class Order> struct blender_rgba
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e 
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha, 
               :                                         unsigned cover=0)
               :        {
               :            calc_type r = p[Order::R];
               :            calc_type g = p[Order::G];
               :            calc_type b = p[Order::B];
               :            calc_type a = p[Order::A];
               :            p[Order::R] = (value_type)(((cr - r) * alpha + (r << base_shift)) >> base_shift);
               :            p[Order::G] = (value_type)(((cg - g) * alpha + (g << base_shift)) >> base_shift);
               :            p[Order::B] = (value_type)(((cb - b) * alpha + (b << base_shift)) >> base_shift);
               :            p[Order::A] = (value_type)((alpha + a) - ((alpha * a + base_mask) >> base_shift));
               :        }
               :    };
               :
               :    //=========================================================blender_rgba_pre
               :    template<class ColorT, class Order> struct blender_rgba_pre
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha,
               :                                         unsigned cover)
               :        {
   104  0.0438 :            alpha = color_type::base_mask - alpha;
               :            cover = (cover + 1) << (base_shift - 8);
  1284  0.5412 :            p[Order::R] = (value_type)((p[Order::R] * alpha + cr * cover) >> base_shift);
   381  0.1606 :            p[Order::G] = (value_type)((p[Order::G] * alpha + cg * cover) >> base_shift);
   229  0.0965 :            p[Order::B] = (value_type)((p[Order::B] * alpha + cb * cover) >> base_shift);
   741  0.3124 :            p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha)
               :        {
   299  0.1260 :            alpha = color_type::base_mask - alpha;
  1151  0.4852 :            p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
   538  0.2268 :            p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
   522  0.2200 :            p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
   307  0.1294 :            p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));
               :        }
               :    };
               :
               :    //======================================================blender_rgba_plain
               :    template<class ColorT, class Order> struct blender_rgba_plain
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e { base_shift = color_type::base_shift };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha,
               :                                         unsigned cover=0)
               :        {
               :            if(alpha == 0) return;
               :            calc_type a = p[Order::A];
               :            calc_type r = p[Order::R] * a;
               :            calc_type g = p[Order::G] * a;
               :            calc_type b = p[Order::B] * a;
               :            a = ((alpha + a) << base_shift) - alpha * a;
               :            p[Order::A] = (value_type)(a >> base_shift);
               :            p[Order::R] = (value_type)((((cr << base_shift) - r) * alpha + (r << base_shift)) / a);
               :            p[Order::G] = (value_type)((((cg << base_shift) - g) * alpha + (g << base_shift)) / a);
               :            p[Order::B] = (value_type)((((cb << base_shift) - b) * alpha + (b << base_shift)) / a);
               :        }
               :    };
               :
               :
               :
               :
               :
               :
               :
               :
               :
               :
               :
               :    //=========================================================comp_op_rgba_clear
               :    template<class ColorT, class Order> struct comp_op_rgba_clear
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned, unsigned, unsigned, unsigned,
               :                                         unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                cover = 255 - cover;
               :                p[Order::R] = (value_type)((p[Order::R] * cover + 255) >> 8);
               :                p[Order::G] = (value_type)((p[Order::G] * cover + 255) >> 8);
               :                p[Order::B] = (value_type)((p[Order::B] * cover + 255) >> 8);
               :                p[Order::A] = (value_type)((p[Order::A] * cover + 255) >> 8);
               :            }
               :            else
               :            {
               :                p[0] = p[1] = p[2] = p[3] = 0; 
               :            }
               :        }
               :    };
               :
               :    //===========================================================comp_op_rgba_src
               :    template<class ColorT, class Order> struct comp_op_rgba_src
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                unsigned alpha = 255 - cover;
               :                p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((sr * cover + 255) >> 8));
               :                p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((sg * cover + 255) >> 8));
               :                p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((sb * cover + 255) >> 8));
               :                p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
               :            }
               :            else
               :            {
               :                p[Order::R] = sr;
               :                p[Order::G] = sg;
               :                p[Order::B] = sb;
               :                p[Order::A] = sa;
               :            }
               :        }
               :    };
               :
               :    //===========================================================comp_op_rgba_dst
               :    template<class ColorT, class Order> struct comp_op_rgba_dst
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :
               :        static AGG_INLINE void blend_pix(value_type*, 
               :                                         unsigned, unsigned, unsigned, 
               :                                         unsigned, unsigned)
               :        {
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_src_over
               :    template<class ColorT, class Order> struct comp_op_rgba_src_over
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //   Dca' = Sca + Dca.(1 - Sa)
               :        //   Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            calc_type s1a = base_mask - sa;
               :            p[Order::R] = (value_type)(sr + ((p[Order::R] * s1a + base_mask) >> base_shift));
               :            p[Order::G] = (value_type)(sg + ((p[Order::G] * s1a + base_mask) >> base_shift));
               :            p[Order::B] = (value_type)(sb + ((p[Order::B] * s1a + base_mask) >> base_shift));
               :            p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_dst_over
               :    template<class ColorT, class Order> struct comp_op_rgba_dst_over
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Dca + Sca.(1 - Da)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            calc_type d1a = base_mask - p[Order::A];
               :            p[Order::R] = (value_type)(p[Order::R] + ((sr * d1a + base_mask) >> base_shift));
               :            p[Order::G] = (value_type)(p[Order::G] + ((sg * d1a + base_mask) >> base_shift));
               :            p[Order::B] = (value_type)(p[Order::B] + ((sb * d1a + base_mask) >> base_shift));
               :            p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_src_in
               :    template<class ColorT, class Order> struct comp_op_rgba_src_in
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca.Da
               :        // Da'  = Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            calc_type da = p[Order::A];
               :            if(cover < 255)
               :            {
               :                unsigned alpha = 255 - cover;
               :                p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((((sr * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((((sg * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((((sb * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :            }
               :            else
               :            {
               :                p[Order::R] = (value_type)((sr * da + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sg * da + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sb * da + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
               :            }
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_dst_in
               :    template<class ColorT, class Order> struct comp_op_rgba_dst_in
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Dca.Sa
               :        // Da'  = Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned, unsigned, unsigned, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sa = base_mask - ((cover * (base_mask - sa) + 255) >> 8);
               :            }
               :            p[Order::R] = (value_type)((p[Order::R] * sa + base_mask) >> base_shift);
               :            p[Order::G] = (value_type)((p[Order::G] * sa + base_mask) >> base_shift);
               :            p[Order::B] = (value_type)((p[Order::B] * sa + base_mask) >> base_shift);
               :            p[Order::A] = (value_type)((p[Order::A] * sa + base_mask) >> base_shift);
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_src_out
               :    template<class ColorT, class Order> struct comp_op_rgba_src_out
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca.(1 - Da)
               :        // Da'  = Sa.(1 - Da) 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            calc_type da = base_mask - p[Order::A];
               :            if(cover < 255)
               :            {
               :                unsigned alpha = 255 - cover;
               :                p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((((sr * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((((sg * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((((sb * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :                p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((((sa * da + base_mask) >> base_shift) * cover + 255) >> 8));
               :            }
               :            else
               :            {
               :                p[Order::R] = (value_type)((sr * da + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sg * da + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sb * da + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)((sa * da + base_mask) >> base_shift);
               :            }
               :        }
               :    };
               :
               :    //======================================================comp_op_rgba_dst_out
               :    template<class ColorT, class Order> struct comp_op_rgba_dst_out
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Dca.(1 - Sa) 
               :        // Da'  = Da.(1 - Sa) 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned, unsigned, unsigned, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            sa = base_mask - sa;
               :            p[Order::R] = (value_type)((p[Order::R] * sa + base_shift) >> base_shift);
               :            p[Order::G] = (value_type)((p[Order::G] * sa + base_shift) >> base_shift);
               :            p[Order::B] = (value_type)((p[Order::B] * sa + base_shift) >> base_shift);
               :            p[Order::A] = (value_type)((p[Order::A] * sa + base_shift) >> base_shift);
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_src_atop
               :    template<class ColorT, class Order> struct comp_op_rgba_src_atop
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca.Da + Dca.(1 - Sa)
               :        // Da'  = Da
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            calc_type da = p[Order::A];
               :            sa = base_mask - sa;
               :            p[Order::R] = (value_type)((sr * da + p[Order::R] * sa + base_mask) >> base_shift);
               :            p[Order::G] = (value_type)((sg * da + p[Order::G] * sa + base_mask) >> base_shift);
               :            p[Order::B] = (value_type)((sb * da + p[Order::B] * sa + base_mask) >> base_shift);
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_dst_atop
               :    template<class ColorT, class Order> struct comp_op_rgba_dst_atop
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Dca.Sa + Sca.(1 - Da)
               :        // Da'  = Sa 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            calc_type da = base_mask - p[Order::A];
               :            if(cover < 255)
               :            {
               :                unsigned alpha = 255 - cover;
               :                sr = (p[Order::R] * sa + sr * da + base_mask) >> base_shift;
               :                sg = (p[Order::G] * sa + sg * da + base_mask) >> base_shift;
               :                sb = (p[Order::B] * sa + sb * da + base_mask) >> base_shift;
               :                p[Order::R] = (value_type)(((p[Order::R] * alpha + 255) >> 8) + ((sr * cover + 255) >> 8));
               :                p[Order::G] = (value_type)(((p[Order::G] * alpha + 255) >> 8) + ((sg * cover + 255) >> 8));
               :                p[Order::B] = (value_type)(((p[Order::B] * alpha + 255) >> 8) + ((sb * cover + 255) >> 8));
               :                p[Order::A] = (value_type)(((p[Order::A] * alpha + 255) >> 8) + ((sa * cover + 255) >> 8));
               :
               :            }
               :            else
               :            {
               :                p[Order::R] = (value_type)((p[Order::R] * sa + sr * da + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((p[Order::G] * sa + sg * da + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((p[Order::B] * sa + sb * da + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)sa;
               :            }
               :        }
               :    };
               :
               :    //=========================================================comp_op_rgba_xor
               :    template<class ColorT, class Order> struct comp_op_rgba_xor
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - 2.Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type s1a = base_mask - sa;
               :                calc_type d1a = base_mask - p[Order::A];
               :                p[Order::R] = (value_type)((p[Order::R] * s1a + sr * d1a + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((p[Order::G] * s1a + sg * d1a + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((p[Order::B] * s1a + sb * d1a + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask/2) >> (base_shift - 1)));
               :            }
               :        }
               :    };
               :
               :    //=========================================================comp_op_rgba_plus
               :    template<class ColorT, class Order> struct comp_op_rgba_plus
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca + Dca
               :        // Da'  = Sa + Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type dr = p[Order::R] + sr;
               :                calc_type dg = p[Order::G] + sg;
               :                calc_type db = p[Order::B] + sb;
               :                calc_type da = p[Order::A] + sa;
               :                p[Order::R] = (dr > base_mask) ? (value_type)base_mask : dr;
               :                p[Order::G] = (dg > base_mask) ? (value_type)base_mask : dg;
               :                p[Order::B] = (db > base_mask) ? (value_type)base_mask : db;
               :                p[Order::A] = (da > base_mask) ? (value_type)base_mask : da;
               :            }
               :        }
               :    };
               :
               :    //========================================================comp_op_rgba_minus
               :    template<class ColorT, class Order> struct comp_op_rgba_minus
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Dca - Sca
               :        // Da' = 1 - (1 - Sa).(1 - Da)
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type dr = p[Order::R] - sr;
               :                calc_type dg = p[Order::G] - sg;
               :                calc_type db = p[Order::B] - sb;
               :                p[Order::R] = (dr > base_mask) ? 0 : dr;
               :                p[Order::G] = (dg > base_mask) ? 0 : dg;
               :                p[Order::B] = (db > base_mask) ? 0 : db;
               :                p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
               :                //p[Order::A] = (value_type)(base_mask - (((base_mask - sa) * (base_mask - p[Order::A]) + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_multiply
               :    template<class ColorT, class Order> struct comp_op_rgba_multiply
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type s1a = base_mask - sa;
               :                calc_type d1a = base_mask - p[Order::A];
               :                calc_type dr = p[Order::R];
               :                calc_type dg = p[Order::G];
               :                calc_type db = p[Order::B];
               :                p[Order::R] = (value_type)((sr * dr + sr * d1a + dr * s1a + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sg * dg + sg * d1a + dg * s1a + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sb * db + sb * d1a + db * s1a + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)(sa + p[Order::A] - ((sa * p[Order::A] + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_screen
               :    template<class ColorT, class Order> struct comp_op_rgba_screen
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca + Dca - Sca.Dca
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type dr = p[Order::R];
               :                calc_type dg = p[Order::G];
               :                calc_type db = p[Order::B];
               :                calc_type da = p[Order::A];
               :                p[Order::R] = (value_type)(sr + dr - ((sr * dr + base_mask) >> base_shift));
               :                p[Order::G] = (value_type)(sg + dg - ((sg * dg + base_mask) >> base_shift));
               :                p[Order::B] = (value_type)(sb + db - ((sb * db + base_mask) >> base_shift));
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_overlay
               :    template<class ColorT, class Order> struct comp_op_rgba_overlay
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // if 2.Dca < Da
               :        //   Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise
               :        //   Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // 
               :        // Da' = Sa + Da - Sa.Da
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a  = base_mask - p[Order::A];
               :                calc_type s1a  = base_mask - sa;
               :                calc_type dr   = p[Order::R];
               :                calc_type dg   = p[Order::G];
               :                calc_type db   = p[Order::B];
               :                calc_type da   = p[Order::A];
               :                calc_type sada = sa * p[Order::A];
               :
               :                p[Order::R] = (value_type)(((2*dr < da) ? 
               :                    2*sr*dr + sr*d1a + dr*s1a : 
               :                    sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
               :
               :                p[Order::G] = (value_type)(((2*dg < da) ? 
               :                    2*sg*dg + sg*d1a + dg*s1a : 
               :                    sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
               :
               :                p[Order::B] = (value_type)(((2*db < da) ? 
               :                    2*sb*db + sb*d1a + db*s1a : 
               :                    sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
               :
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :
               :    template<class T> inline T sd_min(T a, T b) { return (a < b) ? a : b; }
               :    template<class T> inline T sd_max(T a, T b) { return (a > b) ? a : b; }
               :
               :    //=====================================================comp_op_rgba_darken
               :    template<class ColorT, class Order> struct comp_op_rgba_darken
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a = base_mask - p[Order::A];
               :                calc_type s1a = base_mask - sa;
               :                calc_type dr  = p[Order::R];
               :                calc_type dg  = p[Order::G];
               :                calc_type db  = p[Order::B];
               :                calc_type da  = p[Order::A];
               :
               :                p[Order::R] = (value_type)((sd_min(sr * da, dr * sa) + sr * d1a + dr * s1a + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sd_min(sg * da, dg * sa) + sg * d1a + dg * s1a + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sd_min(sb * da, db * sa) + sb * d1a + db * s1a + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_lighten
               :    template<class ColorT, class Order> struct comp_op_rgba_lighten
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a = base_mask - p[Order::A];
               :                calc_type s1a = base_mask - sa;
               :                calc_type dr  = p[Order::R];
               :                calc_type dg  = p[Order::G];
               :                calc_type db  = p[Order::B];
               :                calc_type da  = p[Order::A];
               :
               :                p[Order::R] = (value_type)((sd_max(sr * da, dr * sa) + sr * d1a + dr * s1a + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sd_max(sg * da, dg * sa) + sg * d1a + dg * s1a + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sd_max(sb * da, db * sa) + sb * d1a + db * s1a + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_color_dodge
               :    template<class ColorT, class Order> struct comp_op_rgba_color_dodge
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // if Sca.Da + Dca.Sa >= Sa.Da
               :        //   Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise
               :        //   Dca' = Dca.Sa/(1-Sca/Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        //
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a  = base_mask - p[Order::A];
               :                calc_type s1a  = base_mask - sa;
               :                calc_type dr   = p[Order::R];
               :                calc_type dg   = p[Order::G];
               :                calc_type db   = p[Order::B];
               :                calc_type da   = p[Order::A];
               :                long_type drsa = dr * sa;
               :                long_type dgsa = dg * sa;
               :                long_type dbsa = db * sa;
               :                long_type srda = sr * da;
               :                long_type sgda = sg * da;
               :                long_type sbda = sb * da;
               :                long_type sada = sa * da;
               :
               :                p[Order::R] = (value_type)((srda + drsa >= sada) ? 
               :                    (sada + sr * d1a + dr * s1a + base_mask) >> base_shift :
               :                    drsa / (base_mask - (sr << base_shift) / sa) + ((sr * d1a + dr * s1a + base_mask) >> base_shift));
               :
               :                p[Order::G] = (value_type)((sgda + dgsa >= sada) ? 
               :                    (sada + sg * d1a + dg * s1a + base_mask) >> base_shift :
               :                    dgsa / (base_mask - (sg << base_shift) / sa) + ((sg * d1a + dg * s1a + base_mask) >> base_shift));
               :
               :                p[Order::B] = (value_type)((sbda + dbsa >= sada) ? 
               :                    (sada + sb * d1a + db * s1a + base_mask) >> base_shift :
               :                    dbsa / (base_mask - (sb << base_shift) / sa) + ((sb * d1a + db * s1a + base_mask) >> base_shift));
               :
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_color_burn
               :    template<class ColorT, class Order> struct comp_op_rgba_color_burn
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // if Sca.Da + Dca.Sa <= Sa.Da
               :        //   Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise
               :        //   Dca' = Sa.(Sca.Da + Dca.Sa - Sa.Da)/Sca + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // 
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a  = base_mask - p[Order::A];
               :                calc_type s1a  = base_mask - sa;
               :                calc_type dr   = p[Order::R];
               :                calc_type dg   = p[Order::G];
               :                calc_type db   = p[Order::B];
               :                calc_type da   = p[Order::A];
               :                long_type drsa = dr * sa;
               :                long_type dgsa = dg * sa;
               :                long_type dbsa = db * sa;
               :                long_type srda = sr * da;
               :                long_type sgda = sg * da;
               :                long_type sbda = sb * da;
               :                long_type sada = sa * da;
               :
               :                p[Order::R] = (value_type)(((srda + drsa <= sada) ? 
               :                    sr * d1a + dr * s1a :
               :                    sa * (srda + drsa - sada) / sr + sr * d1a + dr * s1a + base_mask) >> base_shift);
               :
               :                p[Order::G] = (value_type)(((sgda + dgsa <= sada) ? 
               :                    sg * d1a + dg * s1a :
               :                    sa * (sgda + dgsa - sada) / sg + sg * d1a + dg * s1a + base_mask) >> base_shift);
               :
               :                p[Order::B] = (value_type)(((sbda + dbsa <= sada) ? 
               :                    sb * d1a + db * s1a :
               :                    sa * (sbda + dbsa - sada) / sb + sb * d1a + db * s1a + base_mask) >> base_shift);
               :
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_hard_light
               :    template<class ColorT, class Order> struct comp_op_rgba_hard_light
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // if 2.Sca < Sa
               :        //    Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise
               :        //    Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // 
               :        // Da'  = Sa + Da - Sa.Da
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a  = base_mask - p[Order::A];
               :                calc_type s1a  = base_mask - sa;
               :                calc_type dr   = p[Order::R];
               :                calc_type dg   = p[Order::G];
               :                calc_type db   = p[Order::B];
               :                calc_type da   = p[Order::A];
               :                calc_type sada = sa * da;
               :
               :                p[Order::R] = (value_type)(((2*sr < sa) ? 
               :                    2*sr*dr + sr*d1a + dr*s1a : 
               :                    sada - 2*(da - dr)*(sa - sr) + sr*d1a + dr*s1a + base_mask) >> base_shift);
               :
               :                p[Order::G] = (value_type)(((2*sg < sa) ? 
               :                    2*sg*dg + sg*d1a + dg*s1a : 
               :                    sada - 2*(da - dg)*(sa - sg) + sg*d1a + dg*s1a + base_mask) >> base_shift);
               :
               :                p[Order::B] = (value_type)(((2*sb < sa) ? 
               :                    2*sb*db + sb*d1a + db*s1a : 
               :                    sada - 2*(da - db)*(sa - sb) + sb*d1a + db*s1a + base_mask) >> base_shift);
               :
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_soft_light
               :    template<class ColorT, class Order> struct comp_op_rgba_soft_light
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // if 2.Sca < Sa
               :        //   Dca' = Dca.(Sa + (1 - Dca/Da).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise if 8.Dca <= Da
               :        //   Dca' = Dca.(Sa + (1 - Dca/Da).(2.Sca - Sa).(3 - 8.Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // otherwise
               :        //   Dca' = (Dca.Sa + ((Dca/Da)^(0.5).Da - Dca).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // 
               :        // Da'  = Sa + Da - Sa.Da 
               :
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned r, unsigned g, unsigned b, 
               :                                         unsigned a, unsigned cover)
               :        {
               :            double sr = double(r * cover) / (base_mask * 255);
               :            double sg = double(g * cover) / (base_mask * 255);
               :            double sb = double(b * cover) / (base_mask * 255);
               :            double sa = double(a * cover) / (base_mask * 255);
               :            if(sa > 0)
               :            {
               :                double dr = double(p[Order::R]) / base_mask;
               :                double dg = double(p[Order::G]) / base_mask;
               :                double db = double(p[Order::B]) / base_mask;
               :                double da = double(p[Order::A] ? p[Order::A] : 1) / base_mask;
               :                if(cover < 255)
               :                {
               :                    a = (a * cover + 255) >> 8;
               :                }
               :
               :                if(2*sr < sa)       dr = dr*(sa + (1 - dr/da)*(2*sr - sa)) + sr*(1 - da) + dr*(1 - sa);
               :                else if(8*dr <= da) dr = dr*(sa + (1 - dr/da)*(2*sr - sa)*(3 - 8*dr/da)) + sr*(1 - da) + dr*(1 - sa);
               :                else                dr = (dr*sa + (sqrt(dr/da)*da - dr)*(2*sr - sa)) + sr*(1 - da) + dr*(1 - sa);
               :
               :                if(2*sg < sa)       dg = dg*(sa + (1 - dg/da)*(2*sg - sa)) + sg*(1 - da) + dg*(1 - sa);
               :                else if(8*dg <= da) dg = dg*(sa + (1 - dg/da)*(2*sg - sa)*(3 - 8*dg/da)) + sg*(1 - da) + dg*(1 - sa);
               :                else                dg = (dg*sa + (sqrt(dg/da)*da - dg)*(2*sg - sa)) + sg*(1 - da) + dg*(1 - sa);
               :
               :                if(2*sb < sa)       db = db*(sa + (1 - db/da)*(2*sb - sa)) + sb*(1 - da) + db*(1 - sa);
               :                else if(8*db <= da) db = db*(sa + (1 - db/da)*(2*sb - sa)*(3 - 8*db/da)) + sb*(1 - da) + db*(1 - sa);
               :                else                db = (db*sa + (sqrt(db/da)*da - db)*(2*sb - sa)) + sb*(1 - da) + db*(1 - sa);
               :
               :                p[Order::R] = (value_type)uround(dr * base_mask);
               :                p[Order::G] = (value_type)uround(dg * base_mask);
               :                p[Order::B] = (value_type)uround(db * base_mask);
               :                p[Order::A] = (value_type)(a + p[Order::A] - ((a * p[Order::A] + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_difference
               :    template<class ColorT, class Order> struct comp_op_rgba_difference
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_scale = color_type::base_scale,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type dr = p[Order::R];
               :                calc_type dg = p[Order::G];
               :                calc_type db = p[Order::B];
               :                calc_type da = p[Order::A];
               :                p[Order::R] = (value_type)(sr + dr - ((2 * sd_min(sr*da, dr*sa) + base_mask) >> base_shift));
               :                p[Order::G] = (value_type)(sg + dg - ((2 * sd_min(sg*da, dg*sa) + base_mask) >> base_shift));
               :                p[Order::B] = (value_type)(sb + db - ((2 * sd_min(sb*da, db*sa) + base_mask) >> base_shift));
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_exclusion
               :    template<class ColorT, class Order> struct comp_op_rgba_exclusion
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type d1a = base_mask - p[Order::A];
               :                calc_type s1a = base_mask - sa;
               :                calc_type dr = p[Order::R];
               :                calc_type dg = p[Order::G];
               :                calc_type db = p[Order::B];
               :                calc_type da = p[Order::A];
               :                p[Order::R] = (value_type)((sr*da + dr*sa - 2*sr*dr + sr*d1a + dr*s1a + base_mask) >> base_shift);
               :                p[Order::G] = (value_type)((sg*da + dg*sa - 2*sg*dg + sg*d1a + dg*s1a + base_mask) >> base_shift);
               :                p[Order::B] = (value_type)((sb*da + db*sa - 2*sb*db + sb*d1a + db*s1a + base_mask) >> base_shift);
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_contrast
               :    template<class ColorT, class Order> struct comp_op_rgba_contrast
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            long_type dr = p[Order::R];
               :            long_type dg = p[Order::G];
               :            long_type db = p[Order::B];
               :            int       da = p[Order::A];
               :            long_type d2a = da >> 1;
               :            unsigned s2a = sa >> 1;
               :
               :            int r = (int)((((dr - d2a) * int((sr - s2a)*2 + base_mask)) >> base_shift) + d2a); 
               :            int g = (int)((((dg - d2a) * int((sg - s2a)*2 + base_mask)) >> base_shift) + d2a); 
               :            int b = (int)((((db - d2a) * int((sb - s2a)*2 + base_mask)) >> base_shift) + d2a); 
               :
               :            r = (r < 0) ? 0 : r;
               :            g = (g < 0) ? 0 : g;
               :            b = (b < 0) ? 0 : b;
               :
               :            p[Order::R] = (value_type)((r > da) ? da : r);
               :            p[Order::G] = (value_type)((g > da) ? da : g);
               :            p[Order::B] = (value_type)((b > da) ? da : b);
               :        }
               :    };
               :
               :    //=====================================================comp_op_rgba_invert
               :    template<class ColorT, class Order> struct comp_op_rgba_invert
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = (Da - Dca) * Sa + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            sa = (sa * cover + 255) >> 8;
               :            if(sa)
               :            {
               :                calc_type da = p[Order::A];
               :                calc_type dr = ((da - p[Order::R]) * sa + base_mask) >> base_shift;
               :                calc_type dg = ((da - p[Order::G]) * sa + base_mask) >> base_shift;
               :                calc_type db = ((da - p[Order::B]) * sa + base_mask) >> base_shift;
               :                calc_type s1a = base_mask - sa;
               :                p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
               :                p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
               :                p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :    //=================================================comp_op_rgba_invert_rgb
               :    template<class ColorT, class Order> struct comp_op_rgba_invert_rgb
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        { 
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        // Dca' = (Da - Dca) * Sca + Dca.(1 - Sa)
               :        // Da'  = Sa + Da - Sa.Da 
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned sr, unsigned sg, unsigned sb, 
               :                                         unsigned sa, unsigned cover)
               :        {
               :            if(cover < 255)
               :            {
               :                sr = (sr * cover + 255) >> 8;
               :                sg = (sg * cover + 255) >> 8;
               :                sb = (sb * cover + 255) >> 8;
               :                sa = (sa * cover + 255) >> 8;
               :            }
               :            if(sa)
               :            {
               :                calc_type da = p[Order::A];
               :                calc_type dr = ((da - p[Order::R]) * sr + base_mask) >> base_shift;
               :                calc_type dg = ((da - p[Order::G]) * sg + base_mask) >> base_shift;
               :                calc_type db = ((da - p[Order::B]) * sb + base_mask) >> base_shift;
               :                calc_type s1a = base_mask - sa;
               :                p[Order::R] = (value_type)(dr + ((p[Order::R] * s1a + base_mask) >> base_shift));
               :                p[Order::G] = (value_type)(dg + ((p[Order::G] * s1a + base_mask) >> base_shift));
               :                p[Order::B] = (value_type)(db + ((p[Order::B] * s1a + base_mask) >> base_shift));
               :                p[Order::A] = (value_type)(sa + da - ((sa * da + base_mask) >> base_shift));
               :            }
               :        }
               :    };
               :
               :
               :
               :
               :
               :    //======================================================comp_op_table_rgba
               :    template<class ColorT, class Order> struct comp_op_table_rgba
               :    {
               :        typedef typename ColorT::value_type value_type;
               :        typedef void (*comp_op_func_type)(value_type* p, 
               :                                          unsigned cr, 
               :                                          unsigned cg, 
               :                                          unsigned cb,
               :                                          unsigned ca,
               :                                          unsigned cover);
               :        static comp_op_func_type g_comp_op_func[];
               :    };
               :
               :    //==========================================================g_comp_op_func
               :    template<class ColorT, class Order> 
               :    typename comp_op_table_rgba<ColorT, Order>::comp_op_func_type
               :    comp_op_table_rgba<ColorT, Order>::g_comp_op_func[] = 
               :    {
               :        comp_op_rgba_clear      <ColorT,Order>::blend_pix,
               :        comp_op_rgba_src        <ColorT,Order>::blend_pix,
               :        comp_op_rgba_dst        <ColorT,Order>::blend_pix,
               :        comp_op_rgba_src_over   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_dst_over   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_src_in     <ColorT,Order>::blend_pix,
               :        comp_op_rgba_dst_in     <ColorT,Order>::blend_pix,
               :        comp_op_rgba_src_out    <ColorT,Order>::blend_pix,
               :        comp_op_rgba_dst_out    <ColorT,Order>::blend_pix,
               :        comp_op_rgba_src_atop   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_dst_atop   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_xor        <ColorT,Order>::blend_pix,
               :        comp_op_rgba_plus       <ColorT,Order>::blend_pix,
               :        comp_op_rgba_minus      <ColorT,Order>::blend_pix,
               :        comp_op_rgba_multiply   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_screen     <ColorT,Order>::blend_pix,
               :        comp_op_rgba_overlay    <ColorT,Order>::blend_pix,
               :        comp_op_rgba_darken     <ColorT,Order>::blend_pix,
               :        comp_op_rgba_lighten    <ColorT,Order>::blend_pix,
               :        comp_op_rgba_color_dodge<ColorT,Order>::blend_pix,
               :        comp_op_rgba_color_burn <ColorT,Order>::blend_pix,
               :        comp_op_rgba_hard_light <ColorT,Order>::blend_pix,
               :        comp_op_rgba_soft_light <ColorT,Order>::blend_pix,
               :        comp_op_rgba_difference <ColorT,Order>::blend_pix,
               :        comp_op_rgba_exclusion  <ColorT,Order>::blend_pix,
               :        comp_op_rgba_contrast   <ColorT,Order>::blend_pix,
               :        comp_op_rgba_invert     <ColorT,Order>::blend_pix,
               :        comp_op_rgba_invert_rgb <ColorT,Order>::blend_pix,
               :        0
               :    };
               :
               :
               :    //==============================================================comp_op_e
               :    enum comp_op_e
               :    {
               :        comp_op_clear,         //----comp_op_clear
               :        comp_op_src,           //----comp_op_src
               :        comp_op_dst,           //----comp_op_dst
               :        comp_op_src_over,      //----comp_op_src_over
               :        comp_op_dst_over,      //----comp_op_dst_over
               :        comp_op_src_in,        //----comp_op_src_in
               :        comp_op_dst_in,        //----comp_op_dst_in
               :        comp_op_src_out,       //----comp_op_src_out
               :        comp_op_dst_out,       //----comp_op_dst_out
               :        comp_op_src_atop,      //----comp_op_src_atop
               :        comp_op_dst_atop,      //----comp_op_dst_atop
               :        comp_op_xor,           //----comp_op_xor
               :        comp_op_plus,          //----comp_op_plus
               :        comp_op_minus,         //----comp_op_minus
               :        comp_op_multiply,      //----comp_op_multiply
               :        comp_op_screen,        //----comp_op_screen
               :        comp_op_overlay,       //----comp_op_overlay
               :        comp_op_darken,        //----comp_op_darken
               :        comp_op_lighten,       //----comp_op_lighten
               :        comp_op_color_dodge,   //----comp_op_color_dodge
               :        comp_op_color_burn,    //----comp_op_color_burn
               :        comp_op_hard_light,    //----comp_op_hard_light
               :        comp_op_soft_light,    //----comp_op_soft_light
               :        comp_op_difference,    //----comp_op_difference
               :        comp_op_exclusion,     //----comp_op_exclusion
               :        comp_op_contrast,      //----comp_op_contrast
               :        comp_op_invert,        //----comp_op_invert
               :        comp_op_invert_rgb,    //----comp_op_invert_rgb
               :
               :        end_of_comp_op_e
               :    };
               :
               :
               :
               :
               :
               :
               :
               :    //====================================================comp_op_adaptor_rgba
               :    template<class ColorT, class Order> struct comp_op_adaptor_rgba
               :    {
               :        typedef Order  order_type;
               :        typedef ColorT color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
               :                (p, (cr * ca + base_mask) >> base_shift, 
               :                    (cg * ca + base_mask) >> base_shift,
               :                    (cb * ca + base_mask) >> base_shift,
               :                     ca, cover);
               :        }
               :    };
               :
               :    //=========================================comp_op_adaptor_clip_to_dst_rgba
               :    template<class ColorT, class Order> struct comp_op_adaptor_clip_to_dst_rgba
               :    {
               :        typedef Order  order_type;
               :        typedef ColorT color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            cr = (cr * ca + base_mask) >> base_shift;
               :            cg = (cg * ca + base_mask) >> base_shift;
               :            cb = (cb * ca + base_mask) >> base_shift;
               :            unsigned da = p[Order::A];
               :            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
               :                (p, (cr * da + base_mask) >> base_shift, 
               :                    (cg * da + base_mask) >> base_shift, 
               :                    (cb * da + base_mask) >> base_shift, 
               :                    (ca * da + base_mask) >> base_shift, 
               :                    cover);
               :        }
               :    };
               :
               :    //================================================comp_op_adaptor_rgba_pre
               :    template<class ColorT, class Order> struct comp_op_adaptor_rgba_pre
               :    {
               :        typedef Order  order_type;
               :        typedef ColorT color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op](p, cr, cg, cb, ca, cover);
               :        }
               :    };
               :
               :    //=====================================comp_op_adaptor_clip_to_dst_rgba_pre
               :    template<class ColorT, class Order> struct comp_op_adaptor_clip_to_dst_rgba_pre
               :    {
               :        typedef Order  order_type;
               :        typedef ColorT color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            unsigned da = p[Order::A];
               :            comp_op_table_rgba<ColorT, Order>::g_comp_op_func[op]
               :                (p, (cr * da + base_mask) >> base_shift, 
               :                    (cg * da + base_mask) >> base_shift, 
               :                    (cb * da + base_mask) >> base_shift, 
               :                    (ca * da + base_mask) >> base_shift, 
               :                    cover);
               :        }
               :    };
               :
               :    //=======================================================comp_adaptor_rgba
               :    template<class BlenderPre> struct comp_adaptor_rgba
               :    {
               :        typedef typename BlenderPre::order_type order_type;
               :        typedef typename BlenderPre::color_type color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            BlenderPre::blend_pix(p, 
               :                                  (cr * ca + base_mask) >> base_shift, 
               :                                  (cg * ca + base_mask) >> base_shift,
               :                                  (cb * ca + base_mask) >> base_shift,
               :                                  ca, cover);
               :        }
               :    };
               :
               :    //==========================================comp_adaptor_clip_to_dst_rgba
               :    template<class BlenderPre> struct comp_adaptor_clip_to_dst_rgba
               :    {
               :        typedef typename BlenderPre::order_type order_type;
               :        typedef typename BlenderPre::color_type color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            cr = (cr * ca + base_mask) >> base_shift;
               :            cg = (cg * ca + base_mask) >> base_shift;
               :            cb = (cb * ca + base_mask) >> base_shift;
               :            unsigned da = p[order_type::A];
               :            BlenderPre::blend_pix(p, 
               :                                  (cr * da + base_mask) >> base_shift, 
               :                                  (cg * da + base_mask) >> base_shift, 
               :                                  (cb * da + base_mask) >> base_shift, 
               :                                  (ca * da + base_mask) >> base_shift, 
               :                                  cover);
               :        }
               :    };
               :
               :    //======================================comp_adaptor_clip_to_dst_rgba_pre
               :    template<class BlenderPre> struct comp_adaptor_clip_to_dst_rgba_pre
               :    {
               :        typedef typename BlenderPre::order_type order_type;
               :        typedef typename BlenderPre::color_type color_type;
               :        typedef typename color_type::value_type value_type;
               :        enum base_scale_e
               :        {  
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask 
               :        };
               :
               :        static AGG_INLINE void blend_pix(unsigned op, value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned ca,
               :                                         unsigned cover)
               :        {
               :            unsigned da = p[order_type::A];
               :            BlenderPre::blend_pix(p, 
               :                                  (cr * da + base_mask) >> base_shift, 
               :                                  (cg * da + base_mask) >> base_shift, 
               :                                  (cb * da + base_mask) >> base_shift, 
               :                                  (ca * da + base_mask) >> base_shift, 
               :                                  cover);
               :        }
               :    };
               :
               :
               :
               :
               :
               :
               :    //===============================================copy_or_blend_rgba_wrapper
               :    template<class Blender> struct copy_or_blend_rgba_wrapper
               :    {
               :        typedef typename Blender::color_type color_type;
               :        typedef typename Blender::order_type order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_scale = color_type::base_scale,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void copy_or_blend_pix(value_type* p, 
               :                                                 unsigned cr, unsigned cg, unsigned cb,
               :                                                 unsigned alpha)
               :        {
   689  0.2904 :            if(alpha)
               :            {
   454  0.1914 :                if(alpha == base_mask)
               :                {
   499  0.2103 :                    p[order_type::R] = cr;
   237  0.0999 :                    p[order_type::G] = cg;
   847  0.3570 :                    p[order_type::B] = cb;
   147  0.0620 :                    p[order_type::A] = base_mask;
               :                }
               :                else
               :                {
               :                    Blender::blend_pix(p, cr, cg, cb, alpha);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void copy_or_blend_pix(value_type* p, 
               :                                                 unsigned cr, unsigned cg, unsigned cb,
               :                                                 unsigned alpha,
               :                                                 unsigned cover)
               :        {
   629  0.2651 :            if(cover == 255)
               :            {
               :                copy_or_blend_pix(p, cr, cg, cb, alpha);
               :            }
               :            else
               :            {
    91  0.0384 :                if(alpha)
               :                {
    37  0.0156 :                    alpha = (alpha * (cover + 1)) >> 8;
               :                    if(alpha == base_mask)
               :                    {
               :                        p[order_type::R] = cr;
               :                        p[order_type::G] = cg;
               :                        p[order_type::B] = cb;
               :                        p[order_type::A] = base_mask;
               :                    }
               :                    else
               :                    {
               :                        Blender::blend_pix(p, cr, cg, cb, alpha, cover);
               :                    }
               :                }
               :            }
               :        }
               :    };
               :
               :
               :
               :
               :
               :    
               :    //=================================================pixfmt_alpha_blend_rgba
               :    template<class Blender, class RenBuf, class PixelT = int32u> 
               :    class pixfmt_alpha_blend_rgba
               :    {
               :    public:
               :        typedef RenBuf   rbuf_type;
               :        typedef typename rbuf_type::row_data row_data;
               :        typedef PixelT   pixel_type;
               :        typedef Blender  blender_type;
               :        typedef typename blender_type::color_type color_type;
               :        typedef typename blender_type::order_type order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        typedef copy_or_blend_rgba_wrapper<blender_type> cob_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_scale = color_type::base_scale,
               :            base_mask  = color_type::base_mask,
               :            pix_width  = sizeof(pixel_type)
               :        };
               :
               :        //--------------------------------------------------------------------
               :        pixfmt_alpha_blend_rgba() : m_rbuf(0) {}
               :        explicit pixfmt_alpha_blend_rgba(rbuf_type& rb) : m_rbuf(&rb) {}
               :        void attach(rbuf_type& rb) { m_rbuf = &rb; }
               :
               :        //--------------------------------------------------------------------
               :        template<class PixFmt>
               :        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
               :        {
               :            rect_i r(x1, y1, x2, y2);
               :            if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
               :            {
               :                int stride = pixf.stride();
               :                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
               :                               (r.x2 - r.x1) + 1,
               :                               (r.y2 - r.y1) + 1,
               :                               stride);
               :                return true;
               :            }
               :            return false;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
    13  0.0055 :        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
               :        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
    81  0.0341 :        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
               :        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE int8u* pix_ptr(int x, int y)
               :        {
               :            return m_rbuf->row_ptr(y) + x * pix_width;
               :        }
               :
               :        AGG_INLINE const int8u* pix_ptr(int x, int y) const
               :        {
     8  0.0034 :            return m_rbuf->row_ptr(y) + x * pix_width;
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
               :        {
               :            ((value_type*)p)[order_type::R] = c.r;
               :            ((value_type*)p)[order_type::G] = c.g;
               :            ((value_type*)p)[order_type::B] = c.b;
               :            ((value_type*)p)[order_type::A] = c.a;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE color_type pixel(int x, int y) const
               :        {
               :            const value_type* p = (const value_type*)m_rbuf->row_ptr(y);
               :            if(p)
               :            {
               :                p += x << 2;
               :                return color_type(p[order_type::R], 
               :                                  p[order_type::G], 
               :                                  p[order_type::B], 
               :                                  p[order_type::A]);
               :            }
               :            return color_type::no_color();
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2);
               :            p[order_type::R] = c.r;
               :            p[order_type::G] = c.g;
               :            p[order_type::B] = c.b;
               :            p[order_type::A] = c.a;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
               :        {
               :            cob_type::copy_or_blend_pix(
               :                (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2), 
               :                c.r, c.g, c.b, c.a, 
               :                cover);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_hline(int x, int y, 
               :                                   unsigned len, 
               :                                   const color_type& c)
               :        {
    17  0.0072 :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            pixel_type v;
    27  0.0114 :            ((value_type*)&v)[order_type::R] = c.r;
    14  0.0059 :            ((value_type*)&v)[order_type::G] = c.g;
     3  0.0013 :            ((value_type*)&v)[order_type::B] = c.b;
     5  0.0021 :            ((value_type*)&v)[order_type::A] = c.a;
   483  0.2036 :            do
               :            {
   508  0.2141 :                *(pixel_type*)p = v;
   130  0.0548 :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_vline(int x, int y,
               :                                   unsigned len, 
               :                                   const color_type& c)
               :        {
               :            pixel_type v;
               :            ((value_type*)&v)[order_type::R] = c.r;
               :            ((value_type*)&v)[order_type::G] = c.g;
               :            ((value_type*)&v)[order_type::B] = c.b;
               :            ((value_type*)&v)[order_type::A] = c.a;
               :            do
               :            {
               :                value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                *(pixel_type*)p = v;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_hline(int x, int y,
               :                         unsigned len, 
               :                         const color_type& c,
               :                         int8u cover)
               :        {
               :            if (c.a)
               :            {
               :                value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
               :                if(alpha == base_mask)
               :                {
               :                    pixel_type v;
    16  0.0067 :                    ((value_type*)&v)[order_type::R] = c.r;
               :                    ((value_type*)&v)[order_type::G] = c.g;
               :                    ((value_type*)&v)[order_type::B] = c.b;
               :                    ((value_type*)&v)[order_type::A] = c.a;
               :                    do
               :                    {
               :                        *(pixel_type*)p = v;
               :                        p += 4;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    if(cover == 255)
               :                    {
               :                        do
               :                        {
               :                            blender_type::blend_pix(p, c.r, c.g, c.b, alpha);
               :                            p += 4;
               :                        }
               :                        while(--len);
               :                    }
               :                    else
               :                    {
               :                        do
               :                        {
               :                            blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
               :                            p += 4;
               :                        }
               :                        while(--len);
               :                    }
               :                }
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_vline(int x, int y,
               :                         unsigned len, 
               :                         const color_type& c,
               :                         int8u cover)
               :        {
               :            if (c.a)
               :            {
               :                value_type* p;
               :                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
               :                if(alpha == base_mask)
               :                {
               :                    pixel_type v;
               :                    ((value_type*)&v)[order_type::R] = c.r;
               :                    ((value_type*)&v)[order_type::G] = c.g;
               :                    ((value_type*)&v)[order_type::B] = c.b;
               :                    ((value_type*)&v)[order_type::A] = c.a;
               :                    do
               :                    {
               :                        p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                        *(pixel_type*)p = v;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    if(cover == 255)
               :                    {
               :                        do
               :                        {
               :                            p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                            blender_type::blend_pix(p, c.r, c.g, c.b, alpha);
               :                        }
               :                        while(--len);
               :                    }
               :                    else
               :                    {
               :                        do
               :                        {
               :                            p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                            blender_type::blend_pix(p, c.r, c.g, c.b, alpha, cover);
               :                        }
               :                        while(--len);
               :                    }
               :                }
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_hspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type& c,
               :                               const int8u* covers)
               :        {
    40  0.0169 :            if (c.a)
               :            {
   165  0.0696 :                value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
   142  0.0599 :                do 
               :                {
   143  0.0603 :                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
   133  0.0561 :                    if(alpha == base_mask)
               :                    {
    18  0.0076 :                        p[order_type::R] = c.r;
    14  0.0059 :                        p[order_type::G] = c.g;
    17  0.0072 :                        p[order_type::B] = c.b;
     1 4.2e-04 :                        p[order_type::A] = base_mask;
               :                    }
               :                    else
               :                    {
    81  0.0341 :                        blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
               :                    }
   118  0.0497 :                    p += 4;
               :                    ++covers;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_vspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type& c,
               :                               const int8u* covers)
               :        {
               :            if (c.a)
               :            {
               :                do 
               :                {
               :                    value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
               :                    if(alpha == base_mask)
               :                    {
               :                        p[order_type::R] = c.r;
               :                        p[order_type::G] = c.g;
               :                        p[order_type::B] = c.b;
               :                        p[order_type::A] = base_mask;
               :                    }
               :                    else
               :                    {
               :                        blender_type::blend_pix(p, c.r, c.g, c.b, alpha, *covers);
               :                    }
               :                    ++covers;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_hspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            do 
               :            {
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                p[order_type::A] = colors->a;
               :                ++colors;
               :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_vspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :            do 
               :            {
               :                value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                p[order_type::A] = colors->a;
               :                ++colors;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_hspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type* colors,
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
   105  0.0443 :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
     4  0.0017 :            if(covers)
               :            {
   714  0.3010 :                do 
               :                {
  3594  1.5150 :                    cob_type::copy_or_blend_pix(p, 
               :                                                colors->r, 
               :                                                colors->g, 
               :                                                colors->b, 
               :                                                colors->a, 
               :                                                *covers++);
   331  0.1395 :                    p += 4;
               :                    ++colors;
               :                }
               :                while(--len);
               :            }
               :            else
               :            {
     9  0.0038 :                if(cover == 255)
               :                {
    97  0.0409 :                    do 
               :                    {
   250  0.1054 :                        cob_type::copy_or_blend_pix(p, 
               :                                                    colors->r, 
               :                                                    colors->g, 
               :                                                    colors->b, 
               :                                                    colors->a);
    50  0.0211 :                        p += 4;
    13  0.0055 :                        ++colors;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        cob_type::copy_or_blend_pix(p, 
               :                                                    colors->r, 
               :                                                    colors->g, 
               :                                                    colors->b, 
               :                                                    colors->a, 
               :                                                    cover);
               :                        p += 4;
               :                        ++colors;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_vspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type* colors,
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
               :            value_type* p;
               :            if(covers)
               :            {
               :                do 
               :                {
               :                    p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                    cob_type::copy_or_blend_pix(p, 
               :                                                colors->r, 
               :                                                colors->g, 
               :                                                colors->b, 
               :                                                colors->a,
               :                                                *covers++);
               :                    ++colors;
               :                }
               :                while(--len);
               :            }
               :            else
               :            {
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                        cob_type::copy_or_blend_pix(p, 
               :                                                    colors->r, 
               :                                                    colors->g, 
               :                                                    colors->b, 
               :                                                    colors->a);
               :                        ++colors;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                        cob_type::copy_or_blend_pix(p, 
               :                                                    colors->r, 
               :                                                    colors->g, 
               :                                                    colors->b, 
               :                                                    colors->a, 
               :                                                    cover);
               :                        ++colors;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class Function> void for_each_pixel(Function f)
               :        {
               :            unsigned y;
               :            for(y = 0; y < height(); ++y)
               :            {
               :                row_data r = m_rbuf->row(y);
               :                if(r.ptr)
               :                {
               :                    unsigned len = r.x2 - r.x1 + 1;
               :                    value_type* p = 
               :                        (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
               :                    do
               :                    {
               :                        f(p);
               :                        p += 4;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void premultiply()
               :        {
               :            for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void demultiply()
               :        {
               :            for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class RenBuf2> void copy_from(const RenBuf2& from, 
               :                                               int xdst, int ydst,
               :                                               int xsrc, int ysrc,
               :                                               unsigned len)
               :        {
               :            const int8u* p = from.row_ptr(ysrc);
               :            if(p)
               :            {
               :                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
               :                        p + xsrc * pix_width, 
               :                        len * pix_width);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from(const SrcPixelFormatRenderer& from, 
               :                        int xdst, int ydst,
               :                        int xsrc, int ysrc,
               :                        unsigned len,
               :                        int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::order_type src_order;
               :            const value_type* psrc = (value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                psrc += xsrc << 2;
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :                int incp = 4;
               :                if(xdst > xsrc)
               :                {
               :                    psrc += (len-1) << 2;
               :                    pdst += (len-1) << 2;
               :                    incp = -4;
               :                }
               :
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        cob_type::copy_or_blend_pix(pdst, 
               :                                                    psrc[src_order::R],
               :                                                    psrc[src_order::G],
               :                                                    psrc[src_order::B],
               :                                                    psrc[src_order::A]);
               :                        psrc += incp;
               :                        pdst += incp;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        cob_type::copy_or_blend_pix(pdst, 
               :                                                    psrc[src_order::R],
               :                                                    psrc[src_order::G],
               :                                                    psrc[src_order::B],
               :                                                    psrc[src_order::A],
               :                                                    cover);
               :                        psrc += incp;
               :                        pdst += incp;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_color(const SrcPixelFormatRenderer& from, 
               :                              const color_type& color,
               :                              int xdst, int ydst,
               :                              int xsrc, int ysrc,
               :                              unsigned len,
               :                              int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :                do 
               :                {
               :                    cob_type::copy_or_blend_pix(pdst, 
               :                                                color.r, color.g, color.b, color.a,
               :                                                (*psrc * cover + base_mask) >> base_shift);
               :                    ++psrc;
               :                    pdst += 4;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_lut(const SrcPixelFormatRenderer& from, 
               :                            const color_type* color_lut,
               :                            int xdst, int ydst,
               :                            int xsrc, int ysrc,
               :                            unsigned len,
               :                            int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        const color_type& color = color_lut[*psrc];
               :                        cob_type::copy_or_blend_pix(pdst, 
               :                                                    color.r, color.g, color.b, color.a);
               :                        ++psrc;
               :                        pdst += 4;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        const color_type& color = color_lut[*psrc];
               :                        cob_type::copy_or_blend_pix(pdst, 
               :                                                    color.r, color.g, color.b, color.a,
               :                                                    cover);
               :                        ++psrc;
               :                        pdst += 4;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :    private:
               :        rbuf_type* m_rbuf;
               :    };
               :
               :
               :
               :
               :    //================================================pixfmt_custom_blend_rgba
               :    template<class Blender, class RenBuf> class pixfmt_custom_blend_rgba
               :    {
               :    public:
               :        typedef RenBuf   rbuf_type;
               :        typedef typename rbuf_type::row_data row_data;
               :        typedef Blender  blender_type;
               :        typedef typename blender_type::color_type color_type;
               :        typedef typename blender_type::order_type order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_scale = color_type::base_scale,
               :            base_mask  = color_type::base_mask,
               :            pix_width  = sizeof(value_type) * 4 
               :        };
               :
               :
               :        //--------------------------------------------------------------------
               :        pixfmt_custom_blend_rgba() : m_rbuf(0), m_comp_op(3) {}
               :        explicit pixfmt_custom_blend_rgba(rbuf_type& rb, unsigned comp_op=3) : 
               :            m_rbuf(&rb),
               :            m_comp_op(comp_op)
               :        {}
               :        void attach(rbuf_type& rb) { m_rbuf = &rb; }
               :
               :        //--------------------------------------------------------------------
               :        template<class PixFmt>
               :        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
               :        {
               :            rect_i r(x1, y1, x2, y2);
               :            if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
               :            {
               :                int stride = pixf.stride();
               :                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
               :                               (r.x2 - r.x1) + 1,
               :                               (r.y2 - r.y1) + 1,
               :                               stride);
               :                return true;
               :            }
               :            return false;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
               :        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
               :        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
               :        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
               :        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE int8u* pix_ptr(int x, int y)
               :        {
               :            return m_rbuf->row_ptr(y) + x * pix_width;
               :        }
               :
               :        AGG_INLINE const int8u* pix_ptr(int x, int y) const
               :        {
               :            return m_rbuf->row_ptr(y) + x * pix_width;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void comp_op(unsigned op) { m_comp_op = op; }
               :        unsigned comp_op() const  { return m_comp_op; }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
               :        {
               :            ((value_type*)p)[order_type::R] = c.r;
               :            ((value_type*)p)[order_type::G] = c.g;
               :            ((value_type*)p)[order_type::B] = c.b;
               :            ((value_type*)p)[order_type::A] = c.a;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        color_type pixel(int x, int y) const
               :        {
               :            const value_type* p = (value_type*)m_rbuf->row_ptr(y) + (x << 2);
               :            return color_type(p[order_type::R], 
               :                              p[order_type::G], 
               :                              p[order_type::B], 
               :                              p[order_type::A]);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void copy_pixel(int x, int y, const color_type& c)
               :        {
               :            blender_type::blend_pix(
               :                m_comp_op, 
               :                (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2), 
               :                c.r, c.g, c.b, c.a, 255);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_pixel(int x, int y, const color_type& c, int8u cover)
               :        {
               :            blender_type::blend_pix(
               :                m_comp_op, 
               :                (value_type*)m_rbuf->row_ptr(x, y, 1) + (x << 2),
               :                c.r, c.g, c.b, c.a, 
               :                cover);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void copy_hline(int x, int y, unsigned len, const color_type& c)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);;
               :            do
               :            {
               :                blender_type::blend_pix(m_comp_op, p, c.r, c.g, c.b, c.a, 255);
               :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void copy_vline(int x, int y, unsigned len, const color_type& c)
               :        {
               :            do
               :            {
               :                blender_type::blend_pix(
               :                    m_comp_op, 
               :                    (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2),
               :                    c.r, c.g, c.b, c.a, 255);
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_hline(int x, int y, unsigned len, 
               :                         const color_type& c, int8u cover)
               :        {
               :
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            do
               :            {
               :                blender_type::blend_pix(m_comp_op, p, c.r, c.g, c.b, c.a, cover);
               :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_vline(int x, int y, unsigned len, 
               :                         const color_type& c, int8u cover)
               :        {
               :
               :            do
               :            {
               :                blender_type::blend_pix(
               :                    m_comp_op, 
               :                    (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2), 
               :                    c.r, c.g, c.b, c.a, 
               :                    cover);
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_hspan(int x, int y, unsigned len, 
               :                               const color_type& c, const int8u* covers)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            do 
               :            {
               :                blender_type::blend_pix(m_comp_op, 
               :                                        p, c.r, c.g, c.b, c.a, 
               :                                        *covers++);
               :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_vspan(int x, int y, unsigned len, 
               :                               const color_type& c, const int8u* covers)
               :        {
               :            do 
               :            {
               :                blender_type::blend_pix(
               :                    m_comp_op, 
               :                    (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2), 
               :                    c.r, c.g, c.b, c.a, 
               :                    *covers++);
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_hspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            do 
               :            {
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                p[order_type::A] = colors->a;
               :                ++colors;
               :                p += 4;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_vspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :            do 
               :            {
               :                value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2);
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                p[order_type::A] = colors->a;
               :                ++colors;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_hspan(int x, int y, unsigned len, 
               :                               const color_type* colors, 
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + (x << 2);
               :            do 
               :            {
               :                blender_type::blend_pix(m_comp_op, 
               :                                        p, 
               :                                        colors->r, 
               :                                        colors->g, 
               :                                        colors->b, 
               :                                        colors->a, 
               :                                        covers ? *covers++ : cover);
               :                p += 4;
               :                ++colors;
               :            }
               :            while(--len);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_vspan(int x, int y, unsigned len, 
               :                               const color_type* colors, 
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
               :            do 
               :            {
               :                blender_type::blend_pix(
               :                    m_comp_op, 
               :                    (value_type*)m_rbuf->row_ptr(x, y++, 1) + (x << 2), 
               :                    colors->r,
               :                    colors->g,
               :                    colors->b,
               :                    colors->a,
               :                    covers ? *covers++ : cover);
               :                ++colors;
               :            }
               :            while(--len);
               :
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class Function> void for_each_pixel(Function f)
               :        {
               :            unsigned y;
               :            for(y = 0; y < height(); ++y)
               :            {
               :                row_data r = m_rbuf->row(y);
               :                if(r.ptr)
               :                {
               :                    unsigned len = r.x2 - r.x1 + 1;
               :                    value_type* p = 
               :                        (value_type*)m_rbuf->row_ptr(r.x1, y, len) + (r.x1 << 2);
               :                    do
               :                    {
               :                        f(p);
               :                        p += 4;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void premultiply()
               :        {
               :            for_each_pixel(multiplier_rgba<color_type, order_type>::premultiply);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void demultiply()
               :        {
               :            for_each_pixel(multiplier_rgba<color_type, order_type>::demultiply);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_dir_rgba<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_inv_rgba<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class RenBuf2> void copy_from(const RenBuf2& from, 
               :                                               int xdst, int ydst,
               :                                               int xsrc, int ysrc,
               :                                               unsigned len)
               :        {
               :            const int8u* p = from.row_ptr(ysrc);
               :            if(p)
               :            {
               :                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
               :                        p + xsrc * pix_width, 
               :                        len * pix_width);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer> 
               :        void blend_from(const SrcPixelFormatRenderer& from, 
               :                        int xdst, int ydst,
               :                        int xsrc, int ysrc,
               :                        unsigned len,
               :                        int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::order_type src_order;
               :            const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                psrc += xsrc << 2;
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :
               :                int incp = 4;
               :                if(xdst > xsrc)
               :                {
               :                    psrc += (len-1) << 2;
               :                    pdst += (len-1) << 2;
               :                    incp = -4;
               :                }
               :
               :                do 
               :                {
               :                    blender_type::blend_pix(m_comp_op, 
               :                                            pdst, 
               :                                            psrc[src_order::R],
               :                                            psrc[src_order::G],
               :                                            psrc[src_order::B],
               :                                            psrc[src_order::A],
               :                                            cover);
               :                    psrc += incp;
               :                    pdst += incp;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_color(const SrcPixelFormatRenderer& from, 
               :                              const color_type& color,
               :                              int xdst, int ydst,
               :                              int xsrc, int ysrc,
               :                              unsigned len,
               :                              int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :                do 
               :                {
               :                    blender_type::blend_pix(m_comp_op,
               :                                            pdst, 
               :                                            color.r, color.g, color.b, color.a,
               :                                            (*psrc * cover + base_mask) >> base_shift);
               :                    ++psrc;
               :                    pdst += 4;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_lut(const SrcPixelFormatRenderer& from, 
               :                            const color_type* color_lut,
               :                            int xdst, int ydst,
               :                            int xsrc, int ysrc,
               :                            unsigned len,
               :                            int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + (xdst << 2);
               :                do 
               :                {
               :                    const color_type& color = color_lut[*psrc];
               :                    blender_type::blend_pix(m_comp_op,
               :                                            pdst, 
               :                                            color.r, color.g, color.b, color.a,
               :                                            cover);
               :                    ++psrc;
               :                    pdst += 4;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :    private:
               :        rbuf_type* m_rbuf;
               :        unsigned m_comp_op;
               :    };
               :
               :
               :
               :
               :    //-----------------------------------------------------------------------
               :    typedef blender_rgba<rgba8, order_rgba> blender_rgba32; //----blender_rgba32
               :    typedef blender_rgba<rgba8, order_argb> blender_argb32; //----blender_argb32
               :    typedef blender_rgba<rgba8, order_abgr> blender_abgr32; //----blender_abgr32
               :    typedef blender_rgba<rgba8, order_bgra> blender_bgra32; //----blender_bgra32
               :
               :    typedef blender_rgba_pre<rgba8, order_rgba> blender_rgba32_pre; //----blender_rgba32_pre
               :    typedef blender_rgba_pre<rgba8, order_argb> blender_argb32_pre; //----blender_argb32_pre
               :    typedef blender_rgba_pre<rgba8, order_abgr> blender_abgr32_pre; //----blender_abgr32_pre
               :    typedef blender_rgba_pre<rgba8, order_bgra> blender_bgra32_pre; //----blender_bgra32_pre
               :
               :    typedef blender_rgba_plain<rgba8, order_rgba> blender_rgba32_plain; //----blender_rgba32_plain
               :    typedef blender_rgba_plain<rgba8, order_argb> blender_argb32_plain; //----blender_argb32_plain
               :    typedef blender_rgba_plain<rgba8, order_abgr> blender_abgr32_plain; //----blender_abgr32_plain
               :    typedef blender_rgba_plain<rgba8, order_bgra> blender_bgra32_plain; //----blender_bgra32_plain
               :
               :    typedef blender_rgba<rgba16, order_rgba> blender_rgba64; //----blender_rgba64
               :    typedef blender_rgba<rgba16, order_argb> blender_argb64; //----blender_argb64
               :    typedef blender_rgba<rgba16, order_abgr> blender_abgr64; //----blender_abgr64
               :    typedef blender_rgba<rgba16, order_bgra> blender_bgra64; //----blender_bgra64
               :
               :    typedef blender_rgba_pre<rgba16, order_rgba> blender_rgba64_pre; //----blender_rgba64_pre
               :    typedef blender_rgba_pre<rgba16, order_argb> blender_argb64_pre; //----blender_argb64_pre
               :    typedef blender_rgba_pre<rgba16, order_abgr> blender_abgr64_pre; //----blender_abgr64_pre
               :    typedef blender_rgba_pre<rgba16, order_bgra> blender_bgra64_pre; //----blender_bgra64_pre
               :
               :
               :    //-----------------------------------------------------------------------
               :    typedef int32u pixel32_type;
               :    typedef pixfmt_alpha_blend_rgba<blender_rgba32, rendering_buffer, pixel32_type> pixfmt_rgba32; //----pixfmt_rgba32
               :    typedef pixfmt_alpha_blend_rgba<blender_argb32, rendering_buffer, pixel32_type> pixfmt_argb32; //----pixfmt_argb32
               :    typedef pixfmt_alpha_blend_rgba<blender_abgr32, rendering_buffer, pixel32_type> pixfmt_abgr32; //----pixfmt_abgr32
               :    typedef pixfmt_alpha_blend_rgba<blender_bgra32, rendering_buffer, pixel32_type> pixfmt_bgra32; //----pixfmt_bgra32
               :
               :    typedef pixfmt_alpha_blend_rgba<blender_rgba32_pre, rendering_buffer, pixel32_type> pixfmt_rgba32_pre; //----pixfmt_rgba32_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_argb32_pre, rendering_buffer, pixel32_type> pixfmt_argb32_pre; //----pixfmt_argb32_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_abgr32_pre, rendering_buffer, pixel32_type> pixfmt_abgr32_pre; //----pixfmt_abgr32_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_bgra32_pre, rendering_buffer, pixel32_type> pixfmt_bgra32_pre; //----pixfmt_bgra32_pre
               :
               :    typedef pixfmt_alpha_blend_rgba<blender_rgba32_plain, rendering_buffer, pixel32_type> pixfmt_rgba32_plain; //----pixfmt_rgba32_plain
               :    typedef pixfmt_alpha_blend_rgba<blender_argb32_plain, rendering_buffer, pixel32_type> pixfmt_argb32_plain; //----pixfmt_argb32_plain
               :    typedef pixfmt_alpha_blend_rgba<blender_abgr32_plain, rendering_buffer, pixel32_type> pixfmt_abgr32_plain; //----pixfmt_abgr32_plain
               :    typedef pixfmt_alpha_blend_rgba<blender_bgra32_plain, rendering_buffer, pixel32_type> pixfmt_bgra32_plain; //----pixfmt_bgra32_plain
               :
               :    struct  pixel64_type { int16u c[4]; };
               :    typedef pixfmt_alpha_blend_rgba<blender_rgba64, rendering_buffer, pixel64_type> pixfmt_rgba64; //----pixfmt_rgba64
               :    typedef pixfmt_alpha_blend_rgba<blender_argb64, rendering_buffer, pixel64_type> pixfmt_argb64; //----pixfmt_argb64
               :    typedef pixfmt_alpha_blend_rgba<blender_abgr64, rendering_buffer, pixel64_type> pixfmt_abgr64; //----pixfmt_abgr64
               :    typedef pixfmt_alpha_blend_rgba<blender_bgra64, rendering_buffer, pixel64_type> pixfmt_bgra64; //----pixfmt_bgra64
               :
               :    typedef pixfmt_alpha_blend_rgba<blender_rgba64_pre, rendering_buffer, pixel64_type> pixfmt_rgba64_pre; //----pixfmt_rgba64_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_argb64_pre, rendering_buffer, pixel64_type> pixfmt_argb64_pre; //----pixfmt_argb64_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_abgr64_pre, rendering_buffer, pixel64_type> pixfmt_abgr64_pre; //----pixfmt_abgr64_pre
               :    typedef pixfmt_alpha_blend_rgba<blender_bgra64_pre, rendering_buffer, pixel64_type> pixfmt_bgra64_pre; //----pixfmt_bgra64_pre
               :}
               :
               :#endif
               :
/* 
 * Total samples for file : "/usr/include/agg2/agg_dda_line.h"
 * 
 *  15610  6.5801
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_DDA_LINE_INCLUDED
               :#define AGG_DDA_LINE_INCLUDED
               :
               :#include <stdlib.h>
               :#include "agg_basics.h"
               :
               :namespace agg
               :{
               :
               :    //===================================================dda_line_interpolator
               :    template<int FractionShift, int YShift=0> class dda_line_interpolator
               :    {
               :    public:
               :        //--------------------------------------------------------------------
               :        dda_line_interpolator() {}
               :
               :        //--------------------------------------------------------------------
               :        dda_line_interpolator(int y1, int y2, unsigned count) :
               :            m_y(y1),
               :            m_inc(((y2 - y1) << FractionShift) / int(count)),
    99  0.0417 :            m_dy(0)
               :        {
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator ++ ()
               :        {
               :            m_dy += m_inc;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator -- ()
               :        {
               :            m_dy -= m_inc;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator += (unsigned n)
               :        {
               :            m_dy += m_inc * n;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator -= (unsigned n)
               :        {
               :            m_dy -= m_inc * n;
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        int y()  const { return m_y + (m_dy >> (FractionShift-YShift)); }
               :        int dy() const { return m_dy; }
               :
               :
               :    private:
               :        int m_y;
               :        int m_inc;
               :        int m_dy;
               :    };
               :
               :
               :
               :
               :
               :    //=================================================dda2_line_interpolator
               :    class dda2_line_interpolator
               :    {
               :    public:
               :        typedef int save_data_type;
               :        enum save_size_e { save_size = 2 };
               :
               :        //--------------------------------------------------------------------
               :        dda2_line_interpolator() {}
               :
               :        //-------------------------------------------- Forward-adjusted line
               :        dda2_line_interpolator(int y1, int y2, int count) :
               :            m_cnt(count <= 0 ? 1 : count),
               :            m_lft((y2 - y1) / m_cnt),
               :            m_rem((y2 - y1) % m_cnt),
               :            m_mod(m_rem),
   252  0.1062 :            m_y(y1)
               :        {
  2750  1.1592 :            if(m_mod <= 0)
               :            {
    35  0.0148 :                m_mod += count;
               :                m_rem += count;
    86  0.0363 :                m_lft--;
               :            }
               :            m_mod -= count;
               :        }
               :
               :        //-------------------------------------------- Backward-adjusted line
               :        dda2_line_interpolator(int y1, int y2, int count, int) :
               :            m_cnt(count <= 0 ? 1 : count),
               :            m_lft((y2 - y1) / m_cnt),
               :            m_rem((y2 - y1) % m_cnt),
               :            m_mod(m_rem),
               :            m_y(y1)
               :        {
               :            if(m_mod <= 0)
               :            {
               :                m_mod += count;
               :                m_rem += count;
               :                m_lft--;
               :            }
               :        }
               :
               :        //-------------------------------------------- Backward-adjusted line
               :        dda2_line_interpolator(int y, int count) :
               :            m_cnt(count <= 0 ? 1 : count),
               :            m_lft(y / m_cnt),
               :            m_rem(y % m_cnt),
               :            m_mod(m_rem),
               :            m_y(0)
               :        {
               :            if(m_mod <= 0)
               :            {
               :                m_mod += count;
               :                m_rem += count;
               :                m_lft--;
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void save(save_data_type* data) const
               :        {
               :            data[0] = m_mod;
               :            data[1] = m_y;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void load(const save_data_type* data)
               :        {
               :            m_mod = data[0];
               :            m_y   = data[1];
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator++()
               :        {
  2436  1.0268 :            m_mod += m_rem;
  1754  0.7394 :            m_y += m_lft;
   920  0.3878 :            if(m_mod > 0)
               :            {
   605  0.2550 :                m_mod -= m_cnt;
  4845  2.0423 :                m_y++;
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void operator--()
               :        {
               :            if(m_mod <= m_rem)
               :            {
               :                m_mod += m_cnt;
               :                m_y--;
               :            }
               :            m_mod -= m_rem;
               :            m_y -= m_lft;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void adjust_forward()
               :        {
               :            m_mod -= m_cnt;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void adjust_backward()
               :        {
               :            m_mod += m_cnt;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        int mod() const { return m_mod; }
               :        int rem() const { return m_rem; }
               :        int lft() const { return m_lft; }
               :
               :        //--------------------------------------------------------------------
  1828  0.7706 :        int y() const { return m_y; }
               :
               :    private:
               :        int m_cnt;
               :        int m_lft;
               :        int m_rem;
               :        int m_mod;
               :        int m_y;
               :    };
               :
               :
               :
               :
               :
               :
               :
               :    //---------------------------------------------line_bresenham_interpolator
               :    class line_bresenham_interpolator
               :    {
               :    public:
               :        enum subpixel_scale_e
               :        {
               :            subpixel_shift = 8,
               :            subpixel_scale = 1 << subpixel_shift,
               :            subpixel_mask  = subpixel_scale - 1
               :        };
               :
               :        //--------------------------------------------------------------------
               :        static int line_lr(int v) { return v >> subpixel_shift; }
               :
               :        //--------------------------------------------------------------------
               :        line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
               :            m_x1_lr(line_lr(x1)),
               :            m_y1_lr(line_lr(y1)),
               :            m_x2_lr(line_lr(x2)),
               :            m_y2_lr(line_lr(y2)),
               :            m_ver(abs(m_x2_lr - m_x1_lr) < abs(m_y2_lr - m_y1_lr)),
               :            m_len(m_ver ? abs(m_y2_lr - m_y1_lr) : 
               :                          abs(m_x2_lr - m_x1_lr)),
               :            m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
               :            m_interpolator(m_ver ? x1 : y1, 
               :                           m_ver ? x2 : y2, 
               :                           m_len)
               :        {
               :        }
               :    
               :        //--------------------------------------------------------------------
               :        bool     is_ver() const { return m_ver; }
               :        unsigned len()    const { return m_len; }
               :        int      inc()    const { return m_inc; }
               :
               :        //--------------------------------------------------------------------
               :        void hstep()
               :        {
               :            ++m_interpolator;
               :            m_x1_lr += m_inc;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        void vstep()
               :        {
               :            ++m_interpolator;
               :            m_y1_lr += m_inc;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        int x1() const { return m_x1_lr; }
               :        int y1() const { return m_y1_lr; }
               :        int x2() const { return line_lr(m_interpolator.y()); }
               :        int y2() const { return line_lr(m_interpolator.y()); }
               :        int x2_hr() const { return m_interpolator.y(); }
               :        int y2_hr() const { return m_interpolator.y(); }
               :
               :    private:
               :        int                    m_x1_lr;
               :        int                    m_y1_lr;
               :        int                    m_x2_lr;
               :        int                    m_y2_lr;
               :        bool                   m_ver;
               :        unsigned               m_len;
               :        int                    m_inc;
               :        dda2_line_interpolator m_interpolator;
               :
               :    };
               :
               :
               :}
               :
               :
               :
               :#endif
/* 
 * Total samples for file : "/home/rob/projects/gnu/gnash-bzr/trunk/libbase/jemalloc.c"
 * 
 *  15071  6.3529
 */


               :/*-
               : * Copyright (C) 2006-2008 Jason Evans <jasone@FreeBSD.org>.
               : * All rights reserved.
               : *
               : * Redistribution and use in source and binary forms, with or without
               : * modification, are permitted provided that the following conditions
               : * are met:
               : * 1. Redistributions of source code must retain the above copyright
               : *    notice(s), this list of conditions and the following disclaimer as
               : *    the first lines of this file unmodified other than the possible
               : *    addition of one or more copyright notices.
               : * 2. Redistributions in binary form must reproduce the above copyright
               : *    notice(s), this list of conditions and the following disclaimer in
               : *    the documentation and/or other materials provided with the
               : *    distribution.
               : *
               : * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
               : * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
               : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
               : * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
               : * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
               : * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
               : * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
               : * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
               : * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
               : * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
               : * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
               : *
               : *******************************************************************************
               : *
               : * This allocator implementation is designed to provide scalable performance
               : * for multi-threaded programs on multi-processor systems.  The following
               : * features are included for this purpose:
               : *
               : *   + Multiple arenas are used if there are multiple CPUs, which reduces lock
               : *     contention and cache sloshing.
               : *
               : *   + Cache line sharing between arenas is avoided for internal data
               : *     structures.
               : *
               : *   + Memory is managed in chunks and runs (chunks can be split into runs),
               : *     rather than as individual pages.  This provides a constant-time
               : *     mechanism for associating allocations with particular arenas.
               : *
               : * Allocation requests are rounded up to the nearest size class, and no record
               : * of the original request size is maintained.  Allocations are broken into
               : * categories according to size class.  Assuming runtime defaults, 4 kB pages
               : * and a 16 byte quantum, the size classes in each category are as follows:
               : *
               : *   |=====================================|
               : *   | Category | Subcategory    |    Size |
               : *   |=====================================|
               : *   | Small    | Tiny           |       2 |
               : *   |          |                |       4 |
               : *   |          |                |       8 |
               : *   |          |----------------+---------|
               : *   |          | Quantum-spaced |      16 |
               : *   |          |                |      32 |
               : *   |          |                |      48 |
               : *   |          |                |     ... |
               : *   |          |                |     480 |
               : *   |          |                |     496 |
               : *   |          |                |     512 |
               : *   |          |----------------+---------|
               : *   |          | Sub-page       |    1 kB |
               : *   |          |                |    2 kB |
               : *   |=====================================|
               : *   | Large                     |    4 kB |
               : *   |                           |    8 kB |
               : *   |                           |   12 kB |
               : *   |                           |     ... |
               : *   |                           | 1012 kB |
               : *   |                           | 1016 kB |
               : *   |                           | 1020 kB |
               : *   |=====================================|
               : *   | Huge                      |    1 MB |
               : *   |                           |    2 MB |
               : *   |                           |    3 MB |
               : *   |                           |     ... |
               : *   |=====================================|
               : *
               : * A different mechanism is used for each category:
               : *
               : *   Small : Each size class is segregated into its own set of runs.  Each run
               : *           maintains a bitmap of which regions are free/allocated.
               : *
               : *   Large : Each allocation is backed by a dedicated run.  Metadata are stored
               : *           in the associated arena chunk header maps.
               : *
               : *   Huge : Each allocation is backed by a dedicated contiguous set of chunks.
               : *          Metadata are stored in a separate red-black tree.
               : *
               : *******************************************************************************
               : */
               :
               :/*
               : * This has been hacked on heavily by Rob Savoye, so it compiles
               : * within Gnash, using the same configuration settings as
               : * everything else in Gnash.
               : */
               :#ifdef HAVE_CONFIG_H
               :# include "gnashconfig.h"
               :#endif
               :
               :#include "dsodefs.h"
               :
               :/*
               : * MALLOC_PRODUCTION disables assertions and statistics gathering.  It also
               : * defaults the A and J runtime options to off.  These settings are appropriate
               : * for production systems.
               : */
               :#ifndef USE_STATS_MEMORY
               :# define MALLOC_PRODUCTION 1
               :#endif
               :
               :#ifndef MALLOC_PRODUCTION
               :   /*
               :    * MALLOC_DEBUG enables assertions and other sanity checks, and disables
               :    * inline functions.
               :    */
               :#  define MALLOC_DEBUG 1
               :
               :   /* MALLOC_STATS enables statistics calculation. */
               :#  define MALLOC_STATS 1
               :
               :   /* Memory filling (junk/zero). */
               :#  define MALLOC_FILL 1
               :
               :   /* Allocation tracing. */
               :#  define MALLOC_UTRACE 1
               :
               :   /* Support optional abort() on OOM. */
               :#  define MALLOC_XMALLOC 1
               :
               :   /* Support SYSV semantics. */
               :#  define MALLOC_SYSV 1
               :#endif
               :
               :/*
               : * MALLOC_LAZY_FREE enables the use of a per-thread vector of slots that free()
               : * can atomically stuff object pointers into.  This can reduce arena lock
               : * contention.
               : */
               :/* #define	MALLOC_LAZY_FREE 1 */
               :
               :/*
               : * MALLOC_BALANCE enables monitoring of arena lock contention and dynamically
               : * re-balances arena load if exponentially averaged contention exceeds a
               : * certain threshold.
               : */
               :/* #define	MALLOC_BALANCE 1 */
               :
               :/*
               : * MALLOC_DSS enables use of sbrk(2) to allocate chunks from the data storage
               : * segment (DSS).  In an ideal world, this functionality would be completely
               : * unnecessary, but we are burdened by history and the lack of resource limits
               : * for anonymous mapped memory.
               : */
               :#if (!defined(DARWIN) && !defined(WIN32))
               :# define MALLOC_DSS 
               :#endif
               :
               :#ifdef LINUX_HOST
               :# define	_GNU_SOURCE /* For mremap(2). */
               :# define	issetugid() 0
               :# if 0 /* Enable in order to test decommit code on Linux. */
               :#  define MALLOC_DECOMMIT 1
               :/*
               : * The decommit code for Unix doesn't bother to make sure deallocated DSS
               : * chunks are writable.
               : */
               :# undef MALLOC_DSS
               :# endif
               :#endif
               :
               :#include <sys/types.h>
               :
               :#include <errno.h>
               :#include <limits.h>
               :#include <stdarg.h>
               :#include <stdio.h>
               :#include <stdlib.h>
               :#include <string.h>
               :
               :#ifdef WIN32
               :# include <cruntime.h>
               :# include <internal.h>
               :# include <windows.h>
               :# include <io.h>
               :# include "jemtree.h"
               :
               :# pragma warning( disable: 4267 4996 4146 )
               :
               :# define	bool BOOL
               :# define	false FALSE
               :# define	true TRUE
               :# define	inline __inline
               :# define	SIZE_T_MAX SIZE_MAX
               :# define	STDERR_FILENO 2
               :# define	PATH_MAX MAX_PATH
               :# define	vsnprintf _vsnprintf
               :# define	assert(f) /* we can't assert in the CRT */
               :
               :static unsigned long tlsIndex = 0xffffffff;
               :
               :# define	__thread
               :# define	_pthread_self() __threadid()
               :# define	issetugid() 0
               :
               :/* use MSVC intrinsics */
               :# pragma intrinsic(_BitScanForward)
               :static __forceinline int
               :ffs(int x)
               :{
               :	unsigned long i;
               :
               :	if (_BitScanForward(&i, x) != 0)
               :		return (i + 1);
               :
               :	return (0);
               :}
               :
               :typedef unsigned char uint8_t;
               :typedef unsigned uint32_t;
               :typedef unsigned long long uint64_t;
               :typedef unsigned long long uintmax_t;
               :
               :# define	MALLOC_DECOMMIT
               :#endif  /* end of WIN32 */
               :
               :#ifdef HAVE_PTHREADS
               :# include <pthread.h>
               :#endif
               :
               :#ifndef WIN32
               :# include <sys/cdefs.h>
               :# ifndef __DECONST
               :#  define __DECONST(type, var)	((type)(uintptr_t)(const void *)(var))
               :# endif
               :# include <sys/mman.h>
               :# ifndef MADV_FREE
               :#  define MADV_FREE	MADV_DONTNEED
               :# endif
               :# include <sys/param.h>
               :# include <sys/time.h>
               :# include <sys/types.h>
               :# include <sys/sysctl.h>
               :# include "jemtree.h"
               :# include <sys/uio.h>
               :
               :# include <errno.h>
               :# include <limits.h>
               :# ifndef SIZE_T_MAX
               :#  define SIZE_T_MAX	SIZE_MAX
               :# endif
               :# if defined(DARWIN) || defined(LINUX_HOST)
               :#  define _pthread_self pthread_self
               :#  define _pthread_mutex_init pthread_mutex_init
               :#  define _pthread_mutex_trylock pthread_mutex_trylock
               :#  define _pthread_mutex_lock pthread_mutex_lock
               :#  define _pthread_mutex_unlock pthread_mutex_unlock
               :# endif
               :# include <sched.h>
               :# include <stdarg.h>
               :# include <stdbool.h>
               :# include <stdio.h>
               :# include <stdint.h>
               :# include <stdlib.h>
               :# include <string.h>
               :# ifndef DARWIN
               :#  include <strings.h>
               :# endif
               :# include <unistd.h>
               :
               :# ifdef DARWIN
               :#  include <libkern/OSAtomic.h>
               :#  include <mach/mach_error.h>
               :#  include <mach/mach_init.h>
               :#  include <mach/vm_map.h>
               :#  include <malloc/malloc.h>
               :# endif  /* end of DARWIN */
               :#endif   /* end of WIN32 */
               :
               :#ifdef DARWIN
               :static const bool g_isthreaded = true;
               :#endif
               :
               :#define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var))
               :
               :#ifdef MALLOC_DEBUG
               :# ifdef NDEBUG
               :#  undef NDEBUG
               :# endif
               :#else
               :# ifndef NDEBUG
               :#  define NDEBUG
               :# endif
               :#endif
               :#ifndef WIN32
               :# include <assert.h>
               :#endif
               :
               :#ifdef MALLOC_DEBUG
               :/* Disable inlining to make debugging easier. */
               :# ifdef inline
               :#  undef inline
               :# endif
               :
               :# define inline
               :#endif  /* end of MALLOC_DEBUG */
               :
               :/* Size of stack-allocated buffer passed to strerror_r(). */
               :#define	STRERROR_BUF		64
               :
               :/* Minimum alignment of allocations is 2^QUANTUM_2POW_MIN bytes. */
               :#define QUANTUM_2POW_MIN      4
               :#ifdef MOZ_MEMORY_SIZEOF_PTR_2POW
               :# define SIZEOF_PTR_2POW		MOZ_MEMORY_SIZEOF_PTR_2POW
               :#else
               :# define SIZEOF_PTR_2POW       2
               :#endif
               :// __as __isthreaded is already defined on FreeBSD with a different value that does
               :// the same thing, rename our version to be unique. Althought jemalloc is the default
               :// allocator on FreeBSD< we still want to use our own version, as it has additional Gnash
               :// specific tweaks.
               :#ifndef DARWIN
               :static const bool g_isthreaded = true;
               :#else
               :# define NO_TLS
               :#endif
               :#if 0
               :#ifdef __i386__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	2
               :#  define CPU_SPINWAIT		__asm__ volatile("pause")
               :#endif
               :#ifdef __ia64__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	3
               :#endif
               :#ifdef __alpha__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	3
               :#  define NO_TLS
               :#endif
               :#ifdef __sparc64__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	3
               :#  define NO_TLS
               :#endif
               :#ifdef __amd64__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	3
               :#  define CPU_SPINWAIT		__asm__ volatile("pause")
               :#endif
               :#ifdef __arm__
               :#  define QUANTUM_2POW_MIN	3
               :#  define SIZEOF_PTR_2POW	2
               :#  define NO_TLS
               :#endif
               :#ifdef __powerpc__
               :#  define QUANTUM_2POW_MIN	4
               :#  define SIZEOF_PTR_2POW	2
               :#endif
               :#endif
               :
               :#define	SIZEOF_PTR		(1U << SIZEOF_PTR_2POW)
               :
               :/* sizeof(int) == (1U << SIZEOF_INT_2POW). */
               :#ifndef SIZEOF_INT_2POW
               :# define SIZEOF_INT_2POW	2
               :#endif
               :
               :/* We can't use TLS in non-PIC programs, since TLS relies on loader magic. */
               :#if (!defined(PIC) && !defined(NO_TLS))
               :# define NO_TLS
               :#endif
               :
               :#ifdef NO_TLS
               :   /* MALLOC_BALANCE requires TLS. */
               :#  ifdef MALLOC_BALANCE
               :#    undef MALLOC_BALANCE
               :#  endif
               :   /* MALLOC_LAZY_FREE requires TLS. */
               :#  ifdef MALLOC_LAZY_FREE
               :#    undef MALLOC_LAZY_FREE
               :#  endif
               :#endif
               :
               :/*
               : * Size and alignment of memory chunks that are allocated by the OS's virtual
               : * memory system.
               : */
               :#define	CHUNK_2POW_DEFAULT	20
               :
               :/* Maximum number of dirty pages per arena. */
               :#define	DIRTY_MAX_DEFAULT	(1U << 9)
               :
               :/*
               : * Maximum size of L1 cache line.  This is used to avoid cache line aliasing,
               : * so over-estimates are okay (up to a point), but under-estimates will
               : * negatively affect performance.
               : */
               :#define	CACHELINE_2POW		6
               :#define	CACHELINE		((size_t)(1U << CACHELINE_2POW))
               :
               :/* Smallest size class to support. */
               :#define	TINY_MIN_2POW		1
               :
               :/*
               : * Maximum size class that is a multiple of the quantum, but not (necessarily)
               : * a power of 2.  Above this size, allocations are rounded up to the nearest
               : * power of 2.
               : */
               :#define	SMALL_MAX_2POW_DEFAULT	9
               :#define	SMALL_MAX_DEFAULT	(1U << SMALL_MAX_2POW_DEFAULT)
               :
               :/*
               : * RUN_MAX_OVRHD indicates maximum desired run header overhead.  Runs are sized
               : * as small as possible such that this setting is still honored, without
               : * violating other constraints.  The goal is to make runs as small as possible
               : * without exceeding a per run external fragmentation threshold.
               : *
               : * We use binary fixed point math for overhead computations, where the binary
               : * point is implicitly RUN_BFP bits to the left.
               : *
               : * Note that it is possible to set RUN_MAX_OVRHD low enough that it cannot be
               : * honored for some/all object sizes, since there is one bit of header overhead
               : * per object (plus a constant).  This constraint is relaxed (ignored) for runs
               : * that are so small that the per-region overhead is greater than:
               : *
               : *   (RUN_MAX_OVRHD / (reg_size << (3+RUN_BFP))
               : */
               :#define	RUN_BFP			12
               :/*                                    \/   Implicit binary fixed point. */
               :#define	RUN_MAX_OVRHD		0x0000003dU
               :#define	RUN_MAX_OVRHD_RELAX	0x00001800U
               :
               :/*
               : * Put a cap on small object run size.  This overrides RUN_MAX_OVRHD.  Note
               : * that small runs must be small enough that page offsets can fit within the
               : * CHUNK_MAP_POS_MASK bits.
               : */
               :#define	RUN_MAX_SMALL_2POW	15
               :#define	RUN_MAX_SMALL		(1U << RUN_MAX_SMALL_2POW)
               :
               :#ifdef MALLOC_LAZY_FREE
               :   /* Default size of each arena's lazy free cache. */
               :#  define LAZY_FREE_2POW_DEFAULT 8
               :   /*
               :    * Number of pseudo-random probes to conduct before considering the cache to
               :    * be overly full.  It takes on average n probes to detect fullness of
               :    * (n-1)/n.  However, we are effectively doing multiple non-independent
               :    * trials (each deallocation is a trial), so the actual average threshold
               :    * for clearing the cache is somewhat lower.
               :    */
               :#  define LAZY_FREE_NPROBES	5
               :#endif
               :
               :/*
               : * Hyper-threaded CPUs may need a special instruction inside spin loops in
               : * order to yield to another virtual CPU.  If no such instruction is defined
               : * above, make CPU_SPINWAIT a no-op.
               : */
               :#ifndef CPU_SPINWAIT
               :#  define CPU_SPINWAIT
               :#endif
               :
               :/*
               : * Adaptive spinning must eventually switch to blocking, in order to avoid the
               : * potential for priority inversion deadlock.  Backing off past a certain point
               : * can actually waste time.
               : */
               :#define	SPIN_LIMIT_2POW		11
               :
               :/*
               : * Conversion from spinning to blocking is expensive; we use (1U <<
               : * BLOCK_COST_2POW) to estimate how many more times costly blocking is than
               : * worst-case spinning.
               : */
               :#define	BLOCK_COST_2POW		4
               :
               :#ifdef MALLOC_BALANCE
               :   /*
               :    * We use an exponential moving average to track recent lock contention,
               :    * where the size of the history window is N, and alpha=2/(N+1).
               :    *
               :    * Due to integer math rounding, very small values here can cause
               :    * substantial degradation in accuracy, thus making the moving average decay
               :    * faster than it would with precise calculation.
               :    */
               :#  define BALANCE_ALPHA_INV_2POW	9
               :
               :   /*
               :    * Threshold value for the exponential moving contention average at which to
               :    * re-assign a thread.
               :    */
               :#  define BALANCE_THRESHOLD_DEFAULT	(1U << (SPIN_LIMIT_2POW-4))
               :#endif
               :
               :/******************************************************************************/
               :
               :/*
               : * Mutexes based on spinlocks.  We can't use normal pthread spinlocks in all
               : * places, because they require malloc()ed memory, which causes bootstrapping
               : * issues in some cases.
               : */
               :#if defined(WIN32)
               :#define malloc_mutex_t CRITICAL_SECTION
               :#define malloc_spinlock_t CRITICAL_SECTION
               :#elif defined(DARWIN)
               :typedef struct {
               :	OSSpinLock	lock;
               :} malloc_mutex_t;
               :typedef struct {
               :	OSSpinLock	lock;
               :} malloc_spinlock_t;
               :#elif defined(USE_JEMALLOC)
               :typedef pthread_mutex_t malloc_mutex_t;
               :typedef pthread_mutex_t malloc_spinlock_t;
               :#else
               :/* XXX these should #ifdef these for freebsd (and linux?) only */
               :typedef struct {
               :	spinlock_t	lock;
               :} malloc_mutex_t;
               :typedef malloc_spinlock_t malloc_mutex_t;
               :#endif
               :
               :/* Set to true once the allocator has been initialized. */
               :static bool malloc_initialized = false;
               :
               :#ifdef WIN32
               :/* No init lock for Windows. */
               :#elif defined(DARWIN)
               :static malloc_mutex_t init_lock = {OS_SPINLOCK_INIT};
               :#elif defined(LINUX_HOST)
               :static malloc_mutex_t init_lock = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;
               :#elif defined(USE_JEMALLOC)
               :static malloc_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
               :#else
               :static malloc_mutex_t init_lock = {_SPINLOCK_INITIALIZER};
               :#endif
               :
               :/******************************************************************************/
               :/*
               : * Statistics data structures.
               : */
               :
               :#ifdef MALLOC_STATS
               :
               :/* Borrowed from malloc.h, as this is Linux specific. This has been
               : * added to jemalloc so the existing memory profiling in Gnash will
               : * continue to work. Most of these fields aren't used by the Gnash
               : * memory profiling, but we leave them here for a semblance of
               : * portability. The only fields Gnash uses are arena, uordblks. and
               : * fordblks.
               : *
               : * This gets more interesting, as jemalloc maintains multiple
               : * arenas, one for each CPU in a multiprocessor system. We cheat
               : * by just accumulating the stats for all arenas, since our primary
               : * purpose is to track memory leaks.
               : */
               :struct mallinfo {
               :  int arena;    /* non-mmapped space allocated from system */
               :  int ordblks;  /* number of free chunks UNUSED */
               :  int smblks;   /* number of fastbin blocks UNUSED */
               :  int hblks;    /* number of mmapped regions UNUSED */
               :  int hblkhd;   /* space in mmapped regions UNUSED */
               :  int usmblks;  /* maximum total allocated space UNUSED */
               :  int fsmblks;  /* space available in freed fastbin blocks UNUSED */
               :  int uordblks; /* total allocated space */
               :  int fordblks; /* total free space */
               :  int keepcost; /* top-most, releasable space UNUSED */
               :};
               :
               :typedef struct malloc_bin_stats_s malloc_bin_stats_t;
               :struct malloc_bin_stats_s {
               :	/*
               :	 * Number of allocation requests that corresponded to the size of this
               :	 * bin.
               :	 */
               :	uint64_t	nrequests;
               :
               :	/* Total number of runs created for this bin's size class. */
               :	uint64_t	nruns;
               :
               :	/*
               :	 * Total number of runs reused by extracting them from the runs tree for
               :	 * this bin's size class.
               :	 */
               :	uint64_t	reruns;
               :
               :	/* High-water mark for this bin. */
               :	unsigned long	highruns;
               :
               :	/* Current number of runs in this bin. */
               :	unsigned long	curruns;
               :};
               :
               :typedef struct arena_stats_s arena_stats_t;
               :struct arena_stats_s {
               :	/* Number of bytes currently mapped. */
               :	size_t		mapped;
               :
               :	/*
               :	 * Total number of purge sweeps, total number of madvise calls made,
               :	 * and total pages purged in order to keep dirty unused memory under
               :	 * control.
               :	 */
               :	uint64_t	npurge;
               :	uint64_t	nmadvise;
               :	uint64_t	purged;
               :#ifdef MALLOC_DECOMMIT
               :	/*
               :	 * Total number of decommit/commit operations, and total number of
               :	 * pages decommitted.
               :	 */
               :	uint64_t	ndecommit;
               :	uint64_t	ncommit;
               :	uint64_t	decommitted;
               :#endif
               :
               :	/* Per-size-category statistics. */
               :	size_t		allocated_small;
               :	uint64_t	nmalloc_small;
               :	uint64_t	ndalloc_small;
               :
               :	size_t		allocated_large;
               :	uint64_t	nmalloc_large;
               :	uint64_t	ndalloc_large;
               :
               :#ifdef MALLOC_BALANCE
               :	/* Number of times this arena reassigned a thread due to contention. */
               :	uint64_t	nbalance;
               :#endif
               :};
               :
               :typedef struct chunk_stats_s chunk_stats_t;
               :struct chunk_stats_s {
               :	/* Number of chunks that were allocated. */
               :	uint64_t	nchunks;
               :
               :	/* High-water mark for number of chunks allocated. */
               :	unsigned long	highchunks;
               :
               :	/*
               :	 * Current number of chunks allocated.  This value isn't maintained for
               :	 * any other purpose, so keep track of it in order to be able to set
               :	 * highchunks.
               :	 */
               :	unsigned long	curchunks;
               :};
               :
               :#endif /* #ifdef MALLOC_STATS */
               :
               :/******************************************************************************/
               :/*
               : * Extent data structures.
               : */
               :
               :/* Tree of extents. */
               :typedef struct extent_node_s extent_node_t;
               :struct extent_node_s {
               :	/* Linkage for the size/address-ordered tree. */
               :	RB_ENTRY(extent_node_s) link_szad;
               :
               :	/* Linkage for the address-ordered tree. */
               :	RB_ENTRY(extent_node_s) link_ad;
               :
               :	/* Pointer to the extent that this tree node is responsible for. */
               :	void	*addr;
               :
               :	/* Total region size. */
               :	size_t	size;
               :};
               :typedef struct extent_tree_szad_s extent_tree_szad_t;
               :RB_HEAD(extent_tree_szad_s, extent_node_s);
               :typedef struct extent_tree_ad_s extent_tree_ad_t;
               :RB_HEAD(extent_tree_ad_s, extent_node_s);
               :
               :/******************************************************************************/
               :/*
               : * Arena data structures.
               : */
               :
               :typedef struct arena_s arena_t;
               :typedef struct arena_bin_s arena_bin_t;
               :
               :/*
               : * Each map element contains several flags, plus page position for runs that
               : * service small allocations.
               : */
               :typedef uint8_t arena_chunk_map_t;
               :#define	CHUNK_MAP_UNTOUCHED	0x80U
               :#define	CHUNK_MAP_DIRTY		0x40U
               :#define	CHUNK_MAP_LARGE		0x20U
               :#ifdef MALLOC_DECOMMIT
               :#define	CHUNK_MAP_DECOMMITTED	0x10U
               :#define	CHUNK_MAP_POS_MASK	0x0fU
               :#else
               :#define	CHUNK_MAP_POS_MASK	0x1fU
               :#endif
               :
               :/* Arena chunk header. */
               :typedef struct arena_chunk_s arena_chunk_t;
               :struct arena_chunk_s {
               :	/* Arena that owns the chunk. */
               :	arena_t		*arena;
               :
               :	/* Linkage for the arena's chunk tree. */
               :	RB_ENTRY(arena_chunk_s) link;
               :
               :	/*
               :	 * Number of pages in use.  This is maintained in order to make
               :	 * detection of empty chunks fast.
               :	 */
               :	size_t		pages_used;
               :
               :	/* Number of dirty pages. */
               :	size_t		ndirty;
               :
               :	/*
               :	 * Tree of extent nodes that are embedded in the arena chunk header
               :	 * page(s).  These nodes are used by arena_chunk_node_alloc().
               :	 */
               :	extent_tree_ad_t nodes;
               :	extent_node_t	*nodes_past;
               :
               :	/*
               :	 * Map of pages within chunk that keeps track of free/large/small.  For
               :	 * free runs, only the map entries for the first and last pages are
               :	 * kept up to date, so that free runs can be quickly coalesced.
               :	 */
               :	arena_chunk_map_t map[1]; /* Dynamically sized. */
               :};
               :typedef struct arena_chunk_tree_s arena_chunk_tree_t;
               :RB_HEAD(arena_chunk_tree_s, arena_chunk_s);
               :
               :typedef struct arena_run_s arena_run_t;
               :struct arena_run_s {
               :	/* Linkage for run trees. */
               :	RB_ENTRY(arena_run_s) link;
               :
               :#ifdef MALLOC_DEBUG
               :	uint32_t	magic;
               :#  define ARENA_RUN_MAGIC 0x384adf93
               :#endif
               :
               :	/* Bin this run is associated with. */
               :	arena_bin_t	*bin;
               :
               :	/* Index of first element that might have a free region. */
               :	unsigned	regs_minelm;
               :
               :	/* Number of free regions in run. */
               :	unsigned	nfree;
               :
               :	/* Bitmask of in-use regions (0: in use, 1: free). */
               :	unsigned	regs_mask[1]; /* Dynamically sized. */
               :};
               :typedef struct arena_run_tree_s arena_run_tree_t;
               :RB_HEAD(arena_run_tree_s, arena_run_s);
               :
               :struct arena_bin_s {
               :	/*
               :	 * Current run being used to service allocations of this bin's size
               :	 * class.
               :	 */
               :	arena_run_t	*runcur;
               :
               :	/*
               :	 * Tree of non-full runs.  This tree is used when looking for an
               :	 * existing run when runcur is no longer usable.  We choose the
               :	 * non-full run that is lowest in memory; this policy tends to keep
               :	 * objects packed well, and it can also help reduce the number of
               :	 * almost-empty chunks.
               :	 */
               :	arena_run_tree_t runs;
               :
               :	/* Size of regions in a run for this bin's size class. */
               :	size_t		reg_size;
               :
               :	/* Total size of a run for this bin's size class. */
               :	size_t		run_size;
               :
               :	/* Total number of regions in a run for this bin's size class. */
               :	uint32_t	nregs;
               :
               :	/* Number of elements in a run's regs_mask for this bin's size class. */
               :	uint32_t	regs_mask_nelms;
               :
               :	/* Offset of first region in a run for this bin's size class. */
               :	uint32_t	reg0_offset;
               :
               :#ifdef MALLOC_STATS
               :	/* Bin statistics. */
               :	malloc_bin_stats_t stats;
               :#endif
               :};
               :
               :struct arena_s {
               :#ifdef MALLOC_DEBUG
               :	uint32_t		magic;
               :#  define ARENA_MAGIC 0x947d3d24
               :#endif
               :
               :	/* All operations on this arena require that lock be locked. */
               :	malloc_spinlock_t	lock;
               :
               :#ifdef MALLOC_STATS
               :	arena_stats_t		stats;
               :#endif
               :
               :	/*
               :	 * Tree of chunks this arena manages.
               :	 */
               :	arena_chunk_tree_t	chunks;
               :
               :	/*
               :	 * In order to avoid rapid chunk allocation/deallocation when an arena
               :	 * oscillates right on the cusp of needing a new chunk, cache the most
               :	 * recently freed chunk.  The spare is left in the arena's chunk tree
               :	 * until it is deleted.
               :	 *
               :	 * There is one spare chunk per arena, rather than one spare total, in
               :	 * order to avoid interactions between multiple threads that could make
               :	 * a single spare inadequate.
               :	 */
               :	arena_chunk_t		*spare;
               :
               :	/*
               :	 * Current count of pages within unused runs that are potentially
               :	 * dirty, and for which madvise(... MADV_FREE) has not been called.  By
               :	 * tracking this, we can institute a limit on how much dirty unused
               :	 * memory is mapped for each arena.
               :	 */
               :	size_t			ndirty;
               :
               :	/*
               :	 * Trees of this arena's available runs.  Two trees are maintained
               :	 * using one set of nodes, since one is needed for first-best-fit run
               :	 * allocation, and the other is needed for coalescing.
               :	 */
               :	extent_tree_szad_t	runs_avail_szad;
               :	extent_tree_ad_t	runs_avail_ad;
               :
               :	/* Tree of this arena's allocated (in-use) runs. */
               :	extent_tree_ad_t	runs_alloced_ad;
               :
               :#ifdef MALLOC_BALANCE
               :	/*
               :	 * The arena load balancing machinery needs to keep track of how much
               :	 * lock contention there is.  This value is exponentially averaged.
               :	 */
               :	uint32_t		contention;
               :#endif
               :
               :#ifdef MALLOC_LAZY_FREE
               :	/*
               :	 * Deallocation of small objects can be lazy, in which case free_cache
               :	 * stores pointers to those objects that have not yet been deallocated.
               :	 * In order to avoid lock contention, slots are chosen randomly.  Empty
               :	 * slots contain NULL.
               :	 */
               :	void			**free_cache;
               :#endif
               :
               :	/*
               :	 * bins is used to store rings of free regions of the following sizes,
               :	 * assuming a 16-byte quantum, 4kB pagesize, and default MALLOC_OPTIONS.
               :	 *
               :	 *   bins[i] | size |
               :	 *   --------+------+
               :	 *        0  |    2 |
               :	 *        1  |    4 |
               :	 *        2  |    8 |
               :	 *   --------+------+
               :	 *        3  |   16 |
               :	 *        4  |   32 |
               :	 *        5  |   48 |
               :	 *        6  |   64 |
               :	 *           :      :
               :	 *           :      :
               :	 *       33  |  496 |
               :	 *       34  |  512 |
               :	 *   --------+------+
               :	 *       35  | 1024 |
               :	 *       36  | 2048 |
               :	 *   --------+------+
               :	 */
               :	arena_bin_t		bins[1]; /* Dynamically sized. */
               :};
               :
               :/******************************************************************************/
               :/*
               : * Data.
               : */
               :
               :/* Number of CPUs. */
               :static unsigned		ncpus;
               :
               :/* VM page size. */
               :static size_t		pagesize;
               :static size_t		pagesize_mask;
               :static size_t		pagesize_2pow;
               :
               :/* Various bin-related settings. */
               :static size_t		bin_maxclass; /* Max size class for bins. */
               :static unsigned		ntbins; /* Number of (2^n)-spaced tiny bins. */
               :static unsigned		nqbins; /* Number of quantum-spaced bins. */
               :static unsigned		nsbins; /* Number of (2^n)-spaced sub-page bins. */
               :static size_t		small_min;
               :static size_t		small_max;
               :
               :/* Various quantum-related settings. */
               :static size_t		quantum;
               :static size_t		quantum_mask; /* (quantum - 1). */
               :
               :/* Various chunk-related settings. */
               :static size_t		chunksize;
               :static size_t		chunksize_mask; /* (chunksize - 1). */
               :static size_t		chunk_npages;
               :static size_t		arena_chunk_header_npages;
               :static size_t		arena_maxclass; /* Max size class for arenas. */
               :
               :/********/
               :/*
               : * Chunks.
               : */
               :
               :/* Protects chunk-related data structures. */
               :static malloc_mutex_t	huge_mtx;
               :
               :/* Tree of chunks that are stand-alone huge allocations. */
               :static extent_tree_ad_t	huge;
               :
               :#ifdef MALLOC_DSS
               :/*
               : * Protects sbrk() calls.  This avoids malloc races among threads, though it
               : * does not protect against races with threads that call sbrk() directly.
               : */
               :static malloc_mutex_t	dss_mtx;
               :/* Base address of the DSS. */
               :static void		*dss_base;
               :/* Current end of the DSS, or ((void *)-1) if the DSS is exhausted. */
               :static void		*dss_prev;
               :/* Current upper limit on DSS addresses. */
               :static void		*dss_max;
               :
               :/*
               : * Trees of chunks that were previously allocated (trees differ only in node
               : * ordering).  These are used when allocating chunks, in an attempt to re-use
               : * address space.  Depending on function, different tree orderings are needed,
               : * which is why there are two trees with the same contents.
               : */
               :static extent_tree_szad_t dss_chunks_szad;
               :static extent_tree_ad_t	dss_chunks_ad;
               :#endif
               :
               :#ifdef MALLOC_STATS
               :/* Huge allocation statistics. */
               :static uint64_t		huge_nmalloc;
               :static uint64_t		huge_ndalloc;
               :static size_t		huge_allocated;
               :#endif
               :
               :/****************************/
               :/*
               : * base (internal allocation).
               : */
               :
               :/*
               : * Current pages that are being used for internal memory allocations.  These
               : * pages are carved up in cacheline-size quanta, so that there is no chance of
               : * false cache line sharing.
               : */
               :static void		*base_pages;
               :static void		*base_next_addr;
               :static void		*base_past_addr; /* Addr immediately past base_pages. */
               :static extent_node_t	*base_nodes;
               :static malloc_mutex_t	base_mtx;
               :#ifdef MALLOC_STATS
               :static size_t		base_mapped;
               :#endif
               :
               :/********/
               :/*
               : * Arenas.
               : */
               :
               :/*
               : * Arenas that are used to service external requests.  Not all elements of the
               : * arenas array are necessarily used; arenas are created lazily as needed.
               : */
               :static arena_t		**arenas;
               :static unsigned		narenas;
               :#ifndef NO_TLS
               :#  ifdef MALLOC_BALANCE
               :static unsigned		narenas_2pow;
               :#  else
               :static unsigned		next_arena;
               :#  endif
               :#endif
               :static malloc_spinlock_t arenas_lock; /* Protects arenas initialization. */
               :
               :#ifndef NO_TLS
               :/*
               : * Map of pthread_self() --> arenas[???], used for selecting an arena to use
               : * for allocations.
               : */
               :#ifdef HAVE_LOCAL_THREAD_STORAGE
               :static __thread arena_t	*arenas_map;
               :#endif
               :#endif
               :
               :#ifdef MALLOC_STATS
               :/* Chunk statistics. */
               :static chunk_stats_t	stats_chunks;
               :#endif
               :
               :/*******************************/
               :/*
               : * Runtime configuration options.
               : */
               :const char	*_malloc_options
               :#ifdef WIN32
               := "A10n2F"
               :#elif (defined(DARWIN))
               := "AP10n"
               :#elif (defined(LINUX_HOST))
               := "A10n2F"
               :#endif
               :;
               :
               :#ifndef MALLOC_PRODUCTION
               :static bool	opt_abort = true;
               :#ifdef MALLOC_FILL
               :static bool	opt_junk = true;
               :#endif
               :#else
               :static bool	opt_abort = false;
               :#ifdef MALLOC_FILL
               :static bool	opt_junk = false;
               :#endif
               :#endif
               :#ifdef MALLOC_DSS
               :static bool	opt_dss = true;
               :static bool	opt_mmap = true;
               :#endif
               :static size_t	opt_dirty_max = DIRTY_MAX_DEFAULT;
               :#ifdef MALLOC_LAZY_FREE
               :static int	opt_lazy_free_2pow = LAZY_FREE_2POW_DEFAULT;
               :#endif
               :#ifdef MALLOC_BALANCE
               :static uint64_t	opt_balance_threshold = BALANCE_THRESHOLD_DEFAULT;
               :#endif
               :/*
               : * this toggles the printing of statistics when the program exists.
               : */
               :static bool	opt_print_stats = false;
               :static size_t	opt_quantum_2pow = QUANTUM_2POW_MIN;
               :static size_t	opt_small_max_2pow = SMALL_MAX_2POW_DEFAULT;
               :static size_t	opt_chunk_2pow = CHUNK_2POW_DEFAULT;
               :#ifdef MALLOC_UTRACE
               :static bool	opt_utrace = false;
               :#endif
               :#ifdef MALLOC_SYSV
               :static bool	opt_sysv = false;
               :#endif
               :#ifdef MALLOC_XMALLOC
               :static bool	opt_xmalloc = false;
               :#endif
               :#ifdef MALLOC_FILL
               :static bool	opt_zero = false;
               :#endif
               :static int	opt_narenas_lshift = 0;
               :
               :#ifdef MALLOC_UTRACE
               :typedef struct {
               :	void	*p;
               :	size_t	s;
               :	void	*r;
               :} malloc_utrace_t;
               :
               :#define	UTRACE(a, b, c)							\
               :	if (opt_utrace) {						\
               :		malloc_utrace_t ut;					\
               :		ut.p = (a);						\
               :		ut.s = (b);						\
               :		ut.r = (c);						\
               :		utrace(&ut, sizeof(ut));				\
               :	}
               :#else
               :#define	UTRACE(a, b, c)
               :#endif
               :
               :/******************************************************************************/
               :/*
               : * Begin function prototypes for non-inline static functions.
               : */
               :
               :static bool	malloc_mutex_init(malloc_mutex_t *mutex);
               :static bool	malloc_spin_init(malloc_spinlock_t *lock);
               :static void	wrtmessage(const char *p1, const char *p2, const char *p3,
               :		const char *p4);
               :#ifdef MALLOC_STATS
               :#ifdef DARWIN
               :/* Avoid namespace collision with OS X's malloc APIs. */
               :#define malloc_printf xmalloc_printf
               :#endif
               :static void	malloc_printf(const char *format, ...);
               :#endif
               :static char	*umax2s(uintmax_t x, char *s);
               :#ifdef MALLOC_DSS
               :static bool	base_pages_alloc_dss(size_t minsize);
               :#endif
               :static bool	base_pages_alloc_mmap(size_t minsize);
               :static bool	base_pages_alloc(size_t minsize);
               :static void	*base_alloc(size_t size);
               :static void	*base_calloc(size_t number, size_t size);
               :static extent_node_t *base_node_alloc(void);
               :static void	base_node_dealloc(extent_node_t *node);
               :#ifdef MALLOC_STATS
               :static void	stats_print(arena_t *arena);
               :#endif
               :static void	*pages_map(void *addr, size_t size);
               :static void	pages_unmap(void *addr, size_t size);
               :#ifdef MALLOC_DSS
               :static void	*chunk_alloc_dss(size_t size);
               :static void	*chunk_recycle_dss(size_t size, bool zero);
               :#endif
               :static void	*chunk_alloc_mmap(size_t size);
               :static void	*chunk_alloc(size_t size, bool zero);
               :#ifdef MALLOC_DSS
               :static extent_node_t *chunk_dealloc_dss_record(void *chunk, size_t size);
               :static bool	chunk_dealloc_dss(void *chunk, size_t size);
               :#endif
               :static void	chunk_dealloc_mmap(void *chunk, size_t size);
               :static void	chunk_dealloc(void *chunk, size_t size);
               :#ifndef NO_TLS
               :static arena_t	*choose_arena_hard(void);
               :#endif
               :static extent_node_t *arena_chunk_node_alloc(arena_chunk_t *chunk);
               :static void	arena_chunk_node_dealloc(arena_chunk_t *chunk,
               :    extent_node_t *node);
               :static void	arena_run_split(arena_t *arena, arena_run_t *run, size_t size,
               :    bool small, bool zero);
               :static arena_chunk_t *arena_chunk_alloc(arena_t *arena);
               :static void	arena_chunk_dealloc(arena_t *arena, arena_chunk_t *chunk);
               :static arena_run_t *arena_run_alloc(arena_t *arena, size_t size, bool small,
               :    bool zero);
               :static void	arena_purge(arena_t *arena);
               :static void	arena_run_dalloc(arena_t *arena, arena_run_t *run, bool dirty);
               :static void	arena_run_trim_head(arena_t *arena, arena_chunk_t *chunk,
               :    extent_node_t *nodeB, arena_run_t *run, size_t oldsize, size_t newsize);
               :static void	arena_run_trim_tail(arena_t *arena, arena_chunk_t *chunk,
               :    extent_node_t *nodeA, arena_run_t *run, size_t oldsize, size_t newsize,
               :    bool dirty);
               :static arena_run_t *arena_bin_nonfull_run_get(arena_t *arena, arena_bin_t *bin);
               :static void *arena_bin_malloc_hard(arena_t *arena, arena_bin_t *bin);
               :static size_t arena_bin_run_size_calc(arena_bin_t *bin, size_t min_run_size);
               :#ifdef MALLOC_BALANCE
               :static void	arena_lock_balance_hard(arena_t *arena);
               :#endif
               :static void	*arena_malloc_large(arena_t *arena, size_t size, bool zero);
               :static void	*arena_palloc(arena_t *arena, size_t alignment, size_t size,
               :    size_t alloc_size);
               :static size_t	arena_salloc(const void *ptr);
               :#ifdef MALLOC_LAZY_FREE
               :static void	arena_dalloc_lazy_hard(arena_t *arena, arena_chunk_t *chunk,
               :    void *ptr, size_t pageind, arena_chunk_map_t *mapelm);
               :#endif
               :static void	arena_dalloc_large(arena_t *arena, arena_chunk_t *chunk,
               :    void *ptr);
               :static void	arena_ralloc_large_shrink(arena_t *arena, arena_chunk_t *chunk,
               :    void *ptr, size_t size, size_t oldsize);
               :static bool	arena_ralloc_large_grow(arena_t *arena, arena_chunk_t *chunk,
               :    void *ptr, size_t size, size_t oldsize);
               :static bool	arena_ralloc_large(void *ptr, size_t size, size_t oldsize);
               :static void	*arena_ralloc(void *ptr, size_t size, size_t oldsize);
               :static bool	arena_new(arena_t *arena);
               :static arena_t	*arenas_extend(unsigned ind);
               :static void	*huge_malloc(size_t size, bool zero);
               :static void	*huge_palloc(size_t alignment, size_t size);
               :static void	*huge_ralloc(void *ptr, size_t size, size_t oldsize);
               :static void	huge_dalloc(void *ptr);
               :static void	malloc_print_stats(void);
               :#ifndef WIN32
               :static
               :#endif
               :bool		malloc_init_hard(void);
               :
               :/*
               : * End function prototypes.
               : */
               :/******************************************************************************/
               :/*
               : * Begin mutex.  We can't use normal pthread mutexes in all places, because
               : * they require malloc()ed memory, which causes bootstrapping issues in some
               : * cases.
               : */
               :
               :static bool
               :malloc_mutex_init(malloc_mutex_t *mutex)
               :{
               :#if defined(WIN32)
               :	if (g_isthreaded)
               :		if (! __crtInitCritSecAndSpinCount(mutex, _CRT_SPINCOUNT))
               :			return (true);
               :#elif defined(DARWIN)
               :	mutex->lock = OS_SPINLOCK_INIT;
               :#elif defined(LINUX_HOST)
               :	pthread_mutexattr_t attr;
               :	if (pthread_mutexattr_init(&attr) != 0)
               :		return (true);
               :	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
               :	if (pthread_mutex_init(mutex, &attr) != 0) {
               :		pthread_mutexattr_destroy(&attr);
               :		return (true);
               :	}
               :	pthread_mutexattr_destroy(&attr);
               :#elif defined(USE_JEMALLOC)
               :	if (pthread_mutex_init(mutex, NULL) != 0)
               :		return (true);
               :#else
               :	static const spinlock_t lock = _SPINLOCK_INITIALIZER;
               :
               :	mutex->lock = lock;
               :#endif
               :	return (false);
               :}
               :
               :static inline void
               :malloc_mutex_lock(malloc_mutex_t *mutex)
               :{
               :
               :#if defined(WIN32)
               :	EnterCriticalSection(mutex);
               :#elif defined(DARWIN)
               :	OSSpinLockLock(&mutex->lock);
               :#elif defined(USE_JEMALLOC)
   123  0.0518 :	pthread_mutex_lock(mutex);
               :#else
               :	if (g_isthreaded)
               :		_SPINLOCK(&mutex->lock);
               :#endif
               :}
               :
               :static inline void
               :malloc_mutex_unlock(malloc_mutex_t *mutex)
               :{
               :
               :#if defined(WIN32)
               :	LeaveCriticalSection(mutex);
               :#elif defined(DARWIN)
               :	OSSpinLockUnlock(&mutex->lock);
               :#elif defined(USE_JEMALLOC)
    94  0.0396 :	pthread_mutex_unlock(mutex);
               :#else
               :	if (g_isthreaded)
               :		_SPINUNLOCK(&mutex->lock);
               :#endif
               :}
               :
               :static bool
               :malloc_spin_init(malloc_spinlock_t *lock)
               :{
               :#if defined(WIN32)
               :	if (g_isthreaded)
               :		if (! __crtInitCritSecAndSpinCount(lock, _CRT_SPINCOUNT))
               :			return (true);
               :#elif defined(DARWIN)
               :	lock->lock = OS_SPINLOCK_INIT;
               :#elif defined(LINUX_HOST)
               :	pthread_mutexattr_t attr;
               :	if (pthread_mutexattr_init(&attr) != 0)
               :		return (true);
               :	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
               :	if (pthread_mutex_init(lock, &attr) != 0) {
               :		pthread_mutexattr_destroy(&attr);
               :		return (true);
               :	}
               :	pthread_mutexattr_destroy(&attr);
               :#elif defined(USE_JEMALLOC)
               :	if (pthread_mutex_init(lock, NULL) != 0)
               :		return (true);
               :#else
               :	lock->lock = _SPINLOCK_INITIALIZER;
               :#endif
               :	return (false);
               :}
               :
               :static inline void
               :malloc_spin_lock(malloc_spinlock_t *lock)
               :{
               :
               :#if defined(WIN32)
               :	EnterCriticalSection(lock);
               :#elif defined(DARWIN)
               :	OSSpinLockLock(&lock->lock);
               :#elif defined(USE_JEMALLOC)
               :	pthread_mutex_lock(lock);
               :#else
               :	if (g_isthreaded)
               :		_SPINLOCK(&lock->lock);
               :#endif
               :}
               :
               :static inline void
               :malloc_spin_unlock(malloc_spinlock_t *lock)
               :{
               :#if defined(WIN32)
               :	LeaveCriticalSection(lock);
               :#elif defined(DARWIN)
               :	OSSpinLockUnlock(&lock->lock);
               :#elif defined(USE_JEMALLOC)
               :	pthread_mutex_unlock(lock);
               :#else
               :	if (g_isthreaded)
               :		_SPINUNLOCK(&lock->lock);
               :#endif
               :}
               :
               :/*
               : * End mutex.
               : */
               :/******************************************************************************/
               :/*
               : * Begin spin lock.  Spin locks here are actually adaptive mutexes that block
               : * after a period of spinning, because unbounded spinning would allow for
               : * priority inversion.
               : */
               :
               :#ifndef DARWIN
               :#  define	malloc_spin_init	malloc_mutex_init
               :#  define	malloc_spin_lock	malloc_mutex_lock
               :#  define	malloc_spin_unlock	malloc_mutex_unlock
               :#endif
               :
               :/*
               : * End spin lock.
               : */
               :
               :/******************************************************************************/
               :/*
               : * Begin Utility functions/macros.
               : */
               :
               :/* Return the chunk address for allocation address a. */
               :#define	CHUNK_ADDR2BASE(a)						\
               :	((void *)((uintptr_t)(a) & ~chunksize_mask))
               :
               :/* Return the chunk offset of address a. */
               :#define	CHUNK_ADDR2OFFSET(a)						\
               :	((size_t)((uintptr_t)(a) & chunksize_mask))
               :
               :/* Return the smallest chunk multiple that is >= s. */
               :#define	CHUNK_CEILING(s)						\
               :	(((s) + chunksize_mask) & ~chunksize_mask)
               :
               :/* Return the smallest cacheline multiple that is >= s. */
               :#define	CACHELINE_CEILING(s)						\
               :	(((s) + (CACHELINE - 1)) & ~(CACHELINE - 1))
               :
               :/* Return the smallest quantum multiple that is >= a. */
               :#define	QUANTUM_CEILING(a)						\
               :	(((a) + quantum_mask) & ~quantum_mask)
               :
               :/* Return the smallest pagesize multiple that is >= s. */
               :#define	PAGE_CEILING(s)							\
               :	(((s) + pagesize_mask) & ~pagesize_mask)
               :
               :/* Compute the smallest power of 2 that is >= x. */
               :static inline size_t
               :pow2_ceil(size_t x)
               :{
               :
    13  0.0055 :	x--;
    31  0.0131 :	x |= x >> 1;
     7  0.0030 :	x |= x >> 2;
     7  0.0030 :	x |= x >> 4;
    13  0.0055 :	x |= x >> 8;
     8  0.0034 :	x |= x >> 16;
               :#if (SIZEOF_PTR == 8)
               :	x |= x >> 32;
               :#endif
               :	x++;
               :	return (x);
               :}
               :
               :#if (defined(MALLOC_LAZY_FREE) || defined(MALLOC_BALANCE))
               :/*
               : * Use a simple linear congruential pseudo-random number generator:
               : *
               : *   prn(y) = (a*x + c) % m
               : *
               : * where the following constants ensure maximal period:
               : *
               : *   a == Odd number (relatively prime to 2^n), and (a-1) is a multiple of 4.
               : *   c == Odd number (relatively prime to 2^n).
               : *   m == 2^32
               : *
               : * See Knuth's TAOCP 3rd Ed., Vol. 2, pg. 17 for details on these constraints.
               : *
               : * This choice of m has the disadvantage that the quality of the bits is
               : * proportional to bit position.  For example. the lowest bit has a cycle of 2,
               : * the next has a cycle of 4, etc.  For this reason, we prefer to use the upper
               : * bits.
               : */
               :#  define PRN_DEFINE(suffix, var, a, c)					\
               :static inline void							\
               :sprn_##suffix(uint32_t seed)						\
               :{									\
               :	var = seed;							\
               :}									\
               :									\
               :static inline uint32_t							\
               :prn_##suffix(uint32_t lg_range)						\
               :{									\
               :	uint32_t ret, x;						\
               :									\
               :	assert(lg_range > 0);						\
               :	assert(lg_range <= 32);						\
               :									\
               :	x = (var * (a)) + (c);						\
               :	var = x;							\
               :	ret = x >> (32 - lg_range);					\
               :									\
               :	return (ret);							\
               :}
               :#  define SPRN(suffix, seed)	sprn_##suffix(seed)
               :#  define PRN(suffix, lg_range)	prn_##suffix(lg_range)
               :#endif
               :
               :/*
               : * Define PRNGs, one for each purpose, in order to avoid auto-correlation
               : * problems.
               : */
               :
               :#ifdef MALLOC_LAZY_FREE
               :/* Define the per-thread PRNG used for lazy deallocation. */
               :static __thread uint32_t lazy_free_x;
               :PRN_DEFINE(lazy_free, lazy_free_x, 12345, 12347)
               :#endif
               :
               :#ifdef MALLOC_BALANCE
               :/* Define the PRNG used for arena assignment. */
               :static __thread uint32_t balance_x;
               :PRN_DEFINE(balance, balance_x, 1297, 1301)
               :#endif
               :
               :#ifdef MALLOC_UTRACE
               :static int
               :utrace(const void *addr, size_t len)
               :{
               :	malloc_utrace_t *ut = (malloc_utrace_t *)addr;
               :
               :	assert(len == sizeof(malloc_utrace_t));
               :
               :	if (ut->p == NULL && ut->s == 0 && ut->r == NULL)
               :		malloc_printf("%d x USER malloc_init()\n", getpid());
               :	else if (ut->p == NULL && ut->r != NULL) {
               :		malloc_printf("%d x USER %p = malloc(%zu)\n", getpid(), ut->r,
               :		    ut->s);
               :	} else if (ut->p != NULL && ut->r != NULL) {
               :		malloc_printf("%d x USER %p = realloc(%p, %zu)\n", getpid(),
               :		    ut->r, ut->p, ut->s);
               :	} else
               :		malloc_printf("%d x USER free(%p)\n", getpid(), ut->p);
               :
               :	return (0);
               :}
               :#endif
               :
               :static inline const char *
               :_getprogname(void)
               :{
               :
               :	return ("<jemalloc>");
               :}
               :
               :static void
               :wrtmessage(const char *p1, const char *p2, const char *p3, const char *p4)
               :{
               :#ifndef WIN32
               :#define	_write	write
               :#endif
               :	_write(STDERR_FILENO, p1, (unsigned int) strlen(p1));
               :	_write(STDERR_FILENO, p2, (unsigned int) strlen(p2));
               :	_write(STDERR_FILENO, p3, (unsigned int) strlen(p3));
               :	_write(STDERR_FILENO, p4, (unsigned int) strlen(p4));
               :}
               :
               :#define _malloc_message malloc_message
               :
               :void	(*_malloc_message)(const char *p1, const char *p2, const char *p3,
               :	    const char *p4) = wrtmessage;
               :
               :#ifdef MALLOC_STATS
               :/*
               : * Print to stderr in such a way as to (hopefully) avoid memory allocation.
               : */
               :static void
               :malloc_printf(const char *format, ...)
               :{
               :	char buf[4096];
               :	va_list ap;
               :
               :	va_start(ap, format);
               :	vsnprintf(buf, sizeof(buf), format, ap);
               :	va_end(ap);
               :	_malloc_message(buf, "", "", "");
               :}
               :#endif
               :
               :/*
               : * We don't want to depend on vsnprintf() for production builds, since that can
               : * cause unnecessary bloat for static binaries.  umax2s() provides minimal
               : * integer printing functionality, so that malloc_printf() use can be limited to
               : * MALLOC_STATS code.
               : */
               :#define	UMAX2S_BUFSIZE	21
               :static char *
               :umax2s(uintmax_t x, char *s)
               :{
               :	unsigned i;
               :
               :	/* Make sure UMAX2S_BUFSIZE is large enough. */
               :	assert(sizeof(uintmax_t) <= 8);
               :
               :	i = UMAX2S_BUFSIZE - 1;
               :	s[i] = '\0';
               :	do {
               :		i--;
               :		s[i] = "0123456789"[x % 10];
               :		x /= 10;
               :	} while (x > 0);
               :
               :	return (&s[i]);
               :}
               :
               :/******************************************************************************/
               :
               :#ifdef MALLOC_DSS
               :static bool
               :base_pages_alloc_dss(size_t minsize)
               :{
               :
               :	/*
               :	 * Do special DSS allocation here, since base allocations don't need to
               :	 * be chunk-aligned.
               :	 */
               :	malloc_mutex_lock(&dss_mtx);
               :	if (dss_prev != (void *)-1) {
               :		intptr_t incr;
               :		size_t csize = CHUNK_CEILING(minsize);
               :
               :		do {
               :			/* Get the current end of the DSS. */
               :			dss_max = sbrk(0);
               :
               :			/*
               :			 * Calculate how much padding is necessary to
               :			 * chunk-align the end of the DSS.  Don't worry about
               :			 * dss_max not being chunk-aligned though.
               :			 */
               :			incr = (intptr_t)chunksize
               :			    - (intptr_t)CHUNK_ADDR2OFFSET(dss_max);
               :			assert(incr >= 0);
               :			if ((size_t)incr < minsize)
               :				incr += csize;
               :
               :			dss_prev = sbrk(incr);
               :			if (dss_prev == dss_max) {
               :				/* Success. */
               :				dss_max = (void *)((intptr_t)dss_prev + incr);
               :				base_pages = dss_prev;
               :				base_next_addr = base_pages;
               :				base_past_addr = dss_max;
               :#ifdef MALLOC_STATS
               :				base_mapped += incr;
               :#endif
               :				malloc_mutex_unlock(&dss_mtx);
               :				return (false);
               :			}
               :		} while (dss_prev != (void *)-1);
               :	}
               :	malloc_mutex_unlock(&dss_mtx);
               :
               :	return (true);
               :}
               :#endif
               :
               :static bool
               :base_pages_alloc_mmap(size_t minsize)
               :{
               :	size_t csize;
               :
               :	assert(minsize != 0);
               :	csize = PAGE_CEILING(minsize);
               :	base_pages = pages_map(NULL, csize);
               :	if (base_pages == NULL)
               :		return (true);
               :	base_next_addr = base_pages;
               :	base_past_addr = (void *)((uintptr_t)base_pages + csize);
               :#ifdef MALLOC_STATS
               :	base_mapped += csize;
               :#endif
               :
               :	return (false);
               :}
               :
               :static bool
               :base_pages_alloc(size_t minsize)
               :{
               :
               :#ifdef MALLOC_DSS
               :	if (opt_dss) {
               :		if (base_pages_alloc_dss(minsize) == false)
               :			return (false);
               :	}
               :
               :	if (opt_mmap && minsize != 0)
               :#endif
               :	{
               :		if (base_pages_alloc_mmap(minsize) == false)
               :			return (false);
               :	}
               :
               :	return (true);
               :}
               :
               :static void *
               :base_alloc(size_t size)
               :{
               :	void *ret;
               :	size_t csize;
               :
               :	/* Round size up to nearest multiple of the cacheline size. */
               :	csize = CACHELINE_CEILING(size);
               :
               :	malloc_mutex_lock(&base_mtx);
               :	/* Make sure there's enough space for the allocation. */
               :	if ((uintptr_t)base_next_addr + csize > (uintptr_t)base_past_addr) {
               :		if (base_pages_alloc(csize))
               :			return (NULL);
               :	}
               :	/* Allocate. */
               :	ret = base_next_addr;
               :	base_next_addr = (void *)((uintptr_t)base_next_addr + csize);
               :	malloc_mutex_unlock(&base_mtx);
               :
               :	return (ret);
               :}
               :
               :static void *
               :base_calloc(size_t number, size_t size)
               :{
               :	void *ret;
               :
               :	ret = base_alloc(number * size);
               :	memset(ret, 0, number * size);
               :
               :	return (ret);
               :}
               :
               :static extent_node_t *
               :base_node_alloc(void)
               :{
               :	extent_node_t *ret;
               :
               :	malloc_mutex_lock(&base_mtx);
               :	if (base_nodes != NULL) {
               :		ret = base_nodes;
               :		base_nodes = *(extent_node_t **)ret;
               :		malloc_mutex_unlock(&base_mtx);
               :	} else {
               :		malloc_mutex_unlock(&base_mtx);
               :		ret = (extent_node_t *)base_alloc(sizeof(extent_node_t));
               :	}
               :
               :	return (ret);
               :}
               :
               :static void
               :base_node_dealloc(extent_node_t *node)
               :{
               :
               :	malloc_mutex_lock(&base_mtx);
               :	*(extent_node_t **)node = base_nodes;
               :	base_nodes = node;
               :	malloc_mutex_unlock(&base_mtx);
               :}
               :
               :/******************************************************************************/
               :
               :#ifdef MALLOC_STATS
               :static void
               :stats_print(arena_t *arena)
               :{
               :	unsigned i, gap_start;
               :
               :#ifdef WIN32
               :	malloc_printf("dirty: %Iu page%s dirty, %I64u sweep%s,"
               :	    " %I64u madvise%s, %I64u page%s purged\n",
               :	    arena->ndirty, arena->ndirty == 1 ? "" : "s",
               :	    arena->stats.npurge, arena->stats.npurge == 1 ? "" : "s",
               :	    arena->stats.nmadvise, arena->stats.nmadvise == 1 ? "" : "s",
               :	    arena->stats.purged, arena->stats.purged == 1 ? "" : "s");
               :#  ifdef MALLOC_DECOMMIT
               :	malloc_printf("decommit: %I64u decommit%s, %I64u commit%s,"
               :	    " %I64u page%s decommitted\n",
               :	    arena->stats.ndecommit, (arena->stats.ndecommit == 1) ? "" : "s",
               :	    arena->stats.ncommit, (arena->stats.ncommit == 1) ? "" : "s",
               :	    arena->stats.decommitted,
               :	    (arena->stats.decommitted == 1) ? "" : "s");
               :#  endif
               :
               :	malloc_printf("            allocated      nmalloc      ndalloc\n");
               :	malloc_printf("small:   %12Iu %12I64u %12I64u\n",
               :	    arena->stats.allocated_small, arena->stats.nmalloc_small,
               :	    arena->stats.ndalloc_small);
               :	malloc_printf("large:   %12Iu %12I64u %12I64u\n",
               :	    arena->stats.allocated_large, arena->stats.nmalloc_large,
               :	    arena->stats.ndalloc_large);
               :	malloc_printf("total:   %12Iu %12I64u %12I64u\n",
               :	    arena->stats.allocated_small + arena->stats.allocated_large,
               :	    arena->stats.nmalloc_small + arena->stats.nmalloc_large,
               :	    arena->stats.ndalloc_small + arena->stats.ndalloc_large);
               :	malloc_printf("mapped:  %12Iu\n", arena->stats.mapped);
               :#else
               :	malloc_printf("dirty: %zu page%s dirty, %llu sweep%s,"
               :	    " %llu madvise%s, %llu page%s purged\n",
               :	    arena->ndirty, arena->ndirty == 1 ? "" : "s",
               :	    arena->stats.npurge, arena->stats.npurge == 1 ? "" : "s",
               :	    arena->stats.nmadvise, arena->stats.nmadvise == 1 ? "" : "s",
               :	    arena->stats.purged, arena->stats.purged == 1 ? "" : "s");
               :#  ifdef MALLOC_DECOMMIT
               :	malloc_printf("decommit: %llu decommit%s, %llu commit%s,"
               :	    " %llu page%s decommitted\n",
               :	    arena->stats.ndecommit, (arena->stats.ndecommit == 1) ? "" : "s",
               :	    arena->stats.ncommit, (arena->stats.ncommit == 1) ? "" : "s",
               :	    arena->stats.decommitted,
               :	    (arena->stats.decommitted == 1) ? "" : "s");
               :#  endif
               :
               :	malloc_printf("            allocated      nmalloc      ndalloc\n");
               :	malloc_printf("small:   %12zu %12llu %12llu\n",
               :	    arena->stats.allocated_small, arena->stats.nmalloc_small,
               :	    arena->stats.ndalloc_small);
               :	malloc_printf("large:   %12zu %12llu %12llu\n",
               :	    arena->stats.allocated_large, arena->stats.nmalloc_large,
               :	    arena->stats.ndalloc_large);
               :	malloc_printf("total:   %12zu %12llu %12llu\n",
               :	    arena->stats.allocated_small + arena->stats.allocated_large,
               :	    arena->stats.nmalloc_small + arena->stats.nmalloc_large,
               :	    arena->stats.ndalloc_small + arena->stats.ndalloc_large);
               :	malloc_printf("mapped:  %12zu\n", arena->stats.mapped);
               :#endif
               :	malloc_printf("bins:     bin   size regs pgs  requests   newruns"
               :	    "    reruns maxruns curruns\n");
               :	for (i = 0, gap_start = UINT_MAX; i < ntbins + nqbins + nsbins; i++) {
               :		if (arena->bins[i].stats.nrequests == 0) {
               :			if (gap_start == UINT_MAX)
               :				gap_start = i;
               :		} else {
               :			if (gap_start != UINT_MAX) {
               :				if (i > gap_start + 1) {
               :					/* Gap of more than one size class. */
               :					malloc_printf("[%u..%u]\n",
               :					    gap_start, i - 1);
               :				} else {
               :					/* Gap of one size class. */
               :					malloc_printf("[%u]\n", gap_start);
               :				}
               :				gap_start = UINT_MAX;
               :			}
               :			malloc_printf(
               :#if defined(WIN32)
               :			    "%13u %1s %4u %4u %3u %9I64u %9I64u"
               :			    " %9I64u %7u %7u\n",
               :#else
               :			    "%13u %1s %4u %4u %3u %9llu %9llu"
               :			    " %9llu %7lu %7lu\n",
               :#endif
               :			    i,
               :			    i < ntbins ? "T" : i < ntbins + nqbins ? "Q" : "S",
               :			    arena->bins[i].reg_size,
               :			    arena->bins[i].nregs,
               :			    arena->bins[i].run_size >> pagesize_2pow,
               :			    arena->bins[i].stats.nrequests,
               :			    arena->bins[i].stats.nruns,
               :			    arena->bins[i].stats.reruns,
               :			    arena->bins[i].stats.highruns,
               :			    arena->bins[i].stats.curruns);
               :		}
               :	}
               :	if (gap_start != UINT_MAX) {
               :		if (i > gap_start + 1) {
               :			/* Gap of more than one size class. */
               :			malloc_printf("[%u..%u]\n", gap_start, i - 1);
               :		} else {
               :			/* Gap of one size class. */
               :			malloc_printf("[%u]\n", gap_start);
               :		}
               :	}
               :}
               :#endif
               :
               :/*
               : * End Utility functions/macros.
               : */
               :/******************************************************************************/
               :/*
               : * Begin extent tree code.
               : */
               :
               :static inline int
               :extent_szad_comp(extent_node_t *a, extent_node_t *b)
               :{
               :	int ret;
               :	size_t a_size = a->size;
    65  0.0274 :	size_t b_size = b->size;
               :
   359  0.1513 :	ret = (a_size > b_size) - (a_size < b_size);
    42  0.0177 :	if (ret == 0) {
    43  0.0181 :		uintptr_t a_addr = (uintptr_t)a->addr;
               :		uintptr_t b_addr = (uintptr_t)b->addr;
               :
    39  0.0164 :		ret = (a_addr > b_addr) - (a_addr < b_addr);
               :	}
               :
               :	return (ret);
               :}
               :
               :/* Generate red-black tree code for size/address-ordered extents. */
  1723  0.7263 :RB_GENERATE_STATIC(extent_tree_szad_s, extent_node_s, link_szad, /* extent_tree_szad_s_RB_REMOVE    685  0.2887, extent_tree_szad_s_RB_INSERT   1320  0.5564, total:   2005  0.8452 */
               :    extent_szad_comp)
               :
               :static inline int
               :extent_ad_comp(extent_node_t *a, extent_node_t *b)
               :{
               :	uintptr_t a_addr = (uintptr_t)a->addr;
   196  0.0826 :	uintptr_t b_addr = (uintptr_t)b->addr;
               :
  1936  0.8161 :	return ((a_addr > b_addr) - (a_addr < b_addr));
               :}
               :
               :/* Generate red-black tree code for address-ordered extents. */
  5107  2.1527 :RB_GENERATE_STATIC(extent_tree_ad_s, extent_node_s, link_ad, extent_ad_comp) /* extent_tree_ad_s_RB_REMOVE   1389  0.5855, extent_tree_ad_s_RB_INSERT   3271  1.3788, total:   4660  1.9643 */
               :
               :
               :/*
               : * End extent tree code.
               : */
               :/******************************************************************************/
               :/*
               : * Begin chunk management functions.
               : */
               :
               :#ifdef WIN32
               :static void *
               :pages_map(void *addr, size_t size)
               :{
               :	void *ret;
               :
               :	ret = VirtualAlloc(addr, size, MEM_COMMIT | MEM_RESERVE,
               :	    PAGE_READWRITE);
               :
               :	return (ret);
               :}
               :
               :static void
               :pages_unmap(void *addr, size_t size)
               :{
               :
               :	if (VirtualFree(addr, 0, MEM_RELEASE) == 0) {
               :		_malloc_message(_getprogname(),
               :		    ": (malloc) Error in VirtualFree()\n", "", "");
               :		if (opt_abort)
               :			abort();
               :	}
               :}
               :#elif (defined(DARWIN))
               :static void *
               :pages_map(void *addr, size_t size)
               :{
               :	void *ret;
               :	kern_return_t err;
               :	int flags;
               :
               :	if (addr != NULL) {
               :		ret = addr;
               :		flags = 0;
               :	} else
               :		flags = VM_FLAGS_ANYWHERE;
               :
               :	err = vm_allocate((vm_map_t)mach_task_self(), (vm_address_t *)&ret,
               :	    (vm_size_t)size, flags);
               :	if (err != KERN_SUCCESS)
               :		ret = NULL;
               :
               :	assert(ret == NULL || (addr == NULL && ret != addr)
               :	    || (addr != NULL && ret == addr));
               :	return (ret);
               :}
               :
               :static void
               :pages_unmap(void *addr, size_t size)
               :{
               :	kern_return_t err;
               :
               :	err = vm_deallocate((vm_map_t)mach_task_self(), (vm_address_t)addr,
               :	    (vm_size_t)size);
               :	if (err != KERN_SUCCESS) {
               :		malloc_message(_getprogname(),
               :		    ": (malloc) Error in vm_deallocate(): ",
               :		    mach_error_string(err), "\n");
               :		if (opt_abort)
               :			abort();
               :	}
               :}
               :
               :#define	VM_COPY_MIN (pagesize << 5)
               :static inline void
               :pages_copy(void *dest, const void *src, size_t n)
               :{
               :
               :	assert((void *)((uintptr_t)dest & ~pagesize_mask) == dest);
               :	assert(n >= VM_COPY_MIN);
               :	assert((void *)((uintptr_t)src & ~pagesize_mask) == src);
               :
               :	vm_copy(mach_task_self(), (vm_address_t)src, (vm_size_t)n,
               :	    (vm_address_t)dest);
               :}
               :#else /* DARWIN */
               :static void *
               :pages_map(void *addr, size_t size)
               :{
               :	void *ret;
               :
               :	/*
               :	 * We don't use MAP_FIXED here, because it can cause the *replacement*
               :	 * of existing mappings, and we only want to create new mappings.
               :	 */
               :	ret = mmap(addr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON,
               :	    -1, 0);
               :	assert(ret != NULL);
               :
               :	if (ret == MAP_FAILED)
               :		ret = NULL;
               :	else if (addr != NULL && ret != addr) {
               :		/*
               :		 * We succeeded in mapping memory, but not in the right place.
               :		 */
               :		if (munmap(ret, size) == -1) {
               :			char buf[STRERROR_BUF];
               :
               :			strerror_r(errno, buf, sizeof(buf));
               :			_malloc_message(_getprogname(),
               :			    ": (malloc) Error in munmap(): ", buf, "\n");
               :			if (opt_abort)
               :				abort();
               :		}
               :		ret = NULL;
               :	}
               :
               :	assert(ret == NULL || (addr == NULL && ret != addr)
               :	    || (addr != NULL && ret == addr));
               :	return (ret);
               :}
               :
               :static void
               :pages_unmap(void *addr, size_t size)
               :{
               :
               :	if (munmap(addr, size) == -1) {
               :		char buf[STRERROR_BUF];
               :
               :		strerror_r(errno, buf, sizeof(buf));
               :		_malloc_message(_getprogname(),
               :		    ": (malloc) Error in munmap(): ", buf, "\n");
               :		if (opt_abort)
               :			abort();
               :	}
               :}
               :#endif
               :
               :#ifdef MALLOC_DECOMMIT
               :static inline void
               :pages_decommit(void *addr, size_t size)
               :{
               :
               :#ifdef WIN32
               :	VirtualFree(addr, size, MEM_DECOMMIT);
               :#else
               :	if (mmap(addr, size, PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1,
               :	    0) == MAP_FAILED)
               :		abort();
               :#endif
               :}
               :
               :static inline void
               :pages_commit(void *addr, size_t size)
               :{
               :
               :#  ifdef WIN32
               :	VirtualAlloc(addr, size, MEM_COMMIT, PAGE_READWRITE);
               :#  else
               :	if (mmap(addr, size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_PRIVATE |
               :	    MAP_ANON, -1, 0) == MAP_FAILED)
               :		abort();
               :#  endif
               :}
               :#endif
               :
               :#ifdef MALLOC_DSS
               :static void *
               :chunk_alloc_dss(size_t size)
               :{
               :
               :	malloc_mutex_lock(&dss_mtx);
               :	if (dss_prev != (void *)-1) {
               :		intptr_t incr;
               :
               :		/*
               :		 * The loop is necessary to recover from races with other
               :		 * threads that are using the DSS for something other than
               :		 * malloc.
               :		 */
               :		do {
               :			void *ret;
               :
               :			/* Get the current end of the DSS. */
               :			dss_max = sbrk(0);
               :
               :			/*
               :			 * Calculate how much padding is necessary to
               :			 * chunk-align the end of the DSS.
               :			 */
               :			incr = (intptr_t)size
               :			    - (intptr_t)CHUNK_ADDR2OFFSET(dss_max);
               :			if (incr == (intptr_t)size)
               :				ret = dss_max;
               :			else {
               :				ret = (void *)((intptr_t)dss_max + incr);
               :				incr += size;
               :			}
               :
               :			dss_prev = sbrk(incr);
               :			if (dss_prev == dss_max) {
               :				/* Success. */
               :				dss_max = (void *)((intptr_t)dss_prev + incr);
               :				malloc_mutex_unlock(&dss_mtx);
               :				return (ret);
               :			}
               :		} while (dss_prev != (void *)-1);
               :	}
               :	malloc_mutex_unlock(&dss_mtx);
               :
               :	return (NULL);
               :}
               :
               :static void *
               :chunk_recycle_dss(size_t size, bool zero)
               :{
               :	extent_node_t *node, key;
               :
               :	key.addr = NULL;
               :	key.size = size;
               :	malloc_mutex_lock(&dss_mtx);
               :	node = RB_NFIND(extent_tree_szad_s, &dss_chunks_szad, &key);
               :	if (node != NULL) {
               :		void *ret = node->addr;
               :
               :		/* Remove node from the tree. */
               :		RB_REMOVE(extent_tree_szad_s, &dss_chunks_szad, node);
               :		if (node->size == size) {
               :			RB_REMOVE(extent_tree_ad_s, &dss_chunks_ad, node);
               :			base_node_dealloc(node);
               :		} else {
               :			/*
               :			 * Insert the remainder of node's address range as a
               :			 * smaller chunk.  Its position within dss_chunks_ad
               :			 * does not change.
               :			 */
               :			assert(node->size > size);
               :			node->addr = (void *)((uintptr_t)node->addr + size);
               :			node->size -= size;
               :			RB_INSERT(extent_tree_szad_s, &dss_chunks_szad, node);
               :		}
               :		malloc_mutex_unlock(&dss_mtx);
               :
               :		if (zero)
               :			memset(ret, 0, size);
               :		return (ret);
               :	}
               :	malloc_mutex_unlock(&dss_mtx);
               :
               :	return (NULL);
               :}
               :#endif
               :
               :#ifdef WIN32
               :static inline void *
               :chunk_alloc_mmap(size_t size)
               :{
               :	void *ret;
               :	size_t offset;
               :
               :	/*
               :	 * Windows requires that there be a 1:1 mapping between VM
               :	 * allocation/deallocation operations.  Therefore, take care here to
               :	 * acquire the final result via one mapping operation.  This means
               :	 * unmapping any preliminary result that is not correctly aligned.
               :	 */
               :
               :	ret = pages_map(NULL, size);
               :	if (ret == NULL)
               :		return (NULL);
               :
               :	offset = CHUNK_ADDR2OFFSET(ret);
               :	if (offset != 0) {
               :		/* Deallocate, then try to allocate at (ret + size - offset). */
               :		pages_unmap(ret, size);
               :		ret = pages_map((void *)((uintptr_t)ret + size - offset), size);
               :		while (ret == NULL) {
               :			/*
               :			 * Over-allocate in order to map a memory region that
               :			 * is definitely large enough.
               :			 */
               :			ret = pages_map(NULL, size + chunksize);
               :			if (ret == NULL)
               :				return (NULL);
               :			/*
               :			 * Deallocate, then allocate the correct size, within
               :			 * the over-sized mapping.
               :			 */
               :			offset = CHUNK_ADDR2OFFSET(ret);
               :			pages_unmap(ret, size + chunksize);
               :			if (offset == 0)
               :				ret = pages_map(ret, size);
               :			else {
               :				ret = pages_map((void *)((uintptr_t)ret +
               :				    chunksize - offset), size);
               :			}
               :			/*
               :			 * Failure here indicates a race with another thread, so
               :			 * try again.
               :			 */
               :		}
               :	}
               :
               :	return (ret);
               :}
               :#else
               :static inline void *
               :chunk_alloc_mmap(size_t size)
               :{
               :	void *ret;
               :	size_t offset;
               :
               :	/*
               :	 * Ideally, there would be a way to specify alignment to mmap() (like
               :	 * NetBSD has), but in the absence of such a feature, we have to work
               :	 * hard to efficiently create aligned mappings.  The reliable, but
               :	 * expensive method is to create a mapping that is over-sized, then
               :	 * trim the excess.  However, that always results in at least one call
               :	 * to pages_unmap().
               :	 *
               :	 * A more optimistic approach is to try mapping precisely the right
               :	 * amount, then try to append another mapping if alignment is off.  In
               :	 * practice, this works out well as long as the application is not
               :	 * interleaving mappings via direct mmap() calls.  If we do run into a
               :	 * situation where there is an interleaved mapping and we are unable to
               :	 * extend an unaligned mapping, our best option is to momentarily
               :	 * revert to the reliable-but-expensive method.  This will tend to
               :	 * leave a gap in the memory map that is too small to cause later
               :	 * problems for the optimistic method.
               :	 */
               :
               :	ret = pages_map(NULL, size);
               :	if (ret == NULL)
               :		return (NULL);
               :
               :	offset = CHUNK_ADDR2OFFSET(ret);
               :	if (offset != 0) {
               :		/* Try to extend chunk boundary. */
               :		if (pages_map((void *)((uintptr_t)ret + size),
               :		    chunksize - offset) == NULL) {
               :			/*
               :			 * Extension failed.  Clean up, then revert to the
               :			 * reliable-but-expensive method.
               :			 */
               :			pages_unmap(ret, size);
               :
               :			/* Beware size_t wrap-around. */
               :			if (size + chunksize <= size)
               :				return NULL;
               :
               :			ret = pages_map(NULL, size + chunksize);
               :			if (ret == NULL)
               :				return (NULL);
               :
               :			/* Clean up unneeded leading/trailing space. */
               :			offset = CHUNK_ADDR2OFFSET(ret);
               :			if (offset != 0) {
               :				/* Leading space. */
               :				pages_unmap(ret, chunksize - offset);
               :
               :				ret = (void *)((uintptr_t)ret +
               :				    (chunksize - offset));
               :
               :				/* Trailing space. */
               :				pages_unmap((void *)((uintptr_t)ret + size),
               :				    offset);
               :			} else {
               :				/* Trailing space only. */
               :				pages_unmap((void *)((uintptr_t)ret + size),
               :				    chunksize);
               :			}
               :		} else {
               :			/* Clean up unneeded leading space. */
               :			pages_unmap(ret, chunksize - offset);
               :			ret = (void *)((uintptr_t)ret + (chunksize - offset));
               :		}
               :	}
               :
               :	return (ret);
               :}
               :#endif
               :
               :static void *
               :chunk_alloc(size_t size, bool zero)
               :{ /* chunk_alloc total:      1 4.2e-04 */
               :	void *ret;
               :
               :	assert(size != 0);
               :	assert((size & chunksize_mask) == 0);
               :
               :#ifdef MALLOC_DSS
               :	if (opt_dss) {
               :		ret = chunk_recycle_dss(size, zero);
               :		if (ret != NULL) {
               :			goto RETURN;
               :		}
               :
               :		ret = chunk_alloc_dss(size);
               :		if (ret != NULL)
               :			goto RETURN;
               :	}
               :
               :	if (opt_mmap)
               :#endif
               :	{
               :		ret = chunk_alloc_mmap(size);
               :		if (ret != NULL)
               :			goto RETURN;
               :	}
               :
               :	/* All strategies for allocation failed. */
               :	ret = NULL;
               :RETURN:
               :#ifdef MALLOC_STATS
               :	if (ret != NULL) {
               :		stats_chunks.nchunks += (size / chunksize);
               :		stats_chunks.curchunks += (size / chunksize);
               :	}
               :	if (stats_chunks.curchunks > stats_chunks.highchunks)
               :		stats_chunks.highchunks = stats_chunks.curchunks;
               :#endif
               :
               :	assert(CHUNK_ADDR2BASE(ret) == ret);
               :	return (ret);
     1 4.2e-04 :}
               :
               :#ifdef MALLOC_DSS
               :static extent_node_t *
               :chunk_dealloc_dss_record(void *chunk, size_t size)
               :{
               :	extent_node_t *node, *prev, key;
               :
               :	key.addr = (void *)((uintptr_t)chunk + size);
               :	node = RB_NFIND(extent_tree_ad_s, &dss_chunks_ad, &key);
               :	/* Try to coalesce forward. */
               :	if (node != NULL && node->addr == key.addr) {
               :		/*
               :		 * Coalesce chunk with the following address range.  This does
               :		 * not change the position within dss_chunks_ad, so only
               :		 * remove/insert from/into dss_chunks_szad.
               :		 */
               :		RB_REMOVE(extent_tree_szad_s, &dss_chunks_szad, node);
               :		node->addr = chunk;
               :		node->size += size;
               :		RB_INSERT(extent_tree_szad_s, &dss_chunks_szad, node);
               :	} else {
               :		/*
               :		 * Coalescing forward failed, so insert a new node.  Drop
               :		 * dss_mtx during node allocation, since it is possible that a
               :		 * new base chunk will be allocated.
               :		 */
               :		malloc_mutex_unlock(&dss_mtx);
               :		node = base_node_alloc();
               :		malloc_mutex_lock(&dss_mtx);
               :		if (node == NULL)
               :			return (NULL);
               :		node->addr = chunk;
               :		node->size = size;
               :		RB_INSERT(extent_tree_ad_s, &dss_chunks_ad, node);
               :		RB_INSERT(extent_tree_szad_s, &dss_chunks_szad, node);
               :	}
               :
               :	/* Try to coalesce backward. */
               :	prev = RB_PREV(extent_tree_ad_s, &dss_chunks_ad, node);
               :	if (prev != NULL && (void *)((uintptr_t)prev->addr + prev->size) ==
               :	    chunk) {
               :		/*
               :		 * Coalesce chunk with the previous address range.  This does
               :		 * not change the position within dss_chunks_ad, so only
               :		 * remove/insert node from/into dss_chunks_szad.
               :		 */
               :		RB_REMOVE(extent_tree_szad_s, &dss_chunks_szad, prev);
               :		RB_REMOVE(extent_tree_ad_s, &dss_chunks_ad, prev);
               :
               :		RB_REMOVE(extent_tree_szad_s, &dss_chunks_szad, node);
               :		node->addr = prev->addr;
               :		node->size += prev->size;
               :		RB_INSERT(extent_tree_szad_s, &dss_chunks_szad, node);
               :
               :		base_node_dealloc(prev);
               :	}
               :
               :	return (node);
               :}
               :
               :static bool
               :chunk_dealloc_dss(void *chunk, size_t size)
               :{
               :
               :	malloc_mutex_lock(&dss_mtx);
               :	if ((uintptr_t)chunk >= (uintptr_t)dss_base
               :	    && (uintptr_t)chunk < (uintptr_t)dss_max) {
               :		extent_node_t *node;
               :
               :		/* Try to coalesce with other unused chunks. */
               :		node = chunk_dealloc_dss_record(chunk, size);
               :		if (node != NULL) {
               :			chunk = node->addr;
               :			size = node->size;
               :		}
               :
               :		/* Get the current end of the DSS. */
               :		dss_max = sbrk(0);
               :
               :		/*
               :		 * Try to shrink the DSS if this chunk is at the end of the
               :		 * DSS.  The sbrk() call here is subject to a race condition
               :		 * with threads that use brk(2) or sbrk(2) directly, but the
               :		 * alternative would be to leak memory for the sake of poorly
               :		 * designed multi-threaded programs.
               :		 */
               :		if ((void *)((uintptr_t)chunk + size) == dss_max
               :		    && (dss_prev = sbrk(-(intptr_t)size)) == dss_max) {
               :			/* Success. */
               :			dss_max = (void *)((intptr_t)dss_prev - (intptr_t)size);
               :
     1 4.2e-04 :			if (node != NULL) {
               :				RB_REMOVE(extent_tree_szad_s, &dss_chunks_szad,
               :				    node);
               :				RB_REMOVE(extent_tree_ad_s, &dss_chunks_ad,
               :				    node);
               :				base_node_dealloc(node);
               :			}
               :			malloc_mutex_unlock(&dss_mtx);
               :		} else {
               :			malloc_mutex_unlock(&dss_mtx);
               :#ifdef WIN32
               :			VirtualAlloc(chunk, size, MEM_RESET, PAGE_READWRITE);
               :#elif (defined(DARWIN))
               :			mmap(chunk, size, PROT_READ | PROT_WRITE, MAP_PRIVATE
               :			    | MAP_ANON | MAP_FIXED, -1, 0);
               :#else
               :			madvise(chunk, size, MADV_FREE);
               :#endif
               :		}
               :
               :		return (false);
               :	}
               :	malloc_mutex_unlock(&dss_mtx);
               :
               :	return (true);
               :}
               :#endif
               :
               :static void
               :chunk_dealloc_mmap(void *chunk, size_t size)
               :{
               :
               :	pages_unmap(chunk, size);
               :}
               :
               :static void
               :chunk_dealloc(void *chunk, size_t size)
               :{ /* chunk_dealloc total:      3  0.0013 */
               :
               :	assert(chunk != NULL);
               :	assert(CHUNK_ADDR2BASE(chunk) == chunk);
               :	assert(size != 0);
               :	assert((size & chunksize_mask) == 0);
               :
               :#ifdef MALLOC_STATS
               :	stats_chunks.curchunks -= (size / chunksize);
               :#endif
               :
               :#ifdef MALLOC_DSS
               :	if (opt_dss) {
               :		if (chunk_dealloc_dss(chunk, size) == false)
               :			return;
               :	}
               :
               :	if (opt_mmap)
               :#endif
               :		chunk_dealloc_mmap(chunk, size);
     2 8.4e-04 :}
               :
               :/*
               : * End chunk management functions.
               : */
               :/******************************************************************************/
               :/*
               : * Begin arena.
               : */
               :
               :/*
               : * Choose an arena based on a per-thread value (fast-path code, calls slow-path
               : * code if necessary).
               : */
               :static inline arena_t *
               :choose_arena(void)
     1 4.2e-04 :{ /* choose_arena total:      2 8.4e-04 */
               :	arena_t *ret;
               :
               :	/*
               :	 * We can only use TLS if this is a PIC library, since for the static
               :	 * library version, libc's malloc is used by TLS allocation, which
               :	 * introduces a bootstrapping issue.
               :	 */
               :#ifndef NO_TLS
               :	if (g_isthreaded == false) {
               :	    /* Avoid the overhead of TLS for single-threaded operation. */
               :	    return (arenas[0]);
               :	}
               :
               :#  ifdef WIN32
               :	ret = TlsGetValue(tlsIndex);
               :#  else
    25  0.0105 :	ret = arenas_map;
               :#  endif
               :
    13  0.0055 :	if (ret == NULL) {
               :		ret = choose_arena_hard();
               :		assert(ret != NULL);
               :	}
               :#else
               :	if (g_isthreaded && narenas > 1) {
               :		unsigned long ind;
               :
               :		/*
               :		 * Hash _pthread_self() to one of the arenas.  There is a prime
               :		 * number of arenas, so this has a reasonable chance of
               :		 * working.  Even so, the hashing can be easily thwarted by
               :		 * inconvenient _pthread_self() values.  Without specific
               :		 * knowledge of how _pthread_self() calculates values, we can't
               :		 * easily do much better than this.
               :		 */
               :		ind = (unsigned long) _pthread_self() % narenas;
               :
               :		/*
               :		 * Optimistially assume that arenas[ind] has been initialized.
               :		 * At worst, we find out that some other thread has already
               :		 * done so, after acquiring the lock in preparation.  Note that
               :		 * this lazy locking also has the effect of lazily forcing
               :		 * cache coherency; without the lock acquisition, there's no
               :		 * guarantee that modification of arenas[ind] by another thread
               :		 * would be seen on this CPU for an arbitrary amount of time.
               :		 *
               :		 * In general, this approach to modifying a synchronized value
               :		 * isn't a good idea, but in this case we only ever modify the
               :		 * value once, so things work out well.
               :		 */
               :		ret = arenas[ind];
               :		if (ret == NULL) {
               :			/*
               :			 * Avoid races with another thread that may have already
               :			 * initialized arenas[ind].
               :			 */
               :			malloc_spin_lock(&arenas_lock);
               :			if (arenas[ind] == NULL)
               :				ret = arenas_extend((unsigned)ind);
               :			else
               :				ret = arenas[ind];
               :			malloc_spin_unlock(&arenas_lock);
               :		}
               :	} else
               :		ret = arenas[0];
               :#endif
               :
               :	assert(ret != NULL);
               :	return (ret);
     1 4.2e-04 :}
               :
               :#ifndef NO_TLS
               :/*
               : * Choose an arena based on a per-thread value (slow-path code only, called
               : * only by choose_arena()).
               : */
               :static arena_t *
               :choose_arena_hard(void)
               :{
               :	arena_t *ret;
               :
               :	assert(g_isthreaded);
               :
               :#ifdef MALLOC_LAZY_FREE
               :	/*
               :	 * Seed the PRNG used for lazy deallocation.  Since seeding only occurs
               :	 * on the first allocation by a thread, it is possible for a thread to
               :	 * deallocate before seeding.  This is not a critical issue though,
               :	 * since it is extremely unusual for an application to to use threads
               :	 * that deallocate but *never* allocate, and because even if seeding
               :	 * never occurs for multiple threads, they will tend to drift apart
               :	 * unless some aspect of the application forces deallocation
               :	 * synchronization.
               :	 */
               :	SPRN(lazy_free, (uint32_t)(uintptr_t)(_pthread_self()));
               :#endif
               :
               :#ifdef MALLOC_BALANCE
               :	/*
               :	 * Seed the PRNG used for arena load balancing.  We can get away with
               :	 * using the same seed here as for the lazy_free PRNG without
               :	 * introducing autocorrelation because the PRNG parameters are
               :	 * distinct.
               :	 */
               :	SPRN(balance, (uint32_t)(uintptr_t)(_pthread_self()));
               :#endif
               :
               :	if (narenas > 1) {
               :#ifdef MALLOC_BALANCE
               :		unsigned ind;
               :
               :		ind = PRN(balance, narenas_2pow);
               :		if ((ret = arenas[ind]) == NULL) {
               :			malloc_spin_lock(&arenas_lock);
               :			if ((ret = arenas[ind]) == NULL)
               :				ret = arenas_extend(ind);
               :			malloc_spin_unlock(&arenas_lock);
               :		}
               :#else
               :		malloc_spin_lock(&arenas_lock);
               :		if ((ret = arenas[next_arena]) == NULL)
               :			ret = arenas_extend(next_arena);
               :		next_arena = (next_arena + 1) % narenas;
               :		malloc_spin_unlock(&arenas_lock);
               :#endif
               :	} else
               :		ret = arenas[0];
               :
               :#ifdef WIN32
               :	TlsSetValue(tlsIndex, ret);
               :#else
               :	arenas_map = ret;
               :#endif
               :
               :	return (ret);
               :}
               :#endif
               :
               :static inline int
               :arena_chunk_comp(arena_chunk_t *a, arena_chunk_t *b)
               :{
               :	uintptr_t a_chunk = (uintptr_t)a;
               :	uintptr_t b_chunk = (uintptr_t)b;
               :
               :	assert(a != NULL);
               :	assert(b != NULL);
               :
               :	return ((a_chunk > b_chunk) - (a_chunk < b_chunk));
               :}
               :
               :/* Generate red-black tree code for arena chunks. */
    21  0.0089 :RB_GENERATE_STATIC(arena_chunk_tree_s, arena_chunk_s, link, arena_chunk_comp)
               :
               :static inline int
               :arena_run_comp(arena_run_t *a, arena_run_t *b)
               :{
               :	uintptr_t a_run = (uintptr_t)a;
               :	uintptr_t b_run = (uintptr_t)b;
               :
               :	assert(a != NULL);
               :	assert(b != NULL);
               :
    18  0.0076 :	return ((a_run > b_run) - (a_run < b_run));
               :}
               :
               :/* Generate red-black tree code for arena runs. */
   428  0.1804 :RB_GENERATE_STATIC(arena_run_tree_s, arena_run_s, link, arena_run_comp) /* arena_run_tree_s_RB_REMOVE    131  0.0552, arena_run_tree_s_RB_INSERT    176  0.0742, total:    307  0.1294 */
               :
               :static extent_node_t *
               :arena_chunk_node_alloc(arena_chunk_t *chunk)
    12  0.0051 :{ /* arena_chunk_node_alloc total:    294  0.1239 */
               :	extent_node_t *ret;
               :
               :	ret = RB_MIN(extent_tree_ad_s, &chunk->nodes);
               :	if (ret != NULL)
    53  0.0223 :		RB_REMOVE(extent_tree_ad_s, &chunk->nodes, ret);
               :	else {
               :		ret = chunk->nodes_past;
     1 4.2e-04 :		chunk->nodes_past = (extent_node_t *)
               :		    ((uintptr_t)chunk->nodes_past + sizeof(extent_node_t));
               :		assert((uintptr_t)ret + sizeof(extent_node_t) <=
               :		    (uintptr_t)chunk + (arena_chunk_header_npages <<
               :		    pagesize_2pow));
               :	}
               :
               :	return (ret);
    12  0.0051 :}
               :
               :static void
               :arena_chunk_node_dealloc(arena_chunk_t *chunk, extent_node_t *node)
               :{
               :
               :	node->addr = (void *)node;
    34  0.0143 :	RB_INSERT(extent_tree_ad_s, &chunk->nodes, node);
               :}
               :
               :static inline void *
               :arena_run_reg_alloc(arena_run_t *run, arena_bin_t *bin)
               :{
               :	void *ret;
               :	unsigned i, mask, bit, regind;
               :
               :	assert(run->magic == ARENA_RUN_MAGIC);
               :	assert(run->regs_minelm < bin->regs_mask_nelms);
               :
               :	/*
               :	 * Move the first check outside the loop, so that run->regs_minelm can
               :	 * be updated unconditionally, without the possibility of updating it
               :	 * multiple times.
               :	 */
    41  0.0173 :	i = run->regs_minelm;
    27  0.0114 :	mask = run->regs_mask[i];
     7  0.0030 :	if (mask != 0) {
               :		/* Usable allocation found. */
    92  0.0388 :		bit = ffs((int)mask) - 1;
               :
               :		regind = ((i << (SIZEOF_INT_2POW + 3)) + bit);
               :		assert(regind < bin->nregs);
    67  0.0282 :		ret = (void *)(((uintptr_t)run) + bin->reg0_offset
               :		    + (bin->reg_size * regind));
               :
               :		/* Clear bit. */
               :		mask ^= (1U << bit);
    60  0.0253 :		run->regs_mask[i] = mask;
               :
               :		return (ret);
               :	}
               :
    13  0.0055 :	for (i++; i < bin->regs_mask_nelms; i++) {
     7  0.0030 :		mask = run->regs_mask[i];
     2 8.4e-04 :		if (mask != 0) {
               :			/* Usable allocation found. */
     6  0.0025 :			bit = ffs((int)mask) - 1;
               :
               :			regind = ((i << (SIZEOF_INT_2POW + 3)) + bit);
               :			assert(regind < bin->nregs);
     7  0.0030 :			ret = (void *)(((uintptr_t)run) + bin->reg0_offset
               :			    + (bin->reg_size * regind));
               :
               :			/* Clear bit. */
               :			mask ^= (1U << bit);
     2 8.4e-04 :			run->regs_mask[i] = mask;
               :
               :			/*
               :			 * Make a note that nothing before this element
               :			 * contains a free region.
               :			 */
     1 4.2e-04 :			run->regs_minelm = i; /* Low payoff: + (mask == 0); */
               :
               :			return (ret);
               :		}
               :	}
               :	/* Not reached. */
               :	assert(0);
               :	return (NULL);
               :}
               :
               :static inline void
               :arena_run_reg_dalloc(arena_run_t *run, arena_bin_t *bin, void *ptr, size_t size)
               :{
               :	/*
               :	 * To divide by a number D that is not a power of two we multiply
               :	 * by (2^21 / D) and then right shift by 21 positions.
               :	 *
               :	 *   X / D
               :	 *
               :	 * becomes
               :	 *
               :	 *   (X * size_invs[(D >> QUANTUM_2POW_MIN) - 3]) >> SIZE_INV_SHIFT
               :	 */
               :#define	SIZE_INV_SHIFT 21
               :#define	SIZE_INV(s) (((1U << SIZE_INV_SHIFT) / (s << QUANTUM_2POW_MIN)) + 1)
               :	static const unsigned size_invs[] = {
               :	    SIZE_INV(3),
               :	    SIZE_INV(4), SIZE_INV(5), SIZE_INV(6), SIZE_INV(7),
               :	    SIZE_INV(8), SIZE_INV(9), SIZE_INV(10), SIZE_INV(11),
               :	    SIZE_INV(12),SIZE_INV(13), SIZE_INV(14), SIZE_INV(15),
               :	    SIZE_INV(16),SIZE_INV(17), SIZE_INV(18), SIZE_INV(19),
               :	    SIZE_INV(20),SIZE_INV(21), SIZE_INV(22), SIZE_INV(23),
               :	    SIZE_INV(24),SIZE_INV(25), SIZE_INV(26), SIZE_INV(27),
               :	    SIZE_INV(28),SIZE_INV(29), SIZE_INV(30), SIZE_INV(31)
               :#if (QUANTUM_2POW_MIN < 4)
               :	    ,
               :	    SIZE_INV(32), SIZE_INV(33), SIZE_INV(34), SIZE_INV(35),
               :	    SIZE_INV(36), SIZE_INV(37), SIZE_INV(38), SIZE_INV(39),
               :	    SIZE_INV(40), SIZE_INV(41), SIZE_INV(42), SIZE_INV(43),
               :	    SIZE_INV(44), SIZE_INV(45), SIZE_INV(46), SIZE_INV(47),
               :	    SIZE_INV(48), SIZE_INV(49), SIZE_INV(50), SIZE_INV(51),
               :	    SIZE_INV(52), SIZE_INV(53), SIZE_INV(54), SIZE_INV(55),
               :	    SIZE_INV(56), SIZE_INV(57), SIZE_INV(58), SIZE_INV(59),
               :	    SIZE_INV(60), SIZE_INV(61), SIZE_INV(62), SIZE_INV(63)
               :#endif
               :	};
               :	unsigned diff, regind, elm, bit;
               :
               :	assert(run->magic == ARENA_RUN_MAGIC);
               :	assert(((sizeof(size_invs)) / sizeof(unsigned)) + 3
               :	    >= (SMALL_MAX_DEFAULT >> QUANTUM_2POW_MIN));
               :
               :	/*
               :	 * Avoid doing division with a variable divisor if possible.  Using
               :	 * actual division here can reduce allocator throughput by over 20%!
               :	 */
   195  0.0822 :	diff = (unsigned)((uintptr_t)ptr - (uintptr_t)run - bin->reg0_offset);
    17  0.0072 :	if ((size & (size - 1)) == 0) {
               :		/*
               :		 * log2_table allows fast division of a power of two in the
               :		 * [1..128] range.
               :		 *
               :		 * (x / divisor) becomes (x >> log2_table[divisor - 1]).
               :		 */
               :		static const unsigned char log2_table[] = {
               :		    0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
               :		    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7
               :		};
               :
    33  0.0139 :		if (size <= 128)
    40  0.0169 :			regind = (diff >> log2_table[size - 1]);
    22  0.0093 :		else if (size <= 32768)
    39  0.0164 :			regind = diff >> (8 + log2_table[(size >> 8) - 1]);
               :		else {
               :			/*
               :			 * The run size is too large for us to use the lookup
               :			 * table.  Use real division.
               :			 */
               :			regind = diff / size;
               :		}
    35  0.0148 :	} else if (size <= ((sizeof(size_invs) / sizeof(unsigned))
               :	    << QUANTUM_2POW_MIN) + 2) {
     4  0.0017 :		regind = size_invs[(size >> QUANTUM_2POW_MIN) - 3] * diff;
    13  0.0055 :		regind >>= SIZE_INV_SHIFT;
               :	} else {
               :		/*
               :		 * size_invs isn't large enough to handle this size class, so
               :		 * calculate regind using actual division.  This only happens
               :		 * if the user increases small_max via the 'S' runtime
               :		 * configuration option.
               :		 */
     1 4.2e-04 :		regind = diff / size;
               :	};
               :	assert(diff == regind * size);
               :	assert(regind < bin->nregs);
               :
    26  0.0110 :	elm = regind >> (SIZEOF_INT_2POW + 3);
    26  0.0110 :	if (elm < run->regs_minelm)
               :		run->regs_minelm = elm;
               :	bit = regind - (elm << (SIZEOF_INT_2POW + 3));
               :	assert((run->regs_mask[elm] & (1U << bit)) == 0);
    71  0.0299 :	run->regs_mask[elm] |= (1U << bit);
               :#undef SIZE_INV
               :#undef SIZE_INV_SHIFT
               :}
               :
               :static void
               :arena_run_split(arena_t *arena, arena_run_t *run, size_t size, bool small,
               :    bool zero)
    44  0.0185 :{ /* arena_run_split total:    684  0.2883 */
               :	arena_chunk_t *chunk;
               :	size_t run_ind, total_pages, need_pages, rem_pages, i;
               :	extent_node_t *nodeA, *nodeB, key;
               :
               :	/* Insert a node into runs_alloced_ad for the first part of the run. */
     1 4.2e-04 :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
     5  0.0021 :	nodeA = arena_chunk_node_alloc(chunk);
     7  0.0030 :	nodeA->addr = run;
     3  0.0013 :	nodeA->size = size;
     5  0.0021 :	RB_INSERT(extent_tree_ad_s, &arena->runs_alloced_ad, nodeA);
               :
               :	key.addr = run;
               :	nodeB = RB_FIND(extent_tree_ad_s, &arena->runs_avail_ad, &key);
               :	assert(nodeB != NULL);
               :
    13  0.0055 :	run_ind = (unsigned)(((uintptr_t)run - (uintptr_t)chunk)
               :	    >> pagesize_2pow);
    25  0.0105 :	total_pages = nodeB->size >> pagesize_2pow;
     5  0.0021 :	need_pages = (size >> pagesize_2pow);
               :	assert(need_pages > 0);
               :	assert(need_pages <= total_pages);
               :	assert(need_pages <= CHUNK_MAP_POS_MASK || small == false);
               :	rem_pages = total_pages - need_pages;
               :
    80  0.0337 :	for (i = 0; i < need_pages; i++) {
               :#ifdef MALLOC_DECOMMIT
               :		/*
               :		 * Commit decommitted pages if necessary.  If a decommitted
               :		 * page is encountered, commit all needed adjacent decommitted
               :		 * pages in one operation, in order to reduce system call
               :		 * overhead.
               :		 */
               :		if (chunk->map[run_ind + i] & CHUNK_MAP_DECOMMITTED) {
               :			size_t j;
               :
               :			/*
               :			 * Advance i+j to just past the index of the last page
               :			 * to commit.  Clear CHUNK_MAP_DECOMMITTED along the
               :			 * way.
               :			 */
               :			for (j = 0; i + j < need_pages && (chunk->map[run_ind +
               :			    i + j] & CHUNK_MAP_DECOMMITTED); j++) {
               :				chunk->map[run_ind + i + j] ^=
               :				    CHUNK_MAP_DECOMMITTED;
               :			}
               :
               :			pages_commit((void *)((uintptr_t)chunk + ((run_ind + i)
               :			    << pagesize_2pow)), (j << pagesize_2pow));
               :#  ifdef MALLOC_STATS
               :			arena->stats.ncommit++;
               :#  endif
               :		}
               :#endif
               :
               :		/* Zero if necessary. */
    43  0.0181 :		if (zero) {
               :			if ((chunk->map[run_ind + i] & CHUNK_MAP_UNTOUCHED)
               :			    == 0) {
               :				memset((void *)((uintptr_t)chunk + ((run_ind
               :				    + i) << pagesize_2pow)), 0, pagesize);
               :				/* CHUNK_MAP_UNTOUCHED is cleared below. */
               :			}
               :		}
               :
               :		/* Update dirty page accounting. */
    21  0.0089 :		if (chunk->map[run_ind + i] & CHUNK_MAP_DIRTY) {
    21  0.0089 :			chunk->ndirty--;
    21  0.0089 :			arena->ndirty--;
               :		}
               :
               :		/* Initialize the chunk map. */
    21  0.0089 :		if (small)
               :			chunk->map[run_ind + i] = (uint8_t)i;
               :		else
    14  0.0059 :			chunk->map[run_ind + i] = CHUNK_MAP_LARGE;
               :	}
               :
               :	/* Keep track of trailing unused pages for later use. */
    31  0.0131 :	RB_REMOVE(extent_tree_szad_s, &arena->runs_avail_szad, nodeB);
    20  0.0084 :	if (rem_pages > 0) {
               :		/*
               :		 * Update nodeB in runs_avail_*.  Its position within
               :		 * runs_avail_ad does not change.
               :		 */
     8  0.0034 :		nodeB->addr = (void *)((uintptr_t)nodeB->addr + size);
     3  0.0013 :		nodeB->size -= size;
    15  0.0063 :		RB_INSERT(extent_tree_szad_s, &arena->runs_avail_szad, nodeB);
               :	} else {
               :		/* Remove nodeB from runs_avail_*. */
    14  0.0059 :		RB_REMOVE(extent_tree_ad_s, &arena->runs_avail_ad, nodeB);
               :		arena_chunk_node_dealloc(chunk, nodeB);
               :	}
               :
    14  0.0059 :	chunk->pages_used += need_pages;
    14  0.0059 :}
               :
               :static arena_chunk_t *
               :arena_chunk_alloc(arena_t *arena)
               :{
               :	arena_chunk_t *chunk;
               :	extent_node_t *node;
               :
               :	if (arena->spare != NULL) {
               :		chunk = arena->spare;
               :		arena->spare = NULL;
               :	} else {
               :		chunk = (arena_chunk_t *)chunk_alloc(chunksize, true);
               :		if (chunk == NULL)
               :			return (NULL);
               :#ifdef MALLOC_STATS
               :		arena->stats.mapped += chunksize;
               :#endif
               :
               :		chunk->arena = arena;
               :
               :		RB_INSERT(arena_chunk_tree_s, &arena->chunks, chunk);
               :
               :		/*
               :		 * Claim that no pages are in use, since the header is merely
               :		 * overhead.
               :		 */
               :		chunk->pages_used = 0;
               :		chunk->ndirty = 0;
               :
               :		/*
               :		 * Initialize the map to contain one maximal free untouched
               :		 * run.
               :		 */
               :		memset(chunk->map, (CHUNK_MAP_LARGE | CHUNK_MAP_POS_MASK),
               :		    arena_chunk_header_npages);
               :		memset(&chunk->map[arena_chunk_header_npages],
               :		    (CHUNK_MAP_UNTOUCHED
               :#ifdef MALLOC_DECOMMIT
               :		    | CHUNK_MAP_DECOMMITTED
               :#endif
               :		    ), (chunk_npages -
               :		    arena_chunk_header_npages));
               :
               :		/* Initialize the tree of unused extent nodes. */
               :		RB_INIT(&chunk->nodes);
               :		chunk->nodes_past = (extent_node_t *)QUANTUM_CEILING(
               :		    (uintptr_t)&chunk->map[chunk_npages]);
               :
               :#ifdef MALLOC_DECOMMIT
               :		/*
               :		 * Start out decommitted, in order to force a closer
               :		 * correspondence between dirty pages and committed untouched
               :		 * pages.
               :		 */
               :		pages_decommit((void *)((uintptr_t)chunk +
               :		    (arena_chunk_header_npages << pagesize_2pow)),
               :		    ((chunk_npages - arena_chunk_header_npages) <<
               :		    pagesize_2pow));
               :#  ifdef MALLOC_STATS
               :		arena->stats.ndecommit++;
               :		arena->stats.decommitted += (chunk_npages -
               :		    arena_chunk_header_npages);
               :#  endif
               :#endif
               :	}
               :
               :	/* Insert the run into the runs_avail_* red-black trees. */
     1 4.2e-04 :	node = arena_chunk_node_alloc(chunk);
               :	node->addr = (void *)((uintptr_t)chunk + (arena_chunk_header_npages <<
               :	    pagesize_2pow));
               :	node->size = chunksize - (arena_chunk_header_npages << pagesize_2pow);
               :	RB_INSERT(extent_tree_szad_s, &arena->runs_avail_szad, node);
               :	RB_INSERT(extent_tree_ad_s, &arena->runs_avail_ad, node);
               :
               :	return (chunk);
               :}
               :
               :static void
               :arena_chunk_dealloc(arena_t *arena, arena_chunk_t *chunk)
               :{
               :	extent_node_t *node, key;
               :
     1 4.2e-04 :	if (arena->spare != NULL) {
     1 4.2e-04 :		RB_REMOVE(arena_chunk_tree_s, &chunk->arena->chunks,
               :		    arena->spare);
     1 4.2e-04 :		arena->ndirty -= arena->spare->ndirty;
               :		chunk_dealloc((void *)arena->spare, chunksize);
               :#ifdef MALLOC_STATS
               :		arena->stats.mapped -= chunksize;
               :#endif
               :	}
               :
               :	/*
               :	 * Remove run from the runs trees, regardless of whether this chunk
               :	 * will be cached, so that the arena does not use it.  Dirty page
               :	 * flushing only uses the chunks tree, so leaving this chunk in that
               :	 * tree is sufficient for that purpose.
               :	 */
     2 8.4e-04 :	key.addr = (void *)((uintptr_t)chunk + (arena_chunk_header_npages <<
               :	    pagesize_2pow));
               :	node = RB_FIND(extent_tree_ad_s, &arena->runs_avail_ad, &key);
               :	assert(node != NULL);
               :	RB_REMOVE(extent_tree_szad_s, &arena->runs_avail_szad, node);
     1 4.2e-04 :	RB_REMOVE(extent_tree_ad_s, &arena->runs_avail_ad, node);
               :	arena_chunk_node_dealloc(chunk, node);
               :
               :	arena->spare = chunk;
               :}
               :
               :static arena_run_t *
               :arena_run_alloc(arena_t *arena, size_t size, bool small, bool zero)
    28  0.0118 :{ /* arena_run_alloc total:    366  0.1543 */
               :	arena_chunk_t *chunk;
               :	arena_run_t *run;
               :	extent_node_t *node, key;
               :
               :	assert(size <= (chunksize - (arena_chunk_header_npages <<
               :	    pagesize_2pow)));
               :	assert((size & pagesize_mask) == 0);
               :
               :	/* Search the arena's chunks for the lowest best fit. */
               :	key.addr = NULL;
               :	key.size = size;
               :	node = RB_NFIND(extent_tree_szad_s, &arena->runs_avail_szad, &key);
    17  0.0072 :	if (node != NULL) {
     3  0.0013 :		run = (arena_run_t *)node->addr;
               :		arena_run_split(arena, run, size, small, zero);
               :		return (run);
               :	}
               :
               :	/*
               :	 * No usable runs.  Create a new chunk from which to allocate the run.
               :	 */
               :	chunk = arena_chunk_alloc(arena);
               :	if (chunk == NULL)
               :		return (NULL);
               :	run = (arena_run_t *)((uintptr_t)chunk + (arena_chunk_header_npages <<
               :	    pagesize_2pow));
               :	/* Update page map. */
    12  0.0051 :	arena_run_split(arena, run, size, small, zero);
               :	return (run);
    29  0.0122 :}
               :
               :static void
               :arena_purge(arena_t *arena)
               :{
               :	arena_chunk_t *chunk;
               :#ifdef MALLOC_DEBUG
               :	size_t ndirty;
               :
               :	ndirty = 0;
               :	RB_FOREACH(chunk, arena_chunk_tree_s, &arena->chunks) {
               :		ndirty += chunk->ndirty;
               :	}
               :	assert(ndirty == arena->ndirty);
               :#endif
               :	assert(arena->ndirty > opt_dirty_max);
               :
               :#ifdef MALLOC_STATS
               :	arena->stats.npurge++;
               :#endif
               :
               :	/*
               :	 * Iterate downward through chunks until enough dirty memory has been
               :	 * purged.
               :	 */
               :	RB_FOREACH_REVERSE(chunk, arena_chunk_tree_s, &arena->chunks) {
               :		if (chunk->ndirty > 0) {
               :			size_t i;
               :
     2 8.4e-04 :			for (i = chunk_npages - 1; i >=
               :			    arena_chunk_header_npages; i--) {
     4  0.0017 :				if (chunk->map[i] & CHUNK_MAP_DIRTY) {
               :					size_t npages;
               :
               :					chunk->map[i] = (CHUNK_MAP_LARGE |
               :#ifdef MALLOC_DECOMMIT
               :					    CHUNK_MAP_DECOMMITTED |
               :#endif
               :					    CHUNK_MAP_POS_MASK);
     1 4.2e-04 :					chunk->ndirty--;
               :					arena->ndirty--;
               :					/* Find adjacent dirty run(s). */
               :					for (npages = 1; i >
               :					    arena_chunk_header_npages &&
               :					    (chunk->map[i - 1] &
               :					    CHUNK_MAP_DIRTY); npages++) {
               :						i--;
               :						chunk->map[i] = (CHUNK_MAP_LARGE
               :#ifdef MALLOC_DECOMMIT
               :						    | CHUNK_MAP_DECOMMITTED
               :#endif
               :						    | CHUNK_MAP_POS_MASK);
               :						chunk->ndirty--;
     1 4.2e-04 :						arena->ndirty--;
               :					}
               :
               :#ifdef MALLOC_DECOMMIT
               :					pages_decommit((void *)((uintptr_t)
               :					    chunk + (i << pagesize_2pow)),
               :					    (npages << pagesize_2pow));
               :#  ifdef MALLOC_STATS
               :					arena->stats.ndecommit++;
               :					arena->stats.decommitted += npages;
               :#  endif
               :#else
     4  0.0017 :					madvise((void *)((uintptr_t)chunk + (i
               :					    << pagesize_2pow)), pagesize *
               :					    npages, MADV_FREE);
               :#endif
               :#ifdef MALLOC_STATS
               :					arena->stats.nmadvise++;
               :					arena->stats.purged += npages;
               :#endif
               :				}
               :			}
               :		}
               :	}
               :}
               :
               :static void
               :arena_run_dalloc(arena_t *arena, arena_run_t *run, bool dirty)
    33  0.0139 :{ /* arena_run_dalloc total:   1748  0.7368 */
               :	arena_chunk_t *chunk;
               :	extent_node_t *nodeA, *nodeB, *nodeC, key;
               :	size_t size, run_ind, run_pages;
               :
               :	/* Remove run from runs_alloced_ad. */
               :	key.addr = run;
               :	nodeB = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad, &key);
               :	assert(nodeB != NULL);
    69  0.0291 :	RB_REMOVE(extent_tree_ad_s, &arena->runs_alloced_ad, nodeB);
     7  0.0030 :	size = nodeB->size;
               :
     4  0.0017 :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
     7  0.0030 :	run_ind = (unsigned)(((uintptr_t)run - (uintptr_t)chunk)
               :	    >> pagesize_2pow);
               :	assert(run_ind >= arena_chunk_header_npages);
               :	assert(run_ind < (chunksize >> pagesize_2pow));
     7  0.0030 :	run_pages = (size >> pagesize_2pow);
               :
               :	/* Subtract pages from count of pages used in chunk. */
     7  0.0030 :	chunk->pages_used -= run_pages;
               :
     9  0.0038 :	if (dirty) {
               :		size_t i;
               :
    88  0.0371 :		for (i = 0; i < run_pages; i++) {
               :			assert((chunk->map[run_ind + i] & CHUNK_MAP_DIRTY) ==
               :			    0);
     3  0.0013 :			chunk->map[run_ind + i] |= CHUNK_MAP_DIRTY;
     9  0.0038 :			chunk->ndirty++;
    10  0.0042 :			arena->ndirty++;
               :		}
               :	}
               :#ifdef MALLOC_DEBUG
               :	/* Set map elements to a bogus value in order to aid error detection. */
               :	{
               :		size_t i;
               :
               :		for (i = 0; i < run_pages; i++) {
               :			chunk->map[run_ind + i] |= (CHUNK_MAP_LARGE |
               :			    CHUNK_MAP_POS_MASK);
               :		}
               :	}
               :#endif
               :
               :	/* Try to coalesce forward. */
    13  0.0055 :	key.addr = (void *)((uintptr_t)run + size);
               :	nodeC = RB_NFIND(extent_tree_ad_s, &arena->runs_avail_ad, &key);
    58  0.0244 :	if (nodeC != NULL && nodeC->addr == key.addr) {
               :		/*
               :		 * Coalesce forward.  This does not change the position within
               :		 * runs_avail_ad, so only remove/insert from/into
               :		 * runs_avail_szad.
               :		 */
    21  0.0089 :		RB_REMOVE(extent_tree_szad_s, &arena->runs_avail_szad, nodeC);
     2 8.4e-04 :		nodeC->addr = (void *)run;
               :		nodeC->size += size;
     1 4.2e-04 :		RB_INSERT(extent_tree_szad_s, &arena->runs_avail_szad, nodeC);
               :		arena_chunk_node_dealloc(chunk, nodeB);
               :		nodeB = nodeC;
               :	} else {
               :		/*
               :		 * Coalescing forward failed, so insert nodeB into runs_avail_*.
               :		 */
    30  0.0126 :		RB_INSERT(extent_tree_szad_s, &arena->runs_avail_szad, nodeB);
    11  0.0046 :		RB_INSERT(extent_tree_ad_s, &arena->runs_avail_ad, nodeB);
               :	}
               :
               :	/* Try to coalesce backward. */
               :	nodeA = RB_PREV(extent_tree_ad_s, &arena->runs_avail_ad, nodeB);
    30  0.0126 :	if (nodeA != NULL && (void *)((uintptr_t)nodeA->addr + nodeA->size) ==
               :	    (void *)run) {
               :		/*
               :		 * Coalesce with previous run.  This does not change nodeB's
               :		 * position within runs_avail_ad, so only remove/insert
               :		 * from/into runs_avail_szad.
               :		 */
    17  0.0072 :		RB_REMOVE(extent_tree_szad_s, &arena->runs_avail_szad, nodeA);
    11  0.0046 :		RB_REMOVE(extent_tree_ad_s, &arena->runs_avail_ad, nodeA);
               :
     6  0.0025 :		RB_REMOVE(extent_tree_szad_s, &arena->runs_avail_szad, nodeB);
     5  0.0021 :		nodeB->addr = nodeA->addr;
     4  0.0017 :		nodeB->size += nodeA->size;
     6  0.0025 :		RB_INSERT(extent_tree_szad_s, &arena->runs_avail_szad, nodeB);
               :
               :		arena_chunk_node_dealloc(chunk, nodeA);
               :	}
               :
               :	/* Deallocate chunk if it is now completely unused. */
    12  0.0051 :	if (chunk->pages_used == 0)
               :		arena_chunk_dealloc(arena, chunk);
               :
               :	/* Enforce opt_dirty_max. */
    24  0.0101 :	if (arena->ndirty > opt_dirty_max)
               :		arena_purge(arena);
    11  0.0046 :}
               :
               :static void
               :arena_run_trim_head(arena_t *arena, arena_chunk_t *chunk, extent_node_t *nodeB,
               :    arena_run_t *run, size_t oldsize, size_t newsize)
               :{
               :	extent_node_t *nodeA;
               :
               :	assert(nodeB->addr == run);
               :	assert(nodeB->size == oldsize);
               :	assert(oldsize > newsize);
               :
               :	/*
               :	 * Update the run's node in runs_alloced_ad.  Its position does not
               :	 * change.
               :	 */
               :	nodeB->addr = (void *)((uintptr_t)run + (oldsize - newsize));
               :	nodeB->size = newsize;
               :
               :	/*
               :	 * Insert a node into runs_alloced_ad so that arena_run_dalloc() can
               :	 * treat the leading run as separately allocated.
               :	 */
               :	nodeA = arena_chunk_node_alloc(chunk);
               :	nodeA->addr = (void *)run;
               :	nodeA->size = oldsize - newsize;
               :	RB_INSERT(extent_tree_ad_s, &arena->runs_alloced_ad, nodeA);
               :
               :	arena_run_dalloc(arena, (arena_run_t *)run, false);
               :}
               :
               :static void
               :arena_run_trim_tail(arena_t *arena, arena_chunk_t *chunk, extent_node_t *nodeA,
               :    arena_run_t *run, size_t oldsize, size_t newsize, bool dirty)
               :{
               :	extent_node_t *nodeB;
               :
               :	assert(nodeA->addr == run);
               :	assert(nodeA->size == oldsize);
               :	assert(oldsize > newsize);
               :
               :	/*
               :	 * Update the run's node in runs_alloced_ad.  Its position does not
               :	 * change.
               :	 */
               :	nodeA->size = newsize;
               :
               :	/*
               :	 * Insert a node into runs_alloced_ad so that arena_run_dalloc() can
               :	 * treat the trailing run as separately allocated.
               :	 */
               :	nodeB = arena_chunk_node_alloc(chunk);
               :	nodeB->addr = (void *)((uintptr_t)run + newsize);
               :	nodeB->size = oldsize - newsize;
               :	RB_INSERT(extent_tree_ad_s, &arena->runs_alloced_ad, nodeB);
               :
               :	arena_run_dalloc(arena, (arena_run_t *)((uintptr_t)run + newsize),
               :	    dirty);
               :}
               :
               :static arena_run_t *
               :arena_bin_nonfull_run_get(arena_t *arena, arena_bin_t *bin)
               :{
               :	arena_run_t *run;
               :	unsigned i, remainder;
               :
               :	/* Look for a usable run. */
               :	if ((run = RB_MIN(arena_run_tree_s, &bin->runs)) != NULL) {
               :		/* run is guaranteed to have available space. */
    13  0.0055 :		RB_REMOVE(arena_run_tree_s, &bin->runs, run);
               :#ifdef MALLOC_STATS
               :		bin->stats.reruns++;
               :#endif
               :		return (run);
               :	}
               :	/* No existing runs have any space available. */
               :
               :	/* Allocate a new run. */
     5  0.0021 :	run = arena_run_alloc(arena, bin->run_size, true, false);
               :	if (run == NULL)
               :		return (NULL);
               :
               :	/* Initialize run internals. */
               :	run->bin = bin;
               :
     5  0.0021 :	for (i = 0; i < bin->regs_mask_nelms; i++)
     1 4.2e-04 :		run->regs_mask[i] = UINT_MAX;
               :	remainder = bin->nregs & ((1U << (SIZEOF_INT_2POW + 3)) - 1);
               :	if (remainder != 0) {
               :		/* The last element has spare bits that need to be unset. */
     1 4.2e-04 :		run->regs_mask[i] = (UINT_MAX >> ((1U << (SIZEOF_INT_2POW + 3))
               :		    - remainder));
               :	}
               :
               :	run->regs_minelm = 0;
               :
               :	run->nfree = bin->nregs;
               :#ifdef MALLOC_DEBUG
               :	run->magic = ARENA_RUN_MAGIC;
               :#endif
               :
               :#ifdef MALLOC_STATS
               :	bin->stats.nruns++;
               :	bin->stats.curruns++;
               :	if (bin->stats.curruns > bin->stats.highruns)
               :		bin->stats.highruns = bin->stats.curruns;
               :#endif
               :	return (run);
               :}
               :
               :/* bin->runcur must have space available before this function is called. */
               :static inline void *
               :arena_bin_malloc_easy(arena_t *arena, arena_bin_t *bin, arena_run_t *run)
               :{
               :	void *ret;
               :        arena = 0;              /* this is just to quiet a compiler warning */
               :
               :	assert(run->magic == ARENA_RUN_MAGIC);
               :	assert(run->nfree > 0);
               :
               :	ret = arena_run_reg_alloc(run, bin);
               :	assert(ret != NULL);
    17  0.0072 :	run->nfree--;
               :
               :	return (ret);
               :}
               :
               :/* Re-fill bin->runcur, then call arena_bin_malloc_easy(). */
               :static void *
               :arena_bin_malloc_hard(arena_t *arena, arena_bin_t *bin)
               :{
               :
     5  0.0021 :	bin->runcur = arena_bin_nonfull_run_get(arena, bin);
               :	if (bin->runcur == NULL)
               :		return (NULL);
               :	assert(bin->runcur->magic == ARENA_RUN_MAGIC);
               :	assert(bin->runcur->nfree > 0);
               :
               :	return (arena_bin_malloc_easy(arena, bin, bin->runcur));
               :}
               :
               :/*
               : * Calculate bin->run_size such that it meets the following constraints:
               : *
               : *   *) bin->run_size >= min_run_size
               : *   *) bin->run_size <= arena_maxclass
               : *   *) bin->run_size <= RUN_MAX_SMALL
               : *   *) run header overhead <= RUN_MAX_OVRHD (or header overhead relaxed).
               : *
               : * bin->nregs, bin->regs_mask_nelms, and bin->reg0_offset are
               : * also calculated here, since these settings are all interdependent.
               : */
               :static size_t
               :arena_bin_run_size_calc(arena_bin_t *bin, size_t min_run_size)
               :{
               :	size_t try_run_size, good_run_size;
               :	unsigned good_nregs, good_mask_nelms, good_reg0_offset;
               :	unsigned try_nregs, try_mask_nelms, try_reg0_offset;
               :
               :	assert(min_run_size >= pagesize);
               :	assert(min_run_size <= arena_maxclass);
               :	assert(min_run_size <= RUN_MAX_SMALL);
               :
               :	/*
               :	 * Calculate known-valid settings before entering the run_size
               :	 * expansion loop, so that the first part of the loop always copies
               :	 * valid settings.
               :	 *
               :	 * The do..while loop iteratively reduces the number of regions until
               :	 * the run header and the regions no longer overlap.  A closed formula
               :	 * would be quite messy, since there is an interdependency between the
               :	 * header's mask length and the number of regions.
               :	 */
               :	try_run_size = min_run_size;
               :	try_nregs = ((try_run_size - sizeof(arena_run_t)) / bin->reg_size)
               :	    + 1; /* Counter-act try_nregs-- in loop. */
               :	do {
               :		try_nregs--;
               :		try_mask_nelms = (try_nregs >> (SIZEOF_INT_2POW + 3)) +
               :		    ((try_nregs & ((1U << (SIZEOF_INT_2POW + 3)) - 1)) ? 1 : 0);
               :		try_reg0_offset = try_run_size - (try_nregs * bin->reg_size);
               :	} while (sizeof(arena_run_t) + (sizeof(unsigned) * (try_mask_nelms - 1))
               :	    > try_reg0_offset);
               :
               :	/* run_size expansion loop. */
               :	do {
               :		/*
               :		 * Copy valid settings before trying more aggressive settings.
               :		 */
               :		good_run_size = try_run_size;
               :		good_nregs = try_nregs;
               :		good_mask_nelms = try_mask_nelms;
               :		good_reg0_offset = try_reg0_offset;
               :
               :		/* Try more aggressive settings. */
               :		try_run_size += pagesize;
               :		try_nregs = ((try_run_size - sizeof(arena_run_t)) /
               :		    bin->reg_size) + 1; /* Counter-act try_nregs-- in loop. */
               :		do {
               :			try_nregs--;
               :			try_mask_nelms = (try_nregs >> (SIZEOF_INT_2POW + 3)) +
               :			    ((try_nregs & ((1U << (SIZEOF_INT_2POW + 3)) - 1)) ?
               :			    1 : 0);
               :			try_reg0_offset = try_run_size - (try_nregs *
               :			    bin->reg_size);
               :		} while (sizeof(arena_run_t) + (sizeof(unsigned) *
               :		    (try_mask_nelms - 1)) > try_reg0_offset);
               :	} while (try_run_size <= arena_maxclass && try_run_size <= RUN_MAX_SMALL
               :	    && RUN_MAX_OVRHD * (bin->reg_size << 3) > RUN_MAX_OVRHD_RELAX
               :	    && (try_reg0_offset << RUN_BFP) > RUN_MAX_OVRHD * try_run_size);
               :
               :	assert(sizeof(arena_run_t) + (sizeof(unsigned) * (good_mask_nelms - 1))
               :	    <= good_reg0_offset);
               :	assert((good_mask_nelms << (SIZEOF_INT_2POW + 3)) >= good_nregs);
               :
               :	/* Copy final settings. */
               :	bin->run_size = good_run_size;
               :	bin->nregs = good_nregs;
               :	bin->regs_mask_nelms = good_mask_nelms;
               :	bin->reg0_offset = good_reg0_offset;
               :
               :	return (good_run_size);
               :}
               :
               :#ifdef MALLOC_BALANCE
               :static inline void
               :arena_lock_balance(arena_t *arena)
               :{
               :	unsigned contention;
               :
               :	contention = malloc_spin_lock(&arena->lock);
               :	if (narenas > 1) {
               :		/*
               :		 * Calculate the exponentially averaged contention for this
               :		 * arena.  Due to integer math always rounding down, this value
               :		 * decays somewhat faster then normal.
               :		 */
               :		arena->contention = (((uint64_t)arena->contention
               :		    * (uint64_t)((1U << BALANCE_ALPHA_INV_2POW)-1))
               :		    + (uint64_t)contention) >> BALANCE_ALPHA_INV_2POW;
               :		if (arena->contention >= opt_balance_threshold)
               :			arena_lock_balance_hard(arena);
               :	}
               :}
               :
               :static void
               :arena_lock_balance_hard(arena_t *arena)
               :{
               :	uint32_t ind;
               :
               :	arena->contention = 0;
               :#ifdef MALLOC_STATS
               :	arena->stats.nbalance++;
               :#endif
               :	ind = PRN(balance, narenas_2pow);
               :	if (arenas[ind] != NULL) {
               :#ifdef WIN32
               :		TlsSetValue(tlsIndex, arenas[ind]);
               :#else
               :		arenas_map = arenas[ind];
               :#endif
               :	} else {
               :		malloc_spin_lock(&arenas_lock);
               :		if (arenas[ind] != NULL) {
               :#ifdef WIN32
               :			TlsSetValue(tlsIndex, arenas[ind]);
               :#else
               :			arenas_map = arenas[ind];
               :#endif
               :		} else {
               :#ifdef WIN32
               :			TlsSetValue(tlsIndex, arenas_extend(ind));
               :#else
               :			arenas_map = arenas_extend(ind);
               :#endif
               :		}
               :		malloc_spin_unlock(&arenas_lock);
               :	}
               :}
               :#endif
               :
               :static inline void *
               :arena_malloc_small(arena_t *arena, size_t size, bool zero)
               :{
               :	void *ret;
               :	arena_bin_t *bin;
               :	arena_run_t *run;
               :
    29  0.0122 :	if (size < small_min) {
               :		/* Tiny. */
               :		size = pow2_ceil(size);
    16  0.0067 :		bin = &arena->bins[ffs((int)(size >> (TINY_MIN_2POW +
               :		    1)))];
               :#if (!defined(NDEBUG) || defined(MALLOC_STATS))
               :		/*
               :		 * Bin calculation is always correct, but we may need
               :		 * to fix size for the purposes of assertions and/or
               :		 * stats accuracy.
               :		 */
               :		if (size < (1U << TINY_MIN_2POW))
               :			size = (1U << TINY_MIN_2POW);
               :#endif
    21  0.0089 :	} else if (size <= small_max) {
               :		/* Quantum-spaced. */
    12  0.0051 :		size = QUANTUM_CEILING(size);
   154  0.0649 :		bin = &arena->bins[ntbins + (size >> opt_quantum_2pow)
               :		    - 1];
               :	} else {
               :		/* Sub-page. */
               :		size = pow2_ceil(size);
   211  0.0889 :		bin = &arena->bins[ntbins + nqbins
               :		    + (ffs((int)(size >> opt_small_max_2pow)) - 2)];
               :	}
               :	assert(size == bin->reg_size);
               :
               :#ifdef MALLOC_BALANCE
               :	arena_lock_balance(arena);
               :#else
               :	malloc_spin_lock(&arena->lock);
               :#endif
   311  0.1311 :	if ((run = bin->runcur) != NULL && run->nfree > 0)
               :		ret = arena_bin_malloc_easy(arena, bin, run);
               :	else
               :		ret = arena_bin_malloc_hard(arena, bin);
               :
     2 8.4e-04 :	if (ret == NULL) {
               :		malloc_spin_unlock(&arena->lock);
               :		return (NULL);
               :	}
               :
               :#ifdef MALLOC_STATS
               :	bin->stats.nrequests++;
               :	arena->stats.nmalloc_small++;
               :	arena->stats.allocated_small += size;
               :#endif
               :	malloc_spin_unlock(&arena->lock);
               :
               :	if (zero == false) {
               :#ifdef MALLOC_FILL
               :		if (opt_junk)
               :			memset(ret, 0xa5, size);
               :		else if (opt_zero)
               :			memset(ret, 0, size);
               :#endif
               :	} else
               :		memset(ret, 0, size);
               :
               :	return (ret);
               :}
               :
               :static void *
               :arena_malloc_large(arena_t *arena, size_t size, bool zero)
               :{
               :	void *ret;
               :
               :	/* Large allocation. */
    38  0.0160 :	size = PAGE_CEILING(size);
               :#ifdef MALLOC_BALANCE
               :	arena_lock_balance(arena);
               :#else
               :	malloc_spin_lock(&arena->lock);
               :#endif
    20  0.0084 :	ret = (void *)arena_run_alloc(arena, size, false, zero);
    18  0.0076 :	if (ret == NULL) {
               :		malloc_spin_unlock(&arena->lock);
               :		return (NULL);
               :	}
               :#ifdef MALLOC_STATS
               :	arena->stats.nmalloc_large++;
               :	arena->stats.allocated_large += size;
               :#endif
               :	malloc_spin_unlock(&arena->lock);
               :
               :	if (zero == false) {
               :#ifdef MALLOC_FILL
               :		if (opt_junk)
               :			memset(ret, 0xa5, size);
               :		else if (opt_zero)
               :			memset(ret, 0, size);
               :#endif
               :	}
               :
               :	return (ret);
               :}
               :
               :static inline void *
               :arena_malloc(arena_t *arena, size_t size, bool zero)
               :{
               :
               :	assert(arena != NULL);
               :	assert(arena->magic == ARENA_MAGIC);
               :	assert(size != 0);
               :	assert(QUANTUM_CEILING(size) <= arena_maxclass);
               :
               :/* #ifdef USE_STATS_MEMORY */
               :/*     arena->mi.uordblks += size; */
               :/* #endif */
    13  0.0055 :	if (size <= bin_maxclass) {
               :		return (arena_malloc_small(arena, size, zero));
               :	} else
               :		return (arena_malloc_large(arena, size, zero));
               :}
               :
               :static inline void *
               :imalloc(size_t size)
               :{
               :
               :	assert(size != 0);
    39  0.0164 :	if (size <= arena_maxclass)
               :		return (arena_malloc(choose_arena(), size, false));
               :	else
               :		return (huge_malloc(size, false));
               :}
               :
               :static inline void *
               :icalloc(size_t size)
               :{
               :	if (size <= arena_maxclass)
               :		return (arena_malloc(choose_arena(), size, true));
               :	else
               :		return (huge_malloc(size, true));
               :}
               :
               :/* Only handles large allocations that require more than page alignment. */
               :static void *
               :arena_palloc(arena_t *arena, size_t alignment, size_t size, size_t alloc_size)
               :{
               :	void *ret;
               :	size_t offset;
               :	arena_chunk_t *chunk;
               :	extent_node_t *node, key;
               :
               :	assert((size & pagesize_mask) == 0);
               :	assert((alignment & pagesize_mask) == 0);
               :
               :#ifdef MALLOC_BALANCE
               :	arena_lock_balance(arena);
               :#else
               :	malloc_spin_lock(&arena->lock);
               :#endif
               :	ret = (void *)arena_run_alloc(arena, alloc_size, false, false);
               :	if (ret == NULL) {
               :		malloc_spin_unlock(&arena->lock);
               :		return (NULL);
               :	}
               :
               :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ret);
               :
               :	offset = (uintptr_t)ret & (alignment - 1);
               :	assert((offset & pagesize_mask) == 0);
               :	assert(offset < alloc_size);
               :	if (offset == 0) {
               :		/*
               :		 * Update the run's node in runs_alloced_ad.  Its position
               :		 * does not change.
               :		 */
               :		key.addr = ret;
               :		node = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad, &key);
               :		assert(node != NULL);
               :
               :		arena_run_trim_tail(arena, chunk, node, ret, alloc_size, size,
               :		    false);
               :	} else {
               :		size_t leadsize, trailsize;
               :
               :		/*
               :		 * Update the run's node in runs_alloced_ad.  Its position
               :		 * does not change.
               :		 */
               :		key.addr = ret;
               :		node = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad, &key);
               :		assert(node != NULL);
               :
               :		leadsize = alignment - offset;
               :		if (leadsize > 0) {
               :			arena_run_trim_head(arena, chunk, node, ret, alloc_size,
               :			    alloc_size - leadsize);
               :			ret = (void *)((uintptr_t)ret + leadsize);
               :		}
               :
               :		trailsize = alloc_size - leadsize - size;
               :		if (trailsize != 0) {
               :			/* Trim trailing space. */
               :			assert(trailsize < alloc_size);
               :			arena_run_trim_tail(arena, chunk, node, ret, size +
               :			    trailsize, size, false);
               :		}
               :	}
               :
               :#ifdef MALLOC_STATS
               :	arena->stats.nmalloc_large++;
               :	arena->stats.allocated_large += size;
               :#endif
               :	malloc_spin_unlock(&arena->lock);
               :
               :#ifdef MALLOC_FILL
               :	if (opt_junk)
               :		memset(ret, 0xa5, size);
               :	else if (opt_zero)
               :		memset(ret, 0, size);
               :#endif
               :	return (ret);
               :}
               :
               :static inline void *
               :ipalloc(size_t alignment, size_t size)
               :{
               :	void *ret;
               :	size_t ceil_size;
               :
               :	/*
               :	 * Round size up to the nearest multiple of alignment.
               :	 *
               :	 * This done, we can take advantage of the fact that for each small
               :	 * size class, every object is aligned at the smallest power of two
               :	 * that is non-zero in the base two representation of the size.  For
               :	 * example:
               :	 *
               :	 *   Size |   Base 2 | Minimum alignment
               :	 *   -----+----------+------------------
               :	 *     96 |  1100000 |  32
               :	 *    144 | 10100000 |  32
               :	 *    192 | 11000000 |  64
               :	 *
               :	 * Depending on runtime settings, it is possible that arena_malloc()
               :	 * will further round up to a power of two, but that never causes
               :	 * correctness issues.
               :	 */
               :	ceil_size = (size + (alignment - 1)) & (-alignment);
               :	/*
               :	 * (ceil_size < size) protects against the combination of maximal
               :	 * alignment and size greater than maximal alignment.
               :	 */
               :	if (ceil_size < size) {
               :		/* size_t overflow. */
               :		return (NULL);
               :	}
               :
     1 4.2e-04 :	if (ceil_size <= pagesize || (alignment <= pagesize
               :	    && ceil_size <= arena_maxclass))
               :		ret = arena_malloc(choose_arena(), ceil_size, false);
               :	else {
               :		size_t run_size;
               :
               :		/*
               :		 * We can't achieve sub-page alignment, so round up alignment
               :		 * permanently; it makes later calculations simpler.
               :		 */
               :		alignment = PAGE_CEILING(alignment);
               :		ceil_size = PAGE_CEILING(size);
               :		/*
               :		 * (ceil_size < size) protects against very large sizes within
               :		 * pagesize of SIZE_T_MAX.
               :		 *
               :		 * (ceil_size + alignment < ceil_size) protects against the
               :		 * combination of maximal alignment and ceil_size large enough
               :		 * to cause overflow.  This is similar to the first overflow
               :		 * check above, but it needs to be repeated due to the new
               :		 * ceil_size value, which may now be *equal* to maximal
               :		 * alignment, whereas before we only detected overflow if the
               :		 * original size was *greater* than maximal alignment.
               :		 */
               :		if (ceil_size < size || ceil_size + alignment < ceil_size) {
               :			/* size_t overflow. */
               :			return (NULL);
               :		}
               :
               :		/*
               :		 * Calculate the size of the over-size run that arena_palloc()
               :		 * would need to allocate in order to guarantee the alignment.
               :		 */
               :		if (ceil_size >= alignment)
               :			run_size = ceil_size + alignment - pagesize;
               :		else {
               :			/*
               :			 * It is possible that (alignment << 1) will cause
               :			 * overflow, but it doesn't matter because we also
               :			 * subtract pagesize, which in the case of overflow
               :			 * leaves us with a very large run_size.  That causes
               :			 * the first conditional below to fail, which means
               :			 * that the bogus run_size value never gets used for
               :			 * anything important.
               :			 */
               :			run_size = (alignment << 1) - pagesize;
               :		}
               :
               :		if (run_size <= arena_maxclass) {
               :			ret = arena_palloc(choose_arena(), alignment, ceil_size,
               :			    run_size);
               :		} else if (alignment <= chunksize)
               :			ret = huge_malloc(ceil_size, false);
               :		else
               :			ret = huge_palloc(alignment, ceil_size);
               :	}
               :
               :	assert(((uintptr_t)ret & (alignment - 1)) == 0);
               :	return (ret);
               :}
               :
               :/* Return the size of the allocation pointed to by ptr. */
               :static size_t
               :arena_salloc(const void *ptr)
               :{
               :	size_t ret;
               :	arena_chunk_t *chunk;
               :	arena_chunk_map_t mapelm;
               :	size_t pageind;
               :
               :	assert(ptr != NULL);
               :	assert(CHUNK_ADDR2BASE(ptr) != ptr);
               :
               :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
     1 4.2e-04 :	pageind = (((uintptr_t)ptr - (uintptr_t)chunk) >> pagesize_2pow);
               :	mapelm = chunk->map[pageind];
    16  0.0067 :	if ((mapelm & CHUNK_MAP_LARGE) == 0) {
               :		arena_run_t *run;
               :
               :		/* Small allocation size is in the run header. */
               :		pageind -= (mapelm & CHUNK_MAP_POS_MASK);
               :		run = (arena_run_t *)((uintptr_t)chunk + (pageind <<
               :		    pagesize_2pow));
               :		assert(run->magic == ARENA_RUN_MAGIC);
    13  0.0055 :		ret = run->bin->reg_size;
               :	} else {
               :		arena_t *arena = chunk->arena;
               :		extent_node_t *node, key;
               :
               :		/* Large allocation size is in the extent tree. */
               :		assert((mapelm & CHUNK_MAP_POS_MASK) == 0);
               :		arena = chunk->arena;
               :		malloc_spin_lock(&arena->lock);
               :		key.addr = (void *)ptr;
               :		node = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad, &key);
               :		assert(node != NULL);
               :		ret = node->size;
               :		malloc_spin_unlock(&arena->lock);
               :	}
               :
               :	return (ret);
               :}
               :
               :static inline size_t
               :isalloc(const void *ptr)
               :{
               :	size_t ret;
               :	arena_chunk_t *chunk;
               :
               :	assert(ptr != NULL);
               :
     6  0.0025 :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
     3  0.0013 :	if (chunk != ptr) {
               :		/* Region. */
               :		assert(chunk->arena->magic == ARENA_MAGIC);
               :
               :		ret = arena_salloc(ptr);
               :	} else {
               :		extent_node_t *node, key;
               :
               :		/* Chunk (huge allocation). */
               :
               :		malloc_mutex_lock(&huge_mtx);
               :
               :		/* Extract from tree of huge allocations. */
               :		key.addr = __DECONST(void *, ptr);
               :		node = RB_FIND(extent_tree_ad_s, &huge, &key);
               :		assert(node != NULL);
               :
               :		ret = node->size;
               :
               :		malloc_mutex_unlock(&huge_mtx);
               :	}
               :
               :	return (ret);
               :}
               :
               :static inline void
               :arena_dalloc_small(arena_t *arena, arena_chunk_t *chunk, void *ptr,
               :    size_t pageind, arena_chunk_map_t mapelm)
               :{
               :	arena_run_t *run;
               :	arena_bin_t *bin;
               :	size_t size;
               :
               :	pageind -= (mapelm & CHUNK_MAP_POS_MASK);
               :
    71  0.0299 :	run = (arena_run_t *)((uintptr_t)chunk + (pageind << pagesize_2pow));
               :	assert(run->magic == ARENA_RUN_MAGIC);
    16  0.0067 :	bin = run->bin;
               :	size = bin->reg_size;
               :
               :/* #ifdef USE_STATS_MEMORY */
               :/*         arena->mi.fordblks += size; */
               :/* #endif */
               :#ifdef MALLOC_FILL
               :	if (opt_junk)
               :		memset(ptr, 0x5a, size);
               :#endif
               :
               :	arena_run_reg_dalloc(run, bin, ptr, size);
    39  0.0164 :	run->nfree++;
               :
    39  0.0164 :	if (run->nfree == bin->nregs) {
               :		/* Deallocate run. */
     5  0.0021 :		if (run == bin->runcur)
               :			bin->runcur = NULL;
               :		else if (bin->nregs != 1) {
               :			/*
               :			 * This block's conditional is necessary because if the
               :			 * run only contains one region, then it never gets
               :			 * inserted into the non-full runs tree.
               :			 */
     1 4.2e-04 :			RB_REMOVE(arena_run_tree_s, &bin->runs, run);
               :		}
               :#ifdef MALLOC_DEBUG
               :		run->magic = 0;
               :#endif
     3  0.0013 :		arena_run_dalloc(arena, run, true);
               :#ifdef MALLOC_STATS
               :		bin->stats.curruns--;
               :#endif
    62  0.0261 :	} else if (run->nfree == 1 && run != bin->runcur) {
               :		/*
               :		 * Make sure that bin->runcur always refers to the lowest
               :		 * non-full run, if one exists.
               :		 */
     6  0.0025 :		if (bin->runcur == NULL)
               :			bin->runcur = run;
     3  0.0013 :		else if ((uintptr_t)run < (uintptr_t)bin->runcur) {
               :			/* Switch runcur. */
    18  0.0076 :			if (bin->runcur->nfree > 0) {
               :				/* Insert runcur. */
               :				RB_INSERT(arena_run_tree_s, &bin->runs,
     7  0.0030 :				    bin->runcur);
               :			}
     6  0.0025 :			bin->runcur = run;
               :		} else
     3  0.0013 :			RB_INSERT(arena_run_tree_s, &bin->runs, run);
               :	}
               :#ifdef MALLOC_STATS
               :	arena->stats.allocated_small -= size;
               :	arena->stats.ndalloc_small++;
               :#endif
               :}
               :
               :#ifdef MALLOC_LAZY_FREE
               :static inline void
               :arena_dalloc_lazy(arena_t *arena, arena_chunk_t *chunk, void *ptr,
               :    size_t pageind, arena_chunk_map_t *mapelm)
               :{
               :	void **free_cache = arena->free_cache;
               :	unsigned i, slot;
               :
               :	if (g_isthreaded == false || opt_lazy_free_2pow < 0) {
               :		malloc_spin_lock(&arena->lock);
               :		arena_dalloc_small(arena, chunk, ptr, pageind, *mapelm);
               :		malloc_spin_unlock(&arena->lock);
               :		return;
               :	}
               :
               :	for (i = 0; i < LAZY_FREE_NPROBES; i++) {
               :		slot = PRN(lazy_free, opt_lazy_free_2pow);
               :		if (atomic_cmpset_ptr((uintptr_t *)&free_cache[slot],
               :		    (uintptr_t)NULL, (uintptr_t)ptr)) {
               :			return;
               :		}
               :	}
               :
               :	arena_dalloc_lazy_hard(arena, chunk, ptr, pageind, mapelm);
               :}
               :
               :static void
               :arena_dalloc_lazy_hard(arena_t *arena, arena_chunk_t *chunk, void *ptr,
               :    size_t pageind, arena_chunk_map_t *mapelm)
               :{
               :	void **free_cache = arena->free_cache;
               :	unsigned i, slot;
               :
               :	malloc_spin_lock(&arena->lock);
               :	arena_dalloc_small(arena, chunk, ptr, pageind, *mapelm);
               :
               :	/*
               :	 * Check whether another thread already cleared the cache.  It is
               :	 * possible that another thread cleared the cache *and* this slot was
               :	 * already refilled, which could result in a mostly fruitless cache
               :	 * sweep, but such a sequence of events causes no correctness issues.
               :	 */
               :	if ((ptr = (void *)atomic_readandclear_ptr(
               :	    (uintptr_t *)&free_cache[slot]))
               :	    != NULL) {
               :		unsigned lazy_free_mask;
               :		
               :		/*
               :		 * Clear the cache, since we failed to find a slot.  It is
               :		 * possible that other threads will continue to insert objects
               :		 * into the cache while this one sweeps, but that is okay,
               :		 * since on average the cache is still swept with the same
               :		 * frequency.
               :		 */
               :
               :		/* Handle pointer at current slot. */
               :		chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
               :		pageind = (((uintptr_t)ptr - (uintptr_t)chunk) >>
               :		    pagesize_2pow);
               :		mapelm = &chunk->map[pageind];
               :		arena_dalloc_small(arena, chunk, ptr, pageind, *mapelm);
               :
               :		/* Sweep remainder of slots. */
               :		lazy_free_mask = (1U << opt_lazy_free_2pow) - 1;
               :		for (i = (slot + 1) & lazy_free_mask;
               :		     i != slot;
               :		     i = (i + 1) & lazy_free_mask) {
               :			ptr = (void *)atomic_readandclear_ptr(
               :			    (uintptr_t *)&free_cache[i]);
               :			if (ptr != NULL) {
               :				chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
               :				pageind = (((uintptr_t)ptr - (uintptr_t)chunk)
               :				    >> pagesize_2pow);
               :				mapelm = &chunk->map[pageind];
               :				arena_dalloc_small(arena, chunk, ptr, pageind,
               :				    *mapelm);
               :			}
               :		}
               :	}
               :
               :	malloc_spin_unlock(&arena->lock);
               :}
               :#endif
               :
               :static void
               :arena_dalloc_large(arena_t *arena, arena_chunk_t *chunk, void *ptr)
               :{
               :	/* Large allocation. */
               :	malloc_spin_lock(&arena->lock);
               :
               :        chunk = 0;              /* this is just to quiet a compiler warning */
               :#ifdef MALLOC_FILL
               :#ifndef MALLOC_STATS
               :	if (opt_junk)
               :#endif
               :#endif
               :	{
               :		extent_node_t *node, key;
               :		size_t size;
               :
               :		key.addr = ptr;
               :		node = RB_FIND(extent_tree_ad_s,
               :		    &arena->runs_alloced_ad, &key);
               :		assert(node != NULL);
               :		size = node->size;
               :#ifdef MALLOC_FILL
               :#ifdef MALLOC_STATS
               :		if (opt_junk)
               :#endif
               :			memset(ptr, 0x5a, size);
               :#endif
               :/* #ifdef USE_STATS_MEMORY */
               :/*         arena->mi.fordblks += size; */
               :/* #endif */
               :#ifdef MALLOC_STATS
               :		arena->stats.allocated_large -= size;
               :#endif
               :	}
               :#ifdef MALLOC_STATS
               :	arena->stats.ndalloc_large++;
               :#endif
               :
    71  0.0299 :	arena_run_dalloc(arena, (arena_run_t *)ptr, true);
               :	malloc_spin_unlock(&arena->lock);
               :}
               :
               :static inline void
               :arena_dalloc(arena_t *arena, arena_chunk_t *chunk, void *ptr)
               :{
               :	size_t pageind;
               :	arena_chunk_map_t *mapelm;
               :
               :	assert(arena != NULL);
               :	assert(arena->magic == ARENA_MAGIC);
               :	assert(chunk->arena == arena);
               :	assert(ptr != NULL);
               :	assert(CHUNK_ADDR2BASE(ptr) != ptr);
               :
   597  0.2517 :	pageind = (((uintptr_t)ptr - (uintptr_t)chunk) >> pagesize_2pow);
               :	mapelm = &chunk->map[pageind];
   100  0.0422 :	if ((*mapelm & CHUNK_MAP_LARGE) == 0) {
               :		/* Small allocation. */
               :#ifdef MALLOC_LAZY_FREE
               :		arena_dalloc_lazy(arena, chunk, ptr, pageind, mapelm);
               :#else
               :		malloc_spin_lock(&arena->lock);
               :		arena_dalloc_small(arena, chunk, ptr, pageind, *mapelm);
               :		malloc_spin_unlock(&arena->lock);
               :#endif
               :	} else {
               :		assert((*mapelm & CHUNK_MAP_POS_MASK) == 0);
               :		arena_dalloc_large(arena, chunk, ptr);
               :	}
               :}
               :
               :static inline void
               :idalloc(void *ptr)
               :{
               :	arena_chunk_t *chunk;
               :
               :	assert(ptr != NULL);
               :
    24  0.0101 :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
    44  0.0185 :	if (chunk != ptr)
     1 4.2e-04 :		arena_dalloc(chunk->arena, chunk, ptr);
               :	else
               :		huge_dalloc(ptr);
               :}
               :
               :static void
               :arena_ralloc_large_shrink(arena_t *arena, arena_chunk_t *chunk, void *ptr,
               :    size_t size, size_t oldsize)
               :{
               :	extent_node_t *node, key;
               :
               :	assert(size < oldsize);
               :
               :	/*
               :	 * Shrink the run, and make trailing pages available for other
               :	 * allocations.
               :	 */
               :	key.addr = (void *)((uintptr_t)ptr);
               :#ifdef MALLOC_BALANCE
               :	arena_lock_balance(arena);
               :#else
               :	malloc_spin_lock(&arena->lock);
               :#endif
               :	node = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad, &key);
               :	assert(node != NULL);
               :	arena_run_trim_tail(arena, chunk, node, (arena_run_t *)ptr, oldsize,
               :	    size, true);
               :#ifdef MALLOC_STATS
               :	arena->stats.allocated_large -= oldsize - size;
               :#endif
               :	malloc_spin_unlock(&arena->lock);
               :}
               :
               :static bool
               :arena_ralloc_large_grow(arena_t *arena, arena_chunk_t *chunk, void *ptr,
               :    size_t size, size_t oldsize)
               :{
               :	extent_node_t *nodeC, key;
               :
               :	/* Try to extend the run. */
               :	assert(size > oldsize);
               :	key.addr = (void *)((uintptr_t)ptr + oldsize);
               :#ifdef MALLOC_BALANCE
               :	arena_lock_balance(arena);
               :#else
               :	malloc_spin_lock(&arena->lock);
               :#endif
               :	nodeC = RB_FIND(extent_tree_ad_s, &arena->runs_avail_ad, &key);
               :	if (nodeC != NULL && oldsize + nodeC->size >= size) {
               :		extent_node_t *nodeA, *nodeB;
               :
               :		/*
               :		 * The next run is available and sufficiently large.  Split the
               :		 * following run, then merge the first part with the existing
               :		 * allocation.  This results in a bit more tree manipulation
               :		 * than absolutely necessary, but it substantially simplifies
               :		 * the code.
               :		 */
               :		arena_run_split(arena, (arena_run_t *)nodeC->addr, size -
               :		    oldsize, false, false);
               :
               :		key.addr = ptr;
               :		nodeA = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad,
               :		    &key);
               :		assert(nodeA != NULL);
               :
               :		key.addr = (void *)((uintptr_t)ptr + oldsize);
               :		nodeB = RB_FIND(extent_tree_ad_s, &arena->runs_alloced_ad,
               :		    &key);
               :		assert(nodeB != NULL);
               :
               :		nodeA->size += nodeB->size;
               :
               :		RB_REMOVE(extent_tree_ad_s, &arena->runs_alloced_ad, nodeB);
               :		arena_chunk_node_dealloc(chunk, nodeB);
               :
               :#ifdef MALLOC_STATS
               :		arena->stats.allocated_large += size - oldsize;
               :#endif
               :		malloc_spin_unlock(&arena->lock);
               :		return (false);
               :	}
               :	malloc_spin_unlock(&arena->lock);
               :
               :	return (true);
               :}
               :
               :/*
               : * Try to resize a large allocation, in order to avoid copying.  This will
               : * always fail if growing an object, and the following run is already in use.
               : */
               :static bool
               :arena_ralloc_large(void *ptr, size_t size, size_t oldsize)
               :{
               :	size_t psize;
               :
               :	psize = PAGE_CEILING(size);
               :	if (psize == oldsize) {
               :		/* Same size class. */
               :#ifdef MALLOC_FILL
               :		if (opt_junk && size < oldsize) {
               :			memset((void *)((uintptr_t)ptr + size), 0x5a, oldsize -
               :			    size);
               :		}
               :#endif
               :		return (false);
               :	} else {
               :		arena_chunk_t *chunk;
               :		arena_t *arena;
               :
               :		chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
               :		arena = chunk->arena;
               :		assert(arena->magic == ARENA_MAGIC);
               :
               :		if (psize < oldsize) {
               :#ifdef MALLOC_FILL
               :			/* Fill before shrinking in order avoid a race. */
               :			if (opt_junk) {
               :				memset((void *)((uintptr_t)ptr + size), 0x5a,
               :				    oldsize - size);
               :			}
               :#endif
               :			arena_ralloc_large_shrink(arena, chunk, ptr, psize,
               :			    oldsize);
               :			return (false);
               :		} else {
               :			bool ret = arena_ralloc_large_grow(arena, chunk, ptr,
               :			    psize, oldsize);
               :#ifdef MALLOC_FILL
               :			if (ret == false && opt_zero) {
               :				memset((void *)((uintptr_t)ptr + oldsize), 0,
               :				    size - oldsize);
               :			}
               :#endif
               :			return (ret);
               :		}
               :	}
               :}
               :
               :static void *
               :arena_ralloc(void *ptr, size_t size, size_t oldsize)
               :{
               :	void *ret;
               :	size_t copysize;
               :
               :	/* Try to avoid moving the allocation. */
               :	if (size < small_min) {
               :		if (oldsize < small_min &&
               :		    ffs((int)(pow2_ceil(size) >> (TINY_MIN_2POW + 1)))
               :		    == ffs((int)(pow2_ceil(oldsize) >> (TINY_MIN_2POW + 1))))
               :			goto IN_PLACE; /* Same size class. */
     5  0.0021 :	} else if (size <= small_max) {
     7  0.0030 :		if (oldsize >= small_min && oldsize <= small_max &&
     1 4.2e-04 :		    (QUANTUM_CEILING(size) >> opt_quantum_2pow)
               :		    == (QUANTUM_CEILING(oldsize) >> opt_quantum_2pow))
               :			goto IN_PLACE; /* Same size class. */
               :	} else if (size <= bin_maxclass) {
               :		if (oldsize > small_max && oldsize <= bin_maxclass &&
               :		    pow2_ceil(size) == pow2_ceil(oldsize))
               :			goto IN_PLACE; /* Same size class. */
               :	} else if (oldsize > bin_maxclass && oldsize <= arena_maxclass) {
               :		assert(size > bin_maxclass);
               :		if (arena_ralloc_large(ptr, size, oldsize) == false)
               :			return (ptr);
               :	}
               :
               :	/*
               :	 * If we get here, then size and oldsize are different enough that we
               :	 * need to move the object.  In that case, fall back to allocating new
               :	 * space and copying.
               :	 */
               :	ret = arena_malloc(choose_arena(), size, false);
               :	if (ret == NULL)
               :		return (NULL);
               :
               :	/* Junk/zero-filling were already done by arena_malloc(). */
               :	copysize = (size < oldsize) ? size : oldsize;
               :#ifdef VM_COPY_MIN
               :	if (copysize >= VM_COPY_MIN)
               :		pages_copy(ret, ptr, copysize);
               :	else
               :#endif
               :		memcpy(ret, ptr, copysize);
               :	idalloc(ptr);
               :	return (ret);
               :IN_PLACE:
               :#ifdef MALLOC_FILL
               :	if (opt_junk && size < oldsize)
               :		memset((void *)((uintptr_t)ptr + size), 0x5a, oldsize - size);
               :	else if (opt_zero && size > oldsize)
               :		memset((void *)((uintptr_t)ptr + oldsize), 0, size - oldsize);
               :#endif
               :	return (ptr);
               :}
               :
               :static inline void *
               :iralloc(void *ptr, size_t size)
               :{
               :	size_t oldsize;
               :
               :	assert(ptr != NULL);
               :	assert(size != 0);
               :
               :	oldsize = isalloc(ptr);
               :
               :	if (size <= arena_maxclass)
               :		return (arena_ralloc(ptr, size, oldsize));
               :	else
               :		return (huge_ralloc(ptr, size, oldsize));
               :}
               :
               :static bool
               :arena_new(arena_t *arena)
               :{
               :	unsigned i;
               :	arena_bin_t *bin;
               :	size_t pow2_size, prev_run_size;
               :
               :	if (malloc_spin_init(&arena->lock))
               :		return (true);
               :
               :#ifdef MALLOC_STATS
               :	memset(&arena->stats, 0, sizeof(arena_stats_t));
               :#endif
               :
               :	/* Initialize chunks. */
               :	RB_INIT(&arena->chunks);
               :	arena->spare = NULL;
               :
               :	arena->ndirty = 0;
               :
               :	RB_INIT(&arena->runs_avail_szad);
               :	RB_INIT(&arena->runs_avail_ad);
               :	RB_INIT(&arena->runs_alloced_ad);
               :
               :#ifdef MALLOC_BALANCE
               :	arena->contention = 0;
               :#endif
               :#ifdef MALLOC_LAZY_FREE
               :	if (opt_lazy_free_2pow >= 0) {
               :		arena->free_cache = (void **) base_calloc(1, sizeof(void *)
               :		    * (1U << opt_lazy_free_2pow));
               :		if (arena->free_cache == NULL)
               :			return (true);
               :	} else
               :		arena->free_cache = NULL;
               :#endif
               :
               :	/* Initialize bins. */
               :	prev_run_size = pagesize;
               :
               :	/* (2^n)-spaced tiny bins. */
               :	for (i = 0; i < ntbins; i++) {
               :		bin = &arena->bins[i];
               :		bin->runcur = NULL;
               :		RB_INIT(&bin->runs);
               :
               :		bin->reg_size = (1U << (TINY_MIN_2POW + i));
               :
               :		prev_run_size = arena_bin_run_size_calc(bin, prev_run_size);
               :
               :#ifdef MALLOC_STATS
               :		memset(&bin->stats, 0, sizeof(malloc_bin_stats_t));
               :#endif
               :	}
               :
               :	/* Quantum-spaced bins. */
               :	for (; i < ntbins + nqbins; i++) {
               :		bin = &arena->bins[i];
               :		bin->runcur = NULL;
               :		RB_INIT(&bin->runs);
               :
               :		bin->reg_size = quantum * (i - ntbins + 1);
               :
               :		pow2_size = pow2_ceil(quantum * (i - ntbins + 1));
               :		prev_run_size = arena_bin_run_size_calc(bin, prev_run_size);
               :
               :#ifdef MALLOC_STATS
               :		memset(&bin->stats, 0, sizeof(malloc_bin_stats_t));
               :#endif
               :	}
               :
               :	/* (2^n)-spaced sub-page bins. */
               :	for (; i < ntbins + nqbins + nsbins; i++) {
               :		bin = &arena->bins[i];
               :		bin->runcur = NULL;
               :		RB_INIT(&bin->runs);
               :
               :		bin->reg_size = (small_max << (i - (ntbins + nqbins) + 1));
               :
               :		prev_run_size = arena_bin_run_size_calc(bin, prev_run_size);
               :
               :#ifdef MALLOC_STATS
               :		memset(&bin->stats, 0, sizeof(malloc_bin_stats_t));
               :#endif
               :	}
               :
               :#ifdef MALLOC_DEBUG
               :	arena->magic = ARENA_MAGIC;
               :#endif
               :
               :	return (false);
               :}
               :
               :/* Create a new arena and insert it into the arenas array at index ind. */
               :static arena_t *
               :arenas_extend(unsigned ind)
               :{
               :	arena_t *ret;
               :
               :	/* Allocate enough space for trailing bins. */
               :	ret = (arena_t *)base_alloc(sizeof(arena_t)
               :	    + (sizeof(arena_bin_t) * (ntbins + nqbins + nsbins - 1)));
               :	if (ret != NULL && arena_new(ret) == false) {
               :		arenas[ind] = ret;
               :		return (ret);
               :	}
               :	/* Only reached if there is an OOM error. */
               :
               :	/*
               :	 * OOM here is quite inconvenient to propagate, since dealing with it
               :	 * would require a check for failure in the fast path.  Instead, punt
               :	 * by using arenas[0].  In practice, this is an extremely unlikely
               :	 * failure.
               :	 */
               :	_malloc_message(_getprogname(),
               :	    ": (malloc) Error initializing arena\n", "", "");
               :	if (opt_abort)
               :		abort();
               :
               :	return (arenas[0]);
               :}
               :
               :/*
               : * End arena.
               : */
               :/******************************************************************************/
               :/*
               : * Begin general internal functions.
               : */
               :
               :static void *
               :huge_malloc(size_t size, bool zero)
               :{
               :	void *ret;
               :	size_t csize;
               :	extent_node_t *node;
               :
               :	/* Allocate one or more contiguous chunks for this request. */
               :
               :	csize = CHUNK_CEILING(size);
               :	if (csize == 0) {
               :		/* size is large enough to cause size_t wrap-around. */
               :		return (NULL);
               :	}
               :
               :	/* Allocate an extent node with which to track the chunk. */
               :	node = base_node_alloc();
               :	if (node == NULL)
               :		return (NULL);
               :
               :	ret = chunk_alloc(csize, zero);
               :	if (ret == NULL) {
               :		base_node_dealloc(node);
               :		return (NULL);
               :	}
               :
               :	/* Insert node into huge. */
               :	node->addr = ret;
               :	node->size = csize;
               :
               :	malloc_mutex_lock(&huge_mtx);
               :	RB_INSERT(extent_tree_ad_s, &huge, node);
               :#ifdef MALLOC_STATS
               :	huge_nmalloc++;
               :	huge_allocated += csize;
               :#endif
               :	malloc_mutex_unlock(&huge_mtx);
               :
               :#ifdef MALLOC_FILL
               :	if (zero == false) {
               :		if (opt_junk)
               :			memset(ret, 0xa5, csize);
               :		else if (opt_zero)
               :			memset(ret, 0, csize);
               :	}
               :#endif
               :
               :	return (ret);
               :}
               :
               :/* Only handles large allocations that require more than chunk alignment. */
               :static void *
               :huge_palloc(size_t alignment, size_t size)
               :{
               :	void *ret;
               :	size_t alloc_size, chunk_size, offset;
               :	extent_node_t *node;
               :
               :	/*
               :	 * This allocation requires alignment that is even larger than chunk
               :	 * alignment.  This means that huge_malloc() isn't good enough.
               :	 *
               :	 * Allocate almost twice as many chunks as are demanded by the size or
               :	 * alignment, in order to assure the alignment can be achieved, then
               :	 * unmap leading and trailing chunks.
               :	 */
               :	assert(alignment >= chunksize);
               :
               :	chunk_size = CHUNK_CEILING(size);
               :
               :	if (size >= alignment)
               :		alloc_size = chunk_size + alignment - chunksize;
               :	else
               :		alloc_size = (alignment << 1) - chunksize;
               :
               :	/* Allocate an extent node with which to track the chunk. */
               :	node = base_node_alloc();
               :	if (node == NULL)
               :		return (NULL);
               :
               :	ret = chunk_alloc(alloc_size, false);
               :	if (ret == NULL) {
               :		base_node_dealloc(node);
               :		return (NULL);
               :	}
               :
               :	offset = (uintptr_t)ret & (alignment - 1);
               :	assert((offset & chunksize_mask) == 0);
               :	assert(offset < alloc_size);
               :	if (offset == 0) {
               :		/* Trim trailing space. */
               :		chunk_dealloc((void *)((uintptr_t)ret + chunk_size), alloc_size
               :		    - chunk_size);
               :	} else {
               :		size_t trailsize;
               :
               :		/* Trim leading space. */
               :		chunk_dealloc(ret, alignment - offset);
               :
               :		ret = (void *)((uintptr_t)ret + (alignment - offset));
               :
               :		trailsize = alloc_size - (alignment - offset) - chunk_size;
               :		if (trailsize != 0) {
               :		    /* Trim trailing space. */
               :		    assert(trailsize < alloc_size);
               :		    chunk_dealloc((void *)((uintptr_t)ret + chunk_size),
               :			trailsize);
               :		}
               :	}
               :
               :	/* Insert node into huge. */
               :	node->addr = ret;
               :	node->size = chunk_size;
               :
               :	malloc_mutex_lock(&huge_mtx);
               :	RB_INSERT(extent_tree_ad_s, &huge, node);
               :#ifdef MALLOC_STATS
               :	huge_nmalloc++;
               :	huge_allocated += chunk_size;
               :#endif
               :	malloc_mutex_unlock(&huge_mtx);
               :
               :#ifdef MALLOC_FILL
               :	if (opt_junk)
               :		memset(ret, 0xa5, chunk_size);
               :	else if (opt_zero)
               :		memset(ret, 0, chunk_size);
               :#endif
               :
               :	return (ret);
               :}
               :
               :static void *
               :huge_ralloc(void *ptr, size_t size, size_t oldsize)
               :{
               :	void *ret;
               :	size_t copysize;
               :
               :	/* Avoid moving the allocation if the size class would not change. */
               :	if (oldsize > arena_maxclass &&
               :	    CHUNK_CEILING(size) == CHUNK_CEILING(oldsize)) {
               :#ifdef MALLOC_FILL
               :		if (opt_junk && size < oldsize) {
               :			memset((void *)((uintptr_t)ptr + size), 0x5a, oldsize
               :			    - size);
               :		} else if (opt_zero && size > oldsize) {
               :			memset((void *)((uintptr_t)ptr + oldsize), 0, size
               :			    - oldsize);
               :		}
               :#endif
               :		return (ptr);
               :	}
               :
               :	/*
               :	 * If we get here, then size and oldsize are different enough that we
               :	 * need to use a different size class.  In that case, fall back to
               :	 * allocating new space and copying.
               :	 */
               :	ret = huge_malloc(size, false);
               :	if (ret == NULL)
               :		return (NULL);
               :
               :	copysize = (size < oldsize) ? size : oldsize;
               :#ifdef VM_COPY_MIN
               :	if (copysize >= VM_COPY_MIN)
               :		pages_copy(ret, ptr, copysize);
               :	else
               :#endif
               :		memcpy(ret, ptr, copysize);
               :	idalloc(ptr);
               :	return (ret);
               :}
               :
               :static void
               :huge_dalloc(void *ptr)
               :{
               :	extent_node_t *node, key;
               :
               :	malloc_mutex_lock(&huge_mtx);
               :
               :	/* Extract from tree of huge allocations. */
               :	key.addr = ptr;
               :	node = RB_FIND(extent_tree_ad_s, &huge, &key);
               :	assert(node != NULL);
               :	assert(node->addr == ptr);
               :	RB_REMOVE(extent_tree_ad_s, &huge, node);
               :
               :#ifdef MALLOC_STATS
               :	huge_ndalloc++;
               :	huge_allocated -= node->size;
               :#endif
               :
               :	malloc_mutex_unlock(&huge_mtx);
               :
               :	/* Unmap chunk. */
               :#ifdef MALLOC_DSS
               :#ifdef MALLOC_FILL
               :	if (opt_dss && opt_junk)
               :		memset(node->addr, 0x5a, node->size);
               :#endif
               :#endif
               :	chunk_dealloc(node->addr, node->size);
               :
               :	base_node_dealloc(node);
               :}
               :
               :#ifdef BSD
               :static inline unsigned
               :malloc_ncpus(void)
               :{
               :	unsigned ret;
               :	int mib[2];
               :	size_t len;
               :
               :	mib[0] = CTL_HW;
               :	mib[1] = HW_NCPU;
               :	len = sizeof(ret);
               :	if (sysctl(mib, 2, &ret, &len, (void *) 0, 0) == -1) {
               :		/* Error. */
               :		return (1);
               :	}
               :
               :	return (ret);
               :}
               :#elif (defined(LINUX_HOST))
               :#include <fcntl.h>
               :
               :static inline unsigned
               :malloc_ncpus(void)
               :{
               :	unsigned ret;
               :	int fd, nread, column;
               :	char buf[1];
               :	static const char matchstr[] = "processor\t:";
               :
               :	/*
               :	 * sysconf(3) would be the preferred method for determining the number
               :	 * of CPUs, but it uses malloc internally, which causes untennable
               :	 * recursion during malloc initialization.
               :	 */
               :	fd = open("/proc/cpuinfo", O_RDONLY);
               :	if (fd == -1)
               :		return (1); /* Error. */
               :	/*
               :	 * Count the number of occurrences of matchstr at the beginnings of
               :	 * lines.  This treats hyperthreaded CPUs as multiple processors.
               :	 */
               :	column = 0;
               :	ret = 0;
               :	while (true) {
               :		nread = read(fd, &buf, sizeof(buf));
               :		if (nread <= 0)
               :			break; /* EOF or error. */
               :
               :		if (buf[0] == '\n')
               :			column = 0;
               :		else if (column != -1) {
               :			if (buf[0] == matchstr[column]) {
               :				column++;
               :				if (column == sizeof(matchstr) - 1) {
               :					column = -1;
               :					ret++;
               :				}
               :			} else
               :				column = -1;
               :		}
               :	}
               :	if (ret == 0)
               :		ret = 1; /* Something went wrong in the parser. */
               :	close(fd);
               :
               :	return (ret);
               :}
               :#elif (defined(DARWIN))
               :#include <mach/mach_init.h>
               :#include <mach/mach_host.h>
               :
               :static inline unsigned
               :malloc_ncpus(void)
               :{
               :	kern_return_t error;
               :	natural_t n;
               :	processor_info_array_t pinfo;
               :	mach_msg_type_number_t pinfocnt;
               :
               :	error = host_processor_info(mach_host_self(), PROCESSOR_BASIC_INFO,
               :				    &n, &pinfo, &pinfocnt);
               :	if (error != KERN_SUCCESS)
               :		return (1); /* Error. */
               :	else
               :		return (n);
               :}
               :#elif (defined(HAVE_KSTAT))
               :#include <kstat.h>
               :
               :static inline unsigned
               :malloc_ncpus(void)
               :{
               :	unsigned ret;
               :	kstat_ctl_t *ctl;
               :	kstat_t *kstat;
               :	kstat_named_t *named;
               :	unsigned i;
               :
               :	if ((ctl = kstat_open()) == NULL)
               :		return (1); /* Error. */
               :
               :	if ((kstat = kstat_lookup(ctl, "unix", -1, "system_misc")) == NULL)
               :		return (1); /* Error. */
               :
               :	if (kstat_read(ctl, kstat, NULL) == -1)
               :		return (1); /* Error. */
               :
               :	named = KSTAT_NAMED_PTR(kstat);
               :
               :	for (i = 0; i < kstat->ks_ndata; i++) {
               :		if (strcmp(named[i].name, "ncpus") == 0) {
               :			/* Figure out which one of these to actually use. */
               :			switch(named[i].data_type) {
               :			case KSTAT_DATA_INT32:
               :				ret = named[i].value.i32;
               :				break;
               :			case KSTAT_DATA_UINT32:
               :				ret = named[i].value.ui32;
               :				break;
               :			case KSTAT_DATA_INT64:
               :				ret = named[i].value.i64;
               :				break;
               :			case KSTAT_DATA_UINT64:
               :				ret = named[i].value.ui64;
               :				break;
               :			default:
               :				return (1); /* Error. */
               :			}
               :		}
               :	}
               :
               :	kstat_close(ctl); /* Don't bother checking for an error. */
               :
               :	return (ret);
               :}
               :#else
               :static inline unsigned
               :malloc_ncpus(void)
               :{
               :
               :	/*
               :	 * We lack a way to determine the number of CPUs on this platform, so
               :	 * assume 1 CPU.
               :	 */
               :	return (1);
               :}
               :#endif
               :
               :static void
               :malloc_print_stats(void)
               :{
               :
               :	if (opt_print_stats) {
               :		char s[UMAX2S_BUFSIZE];
               :		_malloc_message("___ Begin malloc statistics ___\n", "", "",
               :		    "");
               :		_malloc_message("Assertions ",
               :#ifdef NDEBUG
               :		    "disabled",
               :#else
               :		    "enabled",
               :#endif
               :		    "\n", "");
               :		_malloc_message("Boolean MALLOC_OPTIONS: ",
               :		    opt_abort ? "A" : "a", "", "");
               :#ifdef MALLOC_DSS
               :		_malloc_message(opt_dss ? "D" : "d", "", "", "");
               :#endif
               :#ifdef MALLOC_FILL
               :		_malloc_message(opt_junk ? "J" : "j", "", "", "");
               :#endif
               :#ifdef MALLOC_DSS
               :		_malloc_message(opt_mmap ? "M" : "m", "", "", "");
               :#endif
               :		_malloc_message("P", "", "", "");
               :#ifdef MALLOC_UTRACE
               :		_malloc_message(opt_utrace ? "U" : "u", "", "", "");
               :#endif
               :#ifdef MALLOC_SYSV
               :		_malloc_message(opt_sysv ? "V" : "v", "", "", "");
               :#endif
               :#ifdef MALLOC_XMALLOC
               :		_malloc_message(opt_xmalloc ? "X" : "x", "", "", "");
               :#endif
               :#ifdef MALLOC_FILL
               :		_malloc_message(opt_zero ? "Z" : "z", "", "", "");
               :#endif
               :		_malloc_message("\n", "", "", "");
               :
               :		_malloc_message("CPUs: ", umax2s(ncpus, s), "\n", "");
               :		_malloc_message("Max arenas: ", umax2s(narenas, s), "\n", "");
               :#ifdef MALLOC_LAZY_FREE
               :		if (opt_lazy_free_2pow >= 0) {
               :			_malloc_message("Lazy free slots: ",
               :			    umax2s(1U << opt_lazy_free_2pow, s), "\n", "");
               :		} else
               :			_malloc_message("Lazy free slots: 0\n", "", "", "");
               :#endif
               :#ifdef MALLOC_BALANCE
               :		_malloc_message("Arena balance threshold: ",
               :		    umax2s(opt_balance_threshold, s), "\n", "");
               :#endif
               :		_malloc_message("Pointer size: ", umax2s(sizeof(void *), s),
               :		    "\n", "");
               :		_malloc_message("Quantum size: ", umax2s(quantum, s), "\n", "");
               :		_malloc_message("Max small size: ", umax2s(small_max, s), "\n",
               :		    "");
               :		_malloc_message("Max dirty pages per arena: ",
               :		    umax2s(opt_dirty_max, s), "\n", "");
               :
               :		_malloc_message("Chunk size: ", umax2s(chunksize, s), "", "");
               :		_malloc_message(" (2^", umax2s(opt_chunk_2pow, s), ")\n", "");
               :
               :#ifdef MALLOC_STATS
               :		{
               :			size_t allocated, mapped;
               :#ifdef MALLOC_BALANCE
               :			uint64_t nbalance = 0;
               :#endif
               :			unsigned i;
               :			arena_t *arena;
               :
               :			/* Calculate and print allocated/mapped stats. */
               :
               :			/* arenas. */
               :			for (i = 0, allocated = 0; i < narenas; i++) {
               :				if (arenas[i] != NULL) {
               :					malloc_spin_lock(&arenas[i]->lock);
               :					allocated +=
               :					    arenas[i]->stats.allocated_small;
               :					allocated +=
               :					    arenas[i]->stats.allocated_large;
               :#ifdef MALLOC_BALANCE
               :					nbalance += arenas[i]->stats.nbalance;
               :#endif
               :					malloc_spin_unlock(&arenas[i]->lock);
               :				}
               :			}
               :
               :			/* huge/base. */
               :			malloc_mutex_lock(&huge_mtx);
               :			allocated += huge_allocated;
               :			mapped = stats_chunks.curchunks * chunksize;
               :			malloc_mutex_unlock(&huge_mtx);
               :
               :			malloc_mutex_lock(&base_mtx);
               :			mapped += base_mapped;
               :			malloc_mutex_unlock(&base_mtx);
               :
               :#ifdef WIN32
               :			malloc_printf("Allocated: %lu, mapped: %lu\n",
               :			    allocated, mapped);
               :#else
               :			malloc_printf("Allocated: %zu, mapped: %zu\n",
               :			    allocated, mapped);
               :#endif
               :
               :#ifdef MALLOC_BALANCE
               :			malloc_printf("Arena balance reassignments: %llu\n",
               :			    nbalance);
               :#endif
               :
               :			/* Print chunk stats. */
               :			{
               :				chunk_stats_t chunks_stats;
               :
               :				malloc_mutex_lock(&huge_mtx);
               :				chunks_stats = stats_chunks;
               :				malloc_mutex_unlock(&huge_mtx);
               :
               :				malloc_printf("chunks: nchunks   "
               :				    "highchunks    curchunks\n");
               :				malloc_printf("  %13llu%13lu%13lu\n",
               :				    chunks_stats.nchunks,
               :				    chunks_stats.highchunks,
               :				    chunks_stats.curchunks);
               :			}
               :
               :			/* Print chunk stats. */
               :			malloc_printf(
               :			    "huge: nmalloc      ndalloc    allocated\n");
               :#ifdef WIN32
               :			malloc_printf(" %12llu %12llu %12lu\n",
               :			    huge_nmalloc, huge_ndalloc, huge_allocated);
               :#else
               :			malloc_printf(" %12llu %12llu %12zu\n",
               :			    huge_nmalloc, huge_ndalloc, huge_allocated);
               :#endif
               :			/* Print stats for each arena. */
               :			for (i = 0; i < narenas; i++) {
               :				arena = arenas[i];
               :				if (arena != NULL) {
               :					malloc_printf(
               :					    "\narenas[%u]:\n", i);
               :					malloc_spin_lock(&arena->lock);
               :					stats_print(arena);
               :					malloc_spin_unlock(&arena->lock);
               :				}
               :			}
               :		}
               :#endif /* #ifdef MALLOC_STATS */
               :		_malloc_message("--- End malloc statistics ---\n", "", "", "");
               :	}
               :}
               :
               :/*
               : * FreeBSD's pthreads implementation calls malloc(3), so the malloc
               : * implementation has to take pains to avoid infinite recursion during
               : * initialization.
               : */
               :#if (defined(WIN32) || defined(DARWIN))
               :#define	malloc_init() false
               :#else
               :static inline bool
               :malloc_init(void)
               :{
   218  0.0919 :	if (malloc_initialized == false) /* calloc     13  0.0055, malloc   1811  0.7634, total:   1824  0.7689 */
               :		return (malloc_init_hard());
               :
               :	return (false);
               :}
               :#endif
               :
               :#ifndef WIN32
               :static
               :#endif
               :bool
               :malloc_init_hard(void)
               :{
               :	unsigned i;
               :	char buf[PATH_MAX + 1];
               :	const char *opts;
               :	long result;
               :#ifndef WIN32
               :	int linklen;
               :#endif
               :
               :#ifndef WIN32
               :	malloc_mutex_lock(&init_lock);
               :#endif
               :
               :	if (malloc_initialized) {
               :		/*
               :		 * Another thread initialized the allocator before this one
               :		 * acquired init_lock.
               :		 */
               :#ifndef WIN32
               :		malloc_mutex_unlock(&init_lock);
               :#endif
               :		return (false);
               :	}
               :
               :#ifdef WIN32
               :	/* get a thread local storage index */
               :	tlsIndex = TlsAlloc();
               :#endif
               :
               :	/* Get page size and number of CPUs */
               :#ifdef WIN32
               :	{
               :		SYSTEM_INFO info;
               :
               :		GetSystemInfo(&info);
               :		result = info.dwPageSize;
               :
               :		pagesize = (unsigned) result;
               :
               :		ncpus = info.dwNumberOfProcessors;
               :	}
               :#else
               :	ncpus = malloc_ncpus();
               :
               :	result = sysconf(_SC_PAGESIZE);
               :	assert(result != -1);
               :
               :	pagesize = (unsigned) result;
               :#endif
               :
               :	/*
               :	 * We assume that pagesize is a power of 2 when calculating
               :	 * pagesize_mask and pagesize_2pow.
               :	 */
               :	assert(((result - 1) & result) == 0);
               :	pagesize_mask = result - 1;
               :	pagesize_2pow = ffs((int)result) - 1;
               :
               :#ifdef MALLOC_LAZY_FREE
               :		if (ncpus == 1)
               :			opt_lazy_free_2pow = -1;
               :#endif
               :
               :	for (i = 0; i < 3; i++) {
               :		unsigned j;
               :
               :		/* Get runtime configuration. */
               :		switch (i) {
               :		case 0:
               :#ifndef WIN32
               :			if ((linklen = readlink("/etc/malloc.conf", buf,
               :						sizeof(buf) - 1)) != -1) {
               :				/*
               :				 * Use the contents of the "/etc/malloc.conf"
               :				 * symbolic link's name.
               :				 */
               :				buf[linklen] = '\0';
               :				opts = buf;
               :			} else
               :#endif
               :			{
               :				/* No configuration specified. */
               :				buf[0] = '\0';
               :				opts = buf;
               :			}
               :			break;
               :		case 1:
               :/* 			if (issetugid() == 0 && (opts = */
               :/* 			    getenv("MALLOC_OPTIONS")) != NULL) { */
               :/* 				/\* */
               :/* 				 * Do nothing; opts is already initialized to */
               :/* 				 * the value of the MALLOC_OPTIONS environment */
               :/* 				 * variable. */
               :/* 				 *\/ */
               :/* 			} else { */
               :				/* No configuration specified. */
               :				buf[0] = '\0';
               :				opts = buf;
               :/* 			} */
               :			break;
               :		case 2:
               :			if (_malloc_options != NULL) {
               :				/*
               :				 * Use options that were compiled into the
               :				 * program.
               :				 */
               :				opts = _malloc_options;
               :			} else {
               :				/* No configuration specified. */
               :				buf[0] = '\0';
               :				opts = buf;
               :			}
               :			break;
               :		default:
               :			/* NOTREACHED */
               :			buf[0] = '\0';
               :			opts = buf;
               :			assert(false);
               :		}
               :
               :		for (j = 0; opts[j] != '\0'; j++) {
               :			unsigned k, nreps;
               :			bool nseen;
               :
               :			/* Parse repetition count, if any. */
               :			for (nreps = 0, nseen = false;; j++, nseen = true) {
               :				switch (opts[j]) {
               :					case '0': case '1': case '2': case '3':
               :					case '4': case '5': case '6': case '7':
               :					case '8': case '9':
               :						nreps *= 10;
               :						nreps += opts[j] - '0';
               :						break;
               :					default:
               :						goto MALLOC_OUT;
               :				}
               :			}
               :MALLOC_OUT:
               :			if (nseen == false)
               :				nreps = 1;
               :
               :			for (k = 0; k < nreps; k++) {
               :				switch (opts[j]) {
               :				case 'a':
               :					opt_abort = false;
               :					break;
               :				case 'A':
               :					opt_abort = true;
               :					break;
               :				case 'b':
               :#ifdef MALLOC_BALANCE
               :					opt_balance_threshold >>= 1;
               :#endif
               :					break;
               :				case 'B':
               :#ifdef MALLOC_BALANCE
               :					if (opt_balance_threshold == 0)
               :						opt_balance_threshold = 1;
               :					else if ((opt_balance_threshold << 1)
               :					    > opt_balance_threshold)
               :						opt_balance_threshold <<= 1;
               :#endif
               :					break;
               :				case 'd':
               :#ifdef MALLOC_DSS
               :					opt_dss = false;
               :#endif
               :					break;
               :				case 'D':
               :#ifdef MALLOC_DSS
               :					opt_dss = true;
               :#endif
               :					break;
               :				case 'f':
               :					opt_dirty_max >>= 1;
               :					break;
               :				case 'F':
               :					if (opt_dirty_max == 0)
               :						opt_dirty_max = 1;
               :					else if ((opt_dirty_max << 1) != 0)
               :						opt_dirty_max <<= 1;
               :					break;
               :#ifdef MALLOC_FILL
               :				case 'j':
               :					opt_junk = false;
               :					break;
               :				case 'J':
               :					opt_junk = true;
               :					break;
               :#endif
               :				case 'k':
               :					/*
               :					 * Chunks always require at least one
               :					 * header page, so chunks can never be
               :					 * smaller than two pages.
               :					 */
               :					if (opt_chunk_2pow > pagesize_2pow + 1)
               :						opt_chunk_2pow--;
               :					break;
               :				case 'K':
               :					if (opt_chunk_2pow + 1 <
               :					    (sizeof(size_t) << 3))
               :						opt_chunk_2pow++;
               :					break;
               :				case 'l':
               :#ifdef MALLOC_LAZY_FREE
               :					if (opt_lazy_free_2pow >= 0)
               :						opt_lazy_free_2pow--;
               :#endif
               :					break;
               :				case 'L':
               :#ifdef MALLOC_LAZY_FREE
               :					if (ncpus > 1)
               :						opt_lazy_free_2pow++;
               :#endif
               :					break;
               :				case 'm':
               :#ifdef MALLOC_DSS
               :					opt_mmap = false;
               :#endif
               :					break;
               :				case 'M':
               :#ifdef MALLOC_DSS
               :					opt_mmap = true;
               :#endif
               :					break;
               :				case 'n':
               :					opt_narenas_lshift--;
               :					break;
               :				case 'N':
               :					opt_narenas_lshift++;
               :					break;
               :				case 'p':
               :					opt_print_stats = false;
               :					break;
               :				case 'P':
               :					opt_print_stats = true;
               :					break;
               :				case 'q':
               :					if (opt_quantum_2pow > QUANTUM_2POW_MIN)
               :						opt_quantum_2pow--;
               :					break;
               :				case 'Q':
               :					if (opt_quantum_2pow < pagesize_2pow -
               :					    1)
               :						opt_quantum_2pow++;
               :					break;
               :				case 's':
               :					if (opt_small_max_2pow >
               :					    QUANTUM_2POW_MIN)
               :						opt_small_max_2pow--;
               :					break;
               :				case 'S':
               :					if (opt_small_max_2pow < pagesize_2pow
               :					    - 1)
               :						opt_small_max_2pow++;
               :					break;
               :#ifdef MALLOC_UTRACE
               :				case 'u':
               :					opt_utrace = false;
               :					break;
               :				case 'U':
               :					opt_utrace = true;
               :					break;
               :#endif
               :#ifdef MALLOC_SYSV
               :				case 'v':
               :					opt_sysv = false;
               :					break;
               :				case 'V':
               :					opt_sysv = true;
               :					break;
               :#endif
               :#ifdef MALLOC_XMALLOC
               :				case 'x':
               :					opt_xmalloc = false;
               :					break;
               :				case 'X':
               :					opt_xmalloc = true;
               :					break;
               :#endif
               :#ifdef MALLOC_FILL
               :				case 'z':
               :					opt_zero = false;
               :					break;
               :				case 'Z':
               :					opt_zero = true;
               :					break;
               :#endif
               :				default: {
               :					char cbuf[2];
               :
               :					cbuf[0] = opts[j];
               :					cbuf[1] = '\0';
               :					_malloc_message(_getprogname(),
               :					    ": (malloc) Unsupported character "
               :					    "in malloc options: '", cbuf,
               :					    "'\n");
               :				}
               :				}
               :			}
               :		}
               :	}
               :
               :#ifdef MALLOC_DSS
               :	/* Make sure that there is some method for acquiring memory. */
               :	if (opt_dss == false && opt_mmap == false)
               :		opt_mmap = true;
               :#endif
               :
               :	/* Take care to call atexit() only once. */
               :	if (opt_print_stats) {
               :#ifndef WIN32
               :		/* Print statistics at exit. */
               :		atexit(malloc_print_stats);
               :#endif
               :	}
               :
               :	/* Set variables according to the value of opt_small_max_2pow. */
               :	if (opt_small_max_2pow < opt_quantum_2pow)
               :		opt_small_max_2pow = opt_quantum_2pow;
               :	small_max = (1U << opt_small_max_2pow);
               :
               :	/* Set bin-related variables. */
               :	bin_maxclass = (pagesize >> 1);
               :	assert(opt_quantum_2pow >= TINY_MIN_2POW);
               :	ntbins = opt_quantum_2pow - TINY_MIN_2POW;
               :	assert(ntbins <= opt_quantum_2pow);
               :	nqbins = (small_max >> opt_quantum_2pow);
               :	nsbins = pagesize_2pow - opt_small_max_2pow - 1;
               :
               :	/* Set variables according to the value of opt_quantum_2pow. */
               :	quantum = (1U << opt_quantum_2pow);
               :	quantum_mask = quantum - 1;
               :	if (ntbins > 0)
               :		small_min = (quantum >> 1) + 1;
               :	else
               :		small_min = 1;
               :	assert(small_min <= quantum);
               :
               :	/* Set variables according to the value of opt_chunk_2pow. */
               :	chunksize = (1LU << opt_chunk_2pow);
               :	chunksize_mask = chunksize - 1;
               :	chunk_npages = (chunksize >> pagesize_2pow);
               :	{
               :		size_t header_size;
               :
               :		/*
               :		 * Compute the header size such that it is large
               :		 * enough to contain the page map and enough nodes for the
               :		 * worst case: one node per non-header page plus one extra for
               :		 * situations where we briefly have one more node allocated
               :		 * than we will need.
               :		 */
               :		header_size = sizeof(arena_chunk_t) +
               :		    (sizeof(arena_chunk_map_t) * (chunk_npages - 1)) +
               :		    (sizeof(extent_node_t) * chunk_npages);
               :		arena_chunk_header_npages = (header_size >> pagesize_2pow) +
               :		    ((header_size & pagesize_mask) != 0);
               :	}
               :	arena_maxclass = chunksize - (arena_chunk_header_npages <<
               :	    pagesize_2pow);
               :#ifdef MALLOC_LAZY_FREE
               :	/*
               :	 * Make sure that allocating the free_cache does not exceed the limits
               :	 * of what base_alloc() can handle.
               :	 */
               :	while ((sizeof(void *) << opt_lazy_free_2pow) > chunksize)
               :		opt_lazy_free_2pow--;
               :#endif
               :
               :	UTRACE(0, 0, 0);
               :
               :#ifdef MALLOC_STATS
               :	memset(&stats_chunks, 0, sizeof(chunk_stats_t));
               :#endif
               :
               :	/* Various sanity checks that regard configuration. */
               :	assert(quantum >= sizeof(void *));
               :	assert(quantum <= pagesize);
               :	assert(chunksize >= pagesize);
               :	assert(quantum * 4 <= chunksize);
               :
               :	/* Initialize chunks data. */
               :	malloc_mutex_init(&huge_mtx);
               :	RB_INIT(&huge);
               :#ifdef MALLOC_DSS
               :	malloc_mutex_init(&dss_mtx);
               :	dss_base = sbrk(0);
               :	dss_prev = dss_base;
               :	dss_max = dss_base;
               :	RB_INIT(&dss_chunks_szad);
               :	RB_INIT(&dss_chunks_ad);
               :#endif
               :#ifdef MALLOC_STATS
               :	huge_nmalloc = 0;
               :	huge_ndalloc = 0;
               :	huge_allocated = 0;
               :#endif
               :
               :	/* Initialize base allocation data structures. */
               :#ifdef MALLOC_STATS
               :	base_mapped = 0;
               :#endif
               :#ifdef MALLOC_DSS
               :	/*
               :	 * Allocate a base chunk here, since it doesn't actually have to be
               :	 * chunk-aligned.  Doing this before allocating any other chunks allows
               :	 * the use of space that would otherwise be wasted.
               :	 */
               :	if (opt_dss)
               :		base_pages_alloc(0);
               :#endif
               :	base_nodes = NULL;
               :	malloc_mutex_init(&base_mtx);
               :
               :	if (ncpus > 1) {
               :		/*
               :		 * For SMP systems, create four times as many arenas as there
               :		 * are CPUs by default.
               :		 */
               :		opt_narenas_lshift += 2;
               :	}
               :
               :	/* Determine how many arenas to use. */
               :	narenas = ncpus;
               :	if (opt_narenas_lshift > 0) {
               :		if ((narenas << opt_narenas_lshift) > narenas)
               :			narenas <<= opt_narenas_lshift;
               :		/*
               :		 * Make sure not to exceed the limits of what base_alloc() can
               :		 * handle.
               :		 */
               :		if (narenas * sizeof(arena_t *) > chunksize)
               :			narenas = chunksize / sizeof(arena_t *);
               :	} else if (opt_narenas_lshift < 0) {
               :		if ((narenas >> -opt_narenas_lshift) < narenas)
               :			narenas >>= -opt_narenas_lshift;
               :		/* Make sure there is at least one arena. */
               :		if (narenas == 0)
               :			narenas = 1;
               :	}
               :#ifdef MALLOC_BALANCE
               :	assert(narenas != 0);
               :	for (narenas_2pow = 0;
               :	     (narenas >> (narenas_2pow + 1)) != 0;
               :	     narenas_2pow++);
               :#endif
               :
               :#ifdef NO_TLS
               :	if (narenas > 1) {
               :		static const unsigned primes[] = {1, 3, 5, 7, 11, 13, 17, 19,
               :		    23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
               :		    89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
               :		    151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
               :		    223, 227, 229, 233, 239, 241, 251, 257, 263};
               :		unsigned nprimes, parenas;
               :
               :		/*
               :		 * Pick a prime number of hash arenas that is more than narenas
               :		 * so that direct hashing of pthread_self() pointers tends to
               :		 * spread allocations evenly among the arenas.
               :		 */
               :		assert((narenas & 1) == 0); /* narenas must be even. */
               :		nprimes = (sizeof(primes) >> SIZEOF_INT_2POW);
               :		parenas = primes[nprimes - 1]; /* In case not enough primes. */
               :		for (i = 1; i < nprimes; i++) {
               :			if (primes[i] > narenas) {
               :				parenas = primes[i];
               :				break;
               :			}
               :		}
               :		narenas = parenas;
               :	}
               :#endif
               :
               :#ifndef NO_TLS
               :#  ifndef MALLOC_BALANCE
               :	next_arena = 0;
               :#  endif
               :#endif
               :
               :	/* Allocate and initialize arenas. */
               :	arenas = (arena_t **)base_alloc(sizeof(arena_t *) * narenas);
               :	if (arenas == NULL) {
               :#ifndef WIN32
               :		malloc_mutex_unlock(&init_lock);
               :#endif
               :		return (true);
               :	}
               :	/*
               :	 * Zero the array.  In practice, this should always be pre-zeroed,
               :	 * since it was just mmap()ed, but let's be sure.
               :	 */
               :	memset(arenas, 0, sizeof(arena_t *) * narenas);
               :
               :	/*
               :	 * Initialize one arena here.  The rest are lazily created in
               :	 * choose_arena_hard().
               :	 */
               :	arenas_extend(0);
               :	if (arenas[0] == NULL) {
               :#ifndef WIN32
               :		malloc_mutex_unlock(&init_lock);
               :#endif
               :		return (true);
               :	}
               :#ifndef NO_TLS
               :	/*
               :	 * Assign the initial arena to the initial thread, in order to avoid
               :	 * spurious creation of an extra arena if the application switches to
               :	 * threaded mode.
               :	 */
               :#ifdef WIN32
               :	TlsSetValue(tlsIndex, arenas[0]);
               :#else
               :	arenas_map = arenas[0];
               :#endif
               :#endif
               :
               :	/*
               :	 * Seed here for the initial thread, since choose_arena_hard() is only
               :	 * called for other threads.  The seed values don't really matter.
               :	 */
               :#ifdef MALLOC_LAZY_FREE
               :	SPRN(lazy_free, 42);
               :#endif
               :#ifdef MALLOC_BALANCE
               :	SPRN(balance, 42);
               :#endif
               :
               :	malloc_spin_init(&arenas_lock);
               :
               :	malloc_initialized = true;
               :#ifndef WIN32
               :	malloc_mutex_unlock(&init_lock);
               :#endif
               :	return (false);
               :}
               :
               :/* XXX Why not just expose malloc_print_stats()? */
               :#ifdef WIN32
               :void
               :malloc_shutdown()
               :{
               :
               :	malloc_print_stats();
               :}
               :#endif
               :
               :/*
               : * End general internal functions.
               : */
               :/******************************************************************************/
               :/*
               : * Begin malloc(3)-compatible functions.
               : */
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void *
               :moz_malloc(size_t size)
               :#else
               :void *
               :malloc(size_t size)
               :#endif
               :{
               :	void *ret;
               :
               :	if (malloc_init()) {
               :		ret = NULL;
               :		goto RETURN;
               :	}
               :
    11  0.0046 :	if (size == 0) {
               :#ifdef MALLOC_SYSV
               :		if (opt_sysv == false)
               :#endif
               :			size = 1;
               :#ifdef MALLOC_SYSV
               :		else {
               :			ret = NULL;
               :			goto RETURN;
               :		}
               :#endif
               :	}
               :
               :	ret = imalloc(size);
               :
               :RETURN:
    32  0.0135 :	if (ret == NULL) {
               :#ifdef MALLOC_XMALLOC
               :		if (opt_xmalloc) {
               :			_malloc_message(_getprogname(),
               :			    ": (malloc) Error in malloc(): out of memory\n", "",
               :			    "");
               :			abort();
               :		}
               :#endif
               :		errno = ENOMEM;
               :	}
               :
               :	UTRACE(0, size, ret);
               :	return (ret);
    55  0.0232 :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline int
               :moz_posix_memalign(void **memptr, size_t alignment, size_t size)
               :#else
               :int
               :posix_memalign(void **memptr, size_t alignment, size_t size)
               :#endif
     4  0.0017 :{ /* posix_memalign total:     20  0.0084 */
               :	int ret;
               :	void *result;
               :
               :	if (malloc_init())
               :		result = NULL;
               :	else {
               :		/* Make sure that alignment is a large enough power of 2. */
               :		if (((alignment - 1) & alignment) != 0
               :		    || alignment < sizeof(void *)) {
               :#ifdef MALLOC_XMALLOC
               :			if (opt_xmalloc) {
               :				_malloc_message(_getprogname(),
               :				    ": (malloc) Error in posix_memalign(): "
               :				    "invalid alignment\n", "", "");
               :				abort();
               :			}
               :#endif
               :			result = NULL;
               :			ret = EINVAL;
               :			goto RETURN;
               :		}
               :
               :		result = ipalloc(alignment, size);
               :	}
               :
     1 4.2e-04 :	if (result == NULL) {
               :#ifdef MALLOC_XMALLOC
               :		if (opt_xmalloc) {
               :			_malloc_message(_getprogname(),
               :			": (malloc) Error in posix_memalign(): out of memory\n",
               :			"", "");
               :			abort();
               :		}
               :#endif
               :		ret = ENOMEM;
               :		goto RETURN;
               :	}
               :
               :	*memptr = result;
               :	ret = 0;
               :
               :RETURN:
               :	UTRACE(0, size, result);
               :	return (ret);
     1 4.2e-04 :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void *
               :moz_memalign(size_t alignment, size_t size)
               :#else
               :void *
               :memalign(size_t alignment, size_t size)
               :#endif
               :{
               :	void *ret;
               :
               :#ifdef DARWIN
               :	if (moz_posix_memalign(&ret, alignment, size) != 0)
               :#else
               :	if (posix_memalign(&ret, alignment, size) != 0)
               :#endif
               :		return (NULL);
               :
               :	return ret;
               :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void *
               :moz_valloc(size_t size)
               :#else
               :void *
               :valloc(size_t size)
               :#endif
               :{
               :#ifdef DARWIN
               :	return (moz_memalign(pagesize, size));
               :#else
               :	return (memalign(pagesize, size));
               :#endif
               :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void *
               :moz_calloc(size_t num, size_t size)
               :#else
               :void *
               :calloc(size_t num, size_t size)
               :#endif
               :{
               :	void *ret;
               :	size_t num_size;
               :
               :	if (malloc_init()) {
               :		num_size = 0;
               :		ret = NULL;
               :		goto RETURN;
               :	}
               :
               :	num_size = num * size;
               :	if (num_size == 0) {
               :#ifdef MALLOC_SYSV
               :		if ((opt_sysv == false) && ((num == 0) || (size == 0)))
               :#endif
               :			num_size = 1;
               :#ifdef MALLOC_SYSV
               :		else {
               :			ret = NULL;
               :			goto RETURN;
               :		}
               :#endif
               :	/*
               :	 * Try to avoid division here.  We know that it isn't possible to
               :	 * overflow during multiplication if neither operand uses any of the
               :	 * most significant half of the bits in a size_t.
               :	 */
               :	} else if (((num | size) & (SIZE_T_MAX << (sizeof(size_t) << 2)))
               :	    && (num_size / size != num)) {
               :		/* size_t overflow. */
               :		ret = NULL;
               :		goto RETURN;
               :	}
               :
               :	ret = icalloc(num_size);
               :
               :RETURN:
     1 4.2e-04 :	if (ret == NULL) {
               :#ifdef MALLOC_XMALLOC
               :		if (opt_xmalloc) {
               :			_malloc_message(_getprogname(),
               :			    ": (malloc) Error in calloc(): out of memory\n", "",
               :			    "");
               :			abort();
               :		}
               :#endif
               :		errno = ENOMEM;
               :	}
               :
               :	UTRACE(0, num_size, ret);
               :	return (ret);
               :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void *
               :moz_realloc(void *ptr, size_t size)
               :#else
               :void *
               :realloc(void *ptr, size_t size)
               :#endif
               :{
               :	void *ret;
               :
    14  0.0059 :	if (size == 0) { /* realloc total:    160  0.0674 */
               :#ifdef MALLOC_SYSV
               :		if (opt_sysv == false)
               :#endif
               :			size = 1;
               :#ifdef MALLOC_SYSV
               :		else {
               :			if (ptr != NULL)
               :				idalloc(ptr);
               :			ret = NULL;
               :			goto RETURN;
               :		}
               :#endif
               :	}
               :
     1 4.2e-04 :	if (ptr != NULL) {
               :		assert(malloc_initialized);
               :
               :		ret = iralloc(ptr, size);
               :
               :		if (ret == NULL) {
               :#ifdef MALLOC_XMALLOC
               :			if (opt_xmalloc) {
               :				_malloc_message(_getprogname(),
               :				    ": (malloc) Error in realloc(): out of "
               :				    "memory\n", "", "");
               :				abort();
               :			}
               :#endif
               :			errno = ENOMEM;
               :		}
               :	} else {
               :		if (malloc_init())
               :			ret = NULL;
               :		else
               :			ret = imalloc(size);
               :
               :		if (ret == NULL) {
               :#ifdef MALLOC_XMALLOC
               :			if (opt_xmalloc) {
               :				_malloc_message(_getprogname(),
               :				    ": (malloc) Error in realloc(): out of "
               :				    "memory\n", "", "");
               :				abort();
               :			}
               :#endif
     2 8.4e-04 :			errno = ENOMEM;
               :		}
               :	}
               :
               :#ifdef MALLOC_SYSV
               :RETURN:
               :#endif
               :	UTRACE(ptr, size, ret);
               :	return (ret);
     5  0.0021 :}
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline void
               :moz_free(void *ptr)
               :#else
               :void
               :free(void *ptr)
               :#endif
               :{
               :
               :	UTRACE(ptr, 0, 0);
   210  0.0885 :	if (ptr != NULL) { /* free total:   3003  1.2658 */
               :		assert(malloc_initialized);
               :
               :		idalloc(ptr);
               :	}
    62  0.0261 :}
               :
               :/*
               : * This is a work in progress, which doesn't even get used.
               : */
               :#ifdef USE_STATS_MEMORY
               :/* Utility to update mallinfo for malloc_stats() and mallinfo() */
               :
               :static void
               :malloc_update_mallinfo(arena_t *arena, struct mallinfo *mi)
               :{
               :  int i, navail;
               :  size_t avail;
               :  avail = chunksize * narenas;
               :
               :#if 0
               :  malloc_printf("allocated:   %u %u %u\n",
               :                arena->stats.allocated_small + arena->stats.allocated_large,
               :                arena->stats.nmalloc_small + arena->stats.nmalloc_large,
               :                arena->stats.ndalloc_small + arena->stats.ndalloc_large);
               :  
               :  malloc_printf("available:   %u\n", avail);
               :#endif
               :  
               :/*   stats_print(arena); */
               :  malloc_spin_lock(&arena->lock);
               :
               :  /* clear unused fields */
               :  mi->arena = mi->ordblks = mi->smblks = mi->usmblks = mi->fsmblks = 0;
               :  mi->uordblks = arena->stats.allocated_small + arena->stats.allocated_large;
               :  mi->fordblks = arena->stats.mapped - mi->uordblks;
               :  
               :  mi->hblks = mi->hblkhd = 0;
               :  mi->keepcost = arena->stats.mapped;
               :  malloc_spin_unlock(&arena->lock);
               :}
               :
               :#ifndef DARWIN
               :DSOEXPORT
               :struct mallinfo
               :mallinfo()
               :{
               :    struct mallinfo mi;
               :
               :    /* Calculate and print allocated/mapped stats. */
               :    malloc_update_mallinfo(choose_arena(), &mi);
               :    return mi;
               :}
               :# endif
               :#endif
               :
               :/*
               : * End malloc(3)-compatible functions.
               : */
               :/******************************************************************************/
               :/*
               : * Begin non-standard functions.
               : */
               :
               :DSOEXPORT
               :#ifdef DARWIN
               :inline size_t
               :moz_malloc_usable_size(const void *ptr)
               :#else
               :size_t
               :malloc_usable_size(const void *ptr)
               :#endif
               :{
               :
               :	assert(ptr != NULL);
               :
               :	return (isalloc(ptr));
               :}
               :
               :#ifdef WIN32
               :void*
               :_recalloc(void *ptr, size_t count, size_t size)
               :{
               :	size_t oldsize = (ptr != NULL) ? isalloc(ptr) : 0;
               :	size_t newsize = count * size;
               :
               :	/*
               :	 * In order for all trailing bytes to be zeroed, the caller needs to
               :	 * use calloc(), followed by recalloc().  However, the current calloc()
               :	 * implementation only zeros the bytes requested, so if recalloc() is
               :	 * to work 100% correctly, calloc() will need to change to zero
               :	 * trailing bytes.
               :	 */
               :
               :	ptr = realloc(ptr, newsize);
               :	if (ptr != NULL && oldsize < newsize) {
               :		memset((void *)((uintptr_t)ptr + oldsize), 0, newsize -
               :		    oldsize);
               :	}
               :
               :	return ptr;
               :}
               :
               :/*
               : * This impl of _expand doesn't ever actually expand or shrink blocks: it
               : * simply replies that you may continue using a shrunk block.
               : */
               :void*
               :_expand(void *ptr, size_t newsize)
               :{
               :	if (isalloc(ptr) >= newsize)
               :		return ptr;
               :
               :	return NULL;
               :}
               :
               :size_t
               :_msize(const void *ptr)
               :{
               :
               :	return malloc_usable_size(ptr);
               :}
               :#endif
               :
               :
               :/*
               : * End non-standard functions.
               : */
               :/******************************************************************************/
               :/*
               : * Begin library-private functions, used by threading libraries for protection
               : * of malloc during fork().  These functions are only called if the program is
               : * running in threaded mode, so there is no need to check whether the program
               : * is threaded here.
               : */
               :
               :void
               :_malloc_prefork(void)
               :{
               :	unsigned i;
               :
               :	/* Acquire all mutexes in a safe order. */
               :
               :	malloc_spin_lock(&arenas_lock);
               :	for (i = 0; i < narenas; i++) {
               :		if (arenas[i] != NULL)
               :			malloc_spin_lock(&arenas[i]->lock);
               :	}
               :	malloc_spin_unlock(&arenas_lock);
               :
               :	malloc_mutex_lock(&base_mtx);
               :
               :	malloc_mutex_lock(&huge_mtx);
               :
               :#ifdef MALLOC_DSS
               :	malloc_mutex_lock(&dss_mtx);
               :#endif
               :}
               :
               :void
               :_malloc_postfork(void)
               :{
               :	unsigned i;
               :
               :	/* Release all mutexes, now that fork() has completed. */
               :
               :#ifdef MALLOC_DSS
               :	malloc_mutex_unlock(&dss_mtx);
               :#endif
               :
               :	malloc_mutex_unlock(&huge_mtx);
               :
               :	malloc_mutex_unlock(&base_mtx);
               :
               :	malloc_spin_lock(&arenas_lock);
               :	for (i = 0; i < narenas; i++) {
               :		if (arenas[i] != NULL)
               :			malloc_spin_unlock(&arenas[i]->lock);
               :	}
               :	malloc_spin_unlock(&arenas_lock);
               :}
               :
               :/*
               : * End library-private functions.
               : */
               :/******************************************************************************/
               :
               :
               :#ifdef DARWIN
               :static malloc_zone_t zone;
               :static struct malloc_introspection_t zone_introspect;
               :
               :static size_t
               :zone_size(malloc_zone_t *zone, void *ptr)
               :{
               :	size_t ret = 0;
               :	arena_chunk_t *chunk;
               :
               :	/*
               :	 * There appear to be places within Darwin (such as setenv(3)) that
               :	 * cause calls to this function with pointers that *no* zone owns.  If
               :	 * we knew that all pointers were owned by *some* zone, we could split
               :	 * our zone into two parts, and use one as the default allocator and
               :	 * the other as the default deallocator/reallocator.  Since that will
               :	 * not work in practice, we must check all pointers to assure that they
               :	 * reside within a mapped chunk before determining size.
               :	 */
               :
               :	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
               :	if (chunk != ptr) {
               :		arena_t *arena;
               :		unsigned i;
               :		arena_t *arenas_snapshot[narenas];
               :
               :		/*
               :		 * Make a copy of the arenas vector while holding arenas_lock in
               :		 * order to assure that all elements are up to date in this
               :		 * processor's cache.  Do this outside the following loop in
               :		 * order to reduce lock acquisitions.
               :		 */
               :		malloc_spin_lock(&arenas_lock);
               :		memcpy(&arenas_snapshot, arenas, sizeof(arena_t *) * narenas);
               :		malloc_spin_unlock(&arenas_lock);
               :
               :		/* Region. */
               :		for (i = 0; i < narenas; i++) {
               :			arena = arenas_snapshot[i];
               :
               :			if (arena != NULL) {
               :				bool own;
               :
               :				/* Make sure ptr is within a chunk. */
               :				malloc_spin_lock(&arena->lock);
               :				if (RB_FIND(arena_chunk_tree_s, &arena->chunks,
               :				    chunk) == chunk)
               :					own = true;
               :				else
               :					own = false;
               :				malloc_spin_unlock(&arena->lock);
               :
               :				if (own) {
               :					ret = arena_salloc(ptr);
               :					goto RETURN;
               :				}
               :			}
               :		}
               :	} else {
               :		extent_node_t *node;
               :		extent_node_t key;
               :
               :		/* Chunk. */
               :		key.addr = (void *)chunk;
               :		malloc_mutex_lock(&huge_mtx);
               :		node = RB_FIND(extent_tree_ad_s, &huge, &key);
               :		if (node != NULL)
               :			ret = node->size;
               :		else
               :			ret = 0;
               :		malloc_mutex_unlock(&huge_mtx);
               :	}
               :
               :RETURN:
               :	return (ret);
               :}
               :
               :static void *
               :zone_malloc(malloc_zone_t *zone, size_t size)
               :{
               :
               :	return (moz_malloc(size));
               :}
               :
               :static void *
               :zone_calloc(malloc_zone_t *zone, size_t num, size_t size)
               :{
               :
               :	return (moz_calloc(num, size));
               :}
               :
               :static void *
               :zone_valloc(malloc_zone_t *zone, size_t size)
               :{
               :	void *ret = NULL; /* Assignment avoids useless compiler warning. */
               :
               :	moz_posix_memalign(&ret, pagesize, size);
               :
               :	return (ret);
               :}
               :
               :static void
               :zone_free(malloc_zone_t *zone, void *ptr)
               :{
               :
               :	moz_free(ptr);
               :}
               :
               :static void *
               :zone_realloc(malloc_zone_t *zone, void *ptr, size_t size)
               :{
               :
               :	return (moz_realloc(ptr, size));
               :}
               :
               :static void *
               :zone_destroy(malloc_zone_t *zone)
               :{
               :
               :	/* This function should never be called. */
               :	assert(false);
               :	return (NULL);
               :}
               :
               :static size_t
               :zone_good_size(malloc_zone_t *zone, size_t size)
               :{
               :	size_t ret;
               :	void *p;
               :
               :	/*
               :	 * Actually create an object of the appropriate size, then find out
               :	 * how large it could have been without moving up to the next size
               :	 * class.
               :	 */
               :	p = moz_malloc(size);
               :	if (p != NULL) {
               :		ret = isalloc(p);
               :		moz_free(p);
               :	} else
               :		ret = size;
               :
               :	return (ret);
               :}
               :
               :static void
               :zone_force_lock(malloc_zone_t *zone)
               :{
               :
               :	_malloc_prefork();
               :}
               :
               :static void
               :zone_force_unlock(malloc_zone_t *zone)
               :{
               :
               :	_malloc_postfork();
               :}
               :
               :static malloc_zone_t *
               :create_zone(void)
               :{
               :
               :	assert(malloc_initialized);
               :
               :	zone.size = (void *)zone_size;
               :	zone.malloc = (void *)zone_malloc;
               :	zone.calloc = (void *)zone_calloc;
               :	zone.valloc = (void *)zone_valloc;
               :	zone.free = (void *)zone_free;
               :	zone.realloc = (void *)zone_realloc;
               :	zone.destroy = (void *)zone_destroy;
               :	zone.zone_name = "jemalloc_zone";
               :	zone.batch_malloc = NULL;
               :	zone.batch_free = NULL;
               :	zone.introspect = &zone_introspect;
               :
               :	zone_introspect.enumerator = NULL;
               :	zone_introspect.good_size = (void *)zone_good_size;
               :	zone_introspect.check = NULL;
               :	zone_introspect.print = NULL;
               :	zone_introspect.log = NULL;
               :	zone_introspect.force_lock = (void *)zone_force_lock;
               :	zone_introspect.force_unlock = (void *)zone_force_unlock;
               :	zone_introspect.statistics = NULL;
               :
               :	return (&zone);
               :}
               :
               :__attribute__((constructor))
               :void
               :jemalloc_darwin_init(void)
               :{
               :	extern unsigned malloc_num_zones;
               :	extern malloc_zone_t **malloc_zones;
               :
               :	if (malloc_init_hard())
               :		abort();
               :
               :	/*
               :	 * The following code is *not* thread-safe, so it's critical that
               :	 * initialization be manually triggered.
               :	 */
               :
               :	/* Register the custom zones. */
               :	malloc_zone_register(create_zone());
               :	assert(malloc_zones[malloc_num_zones - 1] == &zone);
               :
               :	/*
               :	 * Shift malloc_zones around so that zone is first, which makes it the
               :	 * default zone.
               :	 */
               :	assert(malloc_num_zones > 1);
               :	memmove(&malloc_zones[1], &malloc_zones[0],
               :		sizeof(malloc_zone_t *) * (malloc_num_zones - 1));
               :	malloc_zones[0] = &zone;
               :}
               :#endif
/* 
 * Total samples for file : "/usr/include/agg2/agg_rasterizer_compound_aa.h"
 * 
 *   7020  2.9591
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry - Version 2.3
               :// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
               ://
               :// Permission to copy, use, modify, sell and distribute this software 
               :// is granted provided this copyright notice appears in all copies. 
               :// This software is provided "as is" without express or implied
               :// warranty, and with no claim as to its suitability for any purpose.
               ://
               ://----------------------------------------------------------------------------
               ://
               :// The author gratefully acknowleges the support of David Turner, 
               :// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
               :// libray - in producing this work. See http://www.freetype.org for details.
               ://
               ://----------------------------------------------------------------------------
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://www.antigrain.com
               ://----------------------------------------------------------------------------
               ://
               :// Adaptation for 32-bit screen coordinates has been sponsored by 
               :// Liberty Technology Systems, Inc., visit http://lib-sys.com
               ://
               :// Liberty Technology Systems, Inc. is the provider of
               :// PostScript and PDF technology for software developers.
               :// 
               ://----------------------------------------------------------------------------
               :#ifndef AGG_RASTERIZER_COMPOUND_AA_INCLUDED
               :#define AGG_RASTERIZER_COMPOUND_AA_INCLUDED
               :
               :#include "agg_rasterizer_cells_aa.h"
               :#include "agg_rasterizer_sl_clip.h"
               :
               :namespace agg
               :{
               :
               :    //-----------------------------------------------------------cell_style_aa
               :    // A pixel cell. There're no constructors defined and it was done 
               :    // intentionally in order to avoid extra overhead when allocating an 
               :    // array of cells.
               :    struct cell_style_aa
               :    {
               :        int   x;
               :        int   y;
               :        int   cover;
               :        int   area;
               :        int16 left, right;
               :
               :        void initial()
               :        {
     1 4.2e-04 :            x     = 0x7FFFFFFF;
     1 4.2e-04 :            y     = 0x7FFFFFFF;
     2 8.4e-04 :            cover = 0;
               :            area  = 0;
     4  0.0017 :            left  = -1;
     1 4.2e-04 :            right = -1;
               :        }
               :
               :        void style(const cell_style_aa& c)
               :        {
    41  0.0173 :            left  = c.left;
    85  0.0358 :            right = c.right;
               :        }
               :
               :        int not_equal(int ex, int ey, const cell_style_aa& c) const
               :        {
    71  0.0299 :            return (ex - x) | (ey - y) | (left - c.left) | (right - c.right);
               :        }
               :    };
               :
               :
               :    //===========================================================layer_order_e
               :    enum layer_order_e
               :    {
               :        layer_unsorted, //------layer_unsorted
               :        layer_direct,   //------layer_direct
               :        layer_inverse   //------layer_inverse
               :    };
               :
               :
               :    //==================================================rasterizer_compound_aa
               :    template<class Clip=rasterizer_sl_clip_int> class rasterizer_compound_aa
     2 8.4e-04 :    { /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::~rasterizer_compound_aa() total:     30  0.0126 */
               :        struct style_info 
               :        { 
               :            unsigned start_cell;
               :            unsigned num_cells;
               :            int      last_x;
               :        };
               :
               :        struct cell_info
               :        {
               :            int x, area, cover; 
               :        };
               :
               :    public:
               :        typedef Clip                      clip_type;
               :        typedef typename Clip::conv_type  conv_type;
               :        typedef typename Clip::coord_type coord_type;
               :
               :        enum aa_scale_e
               :        {
               :            aa_shift  = 8,
               :            aa_scale  = 1 << aa_shift,
               :            aa_mask   = aa_scale - 1,
               :            aa_scale2 = aa_scale * 2,
               :            aa_mask2  = aa_scale2 - 1
               :        };
               :
               :        //--------------------------------------------------------------------
     2 8.4e-04 :        rasterizer_compound_aa() :  /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::rasterizer_compound_aa() total:     23  0.0097 */
               :            m_outline(),
               :            m_clipper(),
               :            m_filling_rule(fill_non_zero),
               :            m_layer_order(layer_direct),
               :            m_styles(),  // Active Styles
               :            m_ast(),     // Active Style Table (unique values)
               :            m_asm(),     // Active Style Mask 
               :            m_cells(),
               :            m_cover_buf(),
               :            m_master_alpha(),
               :            m_min_style(0x7FFFFFFF),
               :            m_max_style(-0x7FFFFFFF),
               :            m_start_x(0),
               :            m_start_y(0),
               :            m_scan_y(0x7FFFFFFF),
               :            m_sl_start(0),
     1 4.2e-04 :            m_sl_len(0)
               :        {}
               :
               :        //--------------------------------------------------------------------
               :        void reset(); 
               :        void reset_clipping();
               :        void clip_box(double x1, double y1, double x2, double y2);
               :        void filling_rule(filling_rule_e filling_rule);
               :        void layer_order(layer_order_e order);
               :        void master_alpha(int style, double alpha);
               :
               :        //--------------------------------------------------------------------
               :        void styles(int left, int right);
               :        void move_to(int x, int y);
               :        void line_to(int x, int y);
               :        void move_to_d(double x, double y);
               :        void line_to_d(double x, double y);
               :        void add_vertex(double x, double y, unsigned cmd);
               :
               :        void edge(int x1, int y1, int x2, int y2);
               :        void edge_d(double x1, double y1, double x2, double y2);
               :
               :        //-------------------------------------------------------------------
               :        template<class VertexSource>
    27  0.0114 :        void add_path(VertexSource& vs, unsigned path_id=0) /* T.8423 total:    406  0.1711 */
               :        {
               :            double x;
               :            double y;
               :
               :            unsigned cmd;
               :            vs.rewind(path_id);
    24  0.0101 :            if(m_outline.sorted()) reset();
   114  0.0481 :            while(!is_stop(cmd = vs.vertex(&x, &y)))
               :            {
     8  0.0034 :                add_vertex(x, y, cmd);
               :            }
    28  0.0118 :        }
               :
               :        
               :        //--------------------------------------------------------------------
               :        int min_x()     const { return m_outline.min_x(); }
               :        int min_y()     const { return m_outline.min_y(); }
               :        int max_x()     const { return m_outline.max_x(); }
               :        int max_y()     const { return m_outline.max_y(); }
               :        int min_style() const { return m_min_style; }
               :        int max_style() const { return m_max_style; }
               :
               :        //--------------------------------------------------------------------
               :        void sort();
               :        bool rewind_scanlines();
               :        unsigned sweep_styles();
     3  0.0013 :        int      scanline_start()  const { return m_sl_start; }
     2 8.4e-04 :        unsigned scanline_length() const { return m_sl_len;   }
               :        unsigned style(unsigned style_idx) const;
               :
               :        cover_type* allocate_cover_buffer(unsigned len);
               :
               :        //--------------------------------------------------------------------
               :        bool navigate_scanline(int y); 
               :        bool hit_test(int tx, int ty);
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE unsigned calculate_alpha(int area, unsigned master_alpha) const
               :        {
   178  0.0750 :            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
               :            if(cover < 0) cover = -cover;
   226  0.0953 :            if(m_filling_rule == fill_even_odd)
               :            {
    30  0.0126 :                cover &= aa_mask2;
    17  0.0072 :                if(cover > aa_scale)
               :                {
               :                    cover = aa_scale2 - cover;
               :                }
               :            }
   122  0.0514 :            if(cover > aa_mask) cover = aa_mask;
    49  0.0207 :            return (cover * master_alpha + aa_mask) >> aa_shift;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        // Sweeps one scanline with one style index. The style ID can be 
               :        // determined by calling style(). 
    84  0.0354 :        template<class Scanline> bool sweep_scanline(Scanline& sl, int style_idx) /* bool agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::sweep_scanline<agg::scanline_u8>(agg::scanline_u8&, int)   2060  0.8683, bool agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::sweep_scanline<agg::scanline_u8_am<agg::alpha_mask_u8<1u, 0u, agg::one_component_mask_u8> > >(agg::scanline_u8_am<agg::alpha_mask_u8<1u, 0u, agg::one_component_mask_u8> >&, int)    279  0.1176, total:   2339  0.9860 */
               :        {
    28  0.0118 :            int scan_y = m_scan_y - 1;
     3  0.0013 :            if(scan_y > m_outline.max_y()) return false;
               :
               :            sl.reset_spans();
               :
               :            unsigned master_alpha = aa_mask;
               :
     4  0.0017 :            if(style_idx < 0) 
               :            {
               :                style_idx = 0;
               :            }
               :            else 
               :            {
               :                style_idx++;
   119  0.0502 :                master_alpha = m_master_alpha[m_ast[style_idx] + m_min_style - 1];
               :            }
               :
               :            const style_info& st = m_styles[m_ast[style_idx]];
               :
    17  0.0072 :            unsigned num_cells = st.num_cells;
               :            cell_info* cell = &m_cells[st.start_cell];
               :
               :            int cover = 0;
   125  0.0527 :            while(num_cells--)
               :            {
               :                unsigned alpha;
    14  0.0059 :                int x = cell->x;
    28  0.0118 :                int area = cell->area;
               :
     5  0.0021 :                cover += cell->cover;
               :
    10  0.0042 :                ++cell;
               :
    57  0.0240 :                if(area)
               :                {
               :                    alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area,
               :                                            master_alpha);
               :                    sl.add_cell(x, alpha);
    25  0.0105 :                    x++;
               :                }
               :
   208  0.0877 :                if(num_cells && cell->x > x)
               :                {
               :                    alpha = calculate_alpha(cover << (poly_subpixel_shift + 1),
               :                                            master_alpha);
    16  0.0067 :                    if(alpha)
               :                    {
    29  0.0122 :                        sl.add_span(x, cell->x - x, alpha);
               :                    }
               :                }
               :            }
               :
    96  0.0405 :            if(sl.num_spans() == 0) return false;
     2 8.4e-04 :            sl.finalize(scan_y);
     1 4.2e-04 :            return true;
    35  0.0148 :        }
               :
               :    private:
               :        void add_style(int style_id);
               :        void allocate_master_alpha();
               :
               :        //--------------------------------------------------------------------
               :        // Disable copying
               :        rasterizer_compound_aa(const rasterizer_compound_aa<Clip>&);
               :        const rasterizer_compound_aa<Clip>& 
               :        operator = (const rasterizer_compound_aa<Clip>&);
               :
               :    private:
               :        rasterizer_cells_aa<cell_style_aa> m_outline;
               :        clip_type              m_clipper;
               :        filling_rule_e         m_filling_rule;
               :        layer_order_e          m_layer_order;
               :        pod_vector<style_info> m_styles;  // Active Styles
               :        pod_vector<unsigned>   m_ast;     // Active Style Table (unique values)
               :        pod_vector<int8u>      m_asm;     // Active Style Mask 
               :        pod_vector<cell_info>  m_cells;
               :        pod_vector<cover_type> m_cover_buf;
               :        pod_bvector<unsigned>  m_master_alpha;
               :
               :        int        m_min_style;
               :        int        m_max_style;
               :        coord_type m_start_x;
               :        coord_type m_start_y;
               :        int        m_scan_y;
               :        int        m_sl_start;
               :        unsigned   m_sl_len;
               :    };
               :
               :
               :
               :
               :
               :
               :
               :
               :
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
    13  0.0055 :    void rasterizer_compound_aa<Clip>::reset()  /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::reset() total:     21  0.0089 */
               :    { 
               :        m_outline.reset(); 
               :        m_min_style =  0x7FFFFFFF;
               :        m_max_style = -0x7FFFFFFF;
     1 4.2e-04 :        m_scan_y    =  0x7FFFFFFF;
               :        m_sl_start  =  0;
               :        m_sl_len    = 0;
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
               :    { 
               :        m_filling_rule = filling_rule; 
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::layer_order(layer_order_e order)
               :    {
               :        m_layer_order = order;
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, 
               :                                                double x2, double y2)
               :    {
     2 8.4e-04 :        reset();
               :        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
               :                           conv_type::upscale(x2), conv_type::upscale(y2));
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::reset_clipping()
               :    {
               :        reset();
               :        m_clipper.reset_clipping();
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
    16  0.0067 :    void rasterizer_compound_aa<Clip>::styles(int left, int right) /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::styles(int, int) total:     58  0.0244 */
               :    {
               :        cell_style_aa cell;
               :        cell.initial();
               :        cell.left = (int16)left;
               :        cell.right = (int16)right;
               :        m_outline.style(cell);
     8  0.0034 :        if(left  >= 0 && left  < m_min_style) m_min_style = left;
     7  0.0030 :        if(left  >= 0 && left  > m_max_style) m_max_style = left;
     7  0.0030 :        if(right >= 0 && right < m_min_style) m_min_style = right;
     6  0.0025 :        if(right >= 0 && right > m_max_style) m_max_style = right;
    13  0.0055 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::move_to(int x, int y)
               :    {
               :        if(m_outline.sorted()) reset();
               :        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
               :                          m_start_y = conv_type::downscale(y));
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::line_to(int x, int y)
               :    {
               :        m_clipper.line_to(m_outline, 
               :                          conv_type::downscale(x), 
               :                          conv_type::downscale(y));
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::move_to_d(double x, double y) 
               :    { 
    11  0.0046 :        if(m_outline.sorted()) reset();
     4  0.0017 :        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
               :                          m_start_y = conv_type::upscale(y)); 
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::line_to_d(double x, double y) 
               :    { 
    20  0.0084 :        m_clipper.line_to(m_outline, 
               :                          conv_type::upscale(x), 
               :                          conv_type::upscale(y)); 
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
               :    {
    21  0.0089 :        if(is_move_to(cmd)) 
               :        {
               :            move_to_d(x, y);
               :        }
               :        else 
    10  0.0042 :        if(is_vertex(cmd))
               :        {
               :            line_to_d(x, y);
               :        }
               :        else
               :        if(is_close(cmd))
               :        {
    32  0.0135 :            m_clipper.line_to(m_outline, m_start_x, m_start_y);
               :        }
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
               :    {
               :        if(m_outline.sorted()) reset();
               :        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
               :        m_clipper.line_to(m_outline, 
               :                          conv_type::downscale(x2), 
               :                          conv_type::downscale(y2));
               :    }
               :    
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, 
               :                                              double x2, double y2)
               :    {
               :        if(m_outline.sorted()) reset();
               :        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
               :        m_clipper.line_to(m_outline, 
               :                          conv_type::upscale(x2), 
               :                          conv_type::upscale(y2)); 
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    AGG_INLINE void rasterizer_compound_aa<Clip>::sort()
               :    {
               :        m_outline.sort_cells();
               :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
    15  0.0063 :    AGG_INLINE bool rasterizer_compound_aa<Clip>::rewind_scanlines() /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::rewind_scanlines() total:     41  0.0173 */
               :    {
               :        m_outline.sort_cells();
     3  0.0013 :        if(m_outline.total_cells() == 0) 
               :        {
               :            return false;
               :        }
     2 8.4e-04 :        if(m_max_style < m_min_style)
               :        {
               :            return false;
               :        }
               :        m_scan_y = m_outline.min_y();
               :        m_styles.allocate(m_max_style - m_min_style + 2, 128);
               :        allocate_master_alpha();
     1 4.2e-04 :        return true;
     3  0.0013 :    }
               :
               :    //------------------------------------------------------------------------
               :    template<class Clip> 
               :    AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
               :    {
   547  0.2306 :        if(style_id < 0) style_id  = 0;
   337  0.1421 :        else             style_id -= m_min_style - 1;
               :
               :        unsigned nbyte = style_id >> 3;
               :        unsigned mask = 1 << (style_id & 7);
               :
               :        style_info* style = &m_styles[style_id];
   610  0.2571 :        if((m_asm[nbyte] & mask) == 0)
               :        {
               :            m_ast.add(style_id);
    23  0.0097 :            m_asm[nbyte] |= mask;
     8  0.0034 :            style->start_cell = 0;
     4  0.0017 :            style->num_cells = 0;
    21  0.0089 :            style->last_x = -0x7FFFFFFF;
               :        }
     3  0.0013 :        ++style->start_cell;
               :    }
               :
               :    //------------------------------------------------------------------------
               :    // Returns the number of styles
               :    template<class Clip> 
    75  0.0316 :    unsigned rasterizer_compound_aa<Clip>::sweep_styles() /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::sweep_styles() total:   5877  2.4773 */
               :    {
               :        for(;;)
               :        {
    21  0.0089 :            if(m_scan_y > m_outline.max_y()) return 0;
               :            unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
               :            const cell_style_aa* const* cells = m_outline.scanline_cells(m_scan_y);
    13  0.0055 :            unsigned num_styles = m_max_style - m_min_style + 2;
               :            const cell_style_aa* curr_cell;
               :            unsigned style_id;
               :            style_info* style;
               :            cell_info* cell;
               :
     8  0.0034 :            m_cells.allocate(num_cells * 2, 256); // Each cell can have two styles
               :            m_ast.capacity(num_styles, 64);
    42  0.0177 :            m_asm.allocate((num_styles + 7) >> 3, 8);
               :            m_asm.zero();
               :
    21  0.0089 :            if(num_cells)
               :            {
               :                // Pre-add zero (for no-fill style, that is, -1).
               :                // We need that to ensure that the "-1 style" would go first.
     8  0.0034 :                m_asm[0] |= 1; 
               :                m_ast.add(0);
               :                style = &m_styles[0];
    42  0.0177 :                style->start_cell = 0;
    27  0.0114 :                style->num_cells = 0;
     4  0.0017 :                style->last_x = -0x7FFFFFFF;
               :
    13  0.0055 :                m_sl_start = cells[0]->x;
   205  0.0864 :                m_sl_len   = cells[num_cells-1]->x - m_sl_start + 1;
   249  0.1050 :                while(num_cells--)
               :                {
    97  0.0409 :                    curr_cell = *cells++;
    52  0.0219 :                    add_style(curr_cell->left);
    39  0.0164 :                    add_style(curr_cell->right);
               :                }
               :
               :                // Convert the Y-histogram into the array of starting indexes
               :                unsigned i;
               :                unsigned start_cell = 0;
   193  0.0814 :                for(i = 0; i < m_ast.size(); i++)
               :                {
               :                    style_info& st = m_styles[m_ast[i]];
    17  0.0072 :                    unsigned v = st.start_cell;
    18  0.0076 :                    st.start_cell = start_cell;
    10  0.0042 :                    start_cell += v;
               :                }
               :
               :                cells = m_outline.scanline_cells(m_scan_y);
               :                num_cells = m_outline.scanline_num_cells(m_scan_y);
               :
   254  0.1071 :                while(num_cells--)
               :                {
   224  0.0944 :                    curr_cell = *cells++;
   257  0.1083 :                    style_id = (curr_cell->left < 0) ? 0 : 
               :                                curr_cell->left - m_min_style + 1;
               :
               :                    style = &m_styles[style_id];
   159  0.0670 :                    if(curr_cell->x == style->last_x)
               :                    {
               :                        cell = &m_cells[style->start_cell + style->num_cells - 1];
    16  0.0067 :                        cell->area  += curr_cell->area;
    20  0.0084 :                        cell->cover += curr_cell->cover;
               :                    }
               :                    else
               :                    {
               :                        cell = &m_cells[style->start_cell + style->num_cells];
    17  0.0072 :                        cell->x       = curr_cell->x;
    87  0.0367 :                        cell->area    = curr_cell->area;
    42  0.0177 :                        cell->cover   = curr_cell->cover;
    82  0.0346 :                        style->last_x = curr_cell->x;
    15  0.0063 :                        style->num_cells++;
               :                    }
               :
   155  0.0653 :                    style_id = (curr_cell->right < 0) ? 0 : 
               :                                curr_cell->right - m_min_style + 1;
               :
               :                    style = &m_styles[style_id];
   178  0.0750 :                    if(curr_cell->x == style->last_x)
               :                    {
               :                        cell = &m_cells[style->start_cell + style->num_cells - 1];
    12  0.0051 :                        cell->area  -= curr_cell->area;
    24  0.0101 :                        cell->cover -= curr_cell->cover;
               :                    }
               :                    else
               :                    {
               :                        cell = &m_cells[style->start_cell + style->num_cells];
    22  0.0093 :                        cell->x       =  curr_cell->x;
   185  0.0780 :                        cell->area    = -curr_cell->area;
    59  0.0249 :                        cell->cover   = -curr_cell->cover;
    52  0.0219 :                        style->last_x =  curr_cell->x;
    26  0.0110 :                        style->num_cells++;
               :                    }
               :                }
               :            }
   107  0.0451 :            if(m_ast.size() > 1) break;
     5  0.0021 :            ++m_scan_y;
               :        }
     4  0.0017 :        ++m_scan_y;
               :
    13  0.0055 :        if(m_layer_order != layer_unsorted)
               :        {
     7  0.0030 :            range_adaptor<pod_vector<unsigned> > ra(m_ast, 1, m_ast.size() - 1);
    44  0.0185 :            if(m_layer_order == layer_direct) quick_sort(ra, unsigned_greater);
               :            else                              quick_sort(ra, unsigned_less);
               :        }
               :
    15  0.0063 :        return m_ast.size() - 1;
    18  0.0076 :    }
               :
               :    //------------------------------------------------------------------------
               :    // Returns style ID depending of the existing style index
               :    template<class Clip> 
               :    AGG_INLINE 
               :    unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
               :    {
    57  0.0240 :        return m_ast[style_idx + 1] + m_min_style - 1;
               :    }
               :
               :    //------------------------------------------------------------------------ 
               :    template<class Clip> 
               :    AGG_INLINE bool rasterizer_compound_aa<Clip>::navigate_scanline(int y)
               :    {
               :        m_outline.sort_cells();
               :        if(m_outline.total_cells() == 0) 
               :        {
               :            return false;
               :        }
               :        if(m_max_style < m_min_style)
               :        {
               :            return false;
               :        }
               :        if(y < m_outline.min_y() || y > m_outline.max_y()) 
               :        {
               :            return false;
               :        }
               :        m_scan_y = y;
               :        m_styles.allocate(m_max_style - m_min_style + 2, 128);
               :        allocate_master_alpha();
               :        return true;
               :    }
               :    
               :    //------------------------------------------------------------------------ 
               :    template<class Clip> 
               :    bool rasterizer_compound_aa<Clip>::hit_test(int tx, int ty)
               :    {
               :        if(!navigate_scanline(ty)) 
               :        {
               :            return false;
               :        }
               :
               :        unsigned num_styles = sweep_styles(); 
               :        if(num_styles <= 0)
               :        {
               :            return false;
               :        }
               :
               :        scanline_hit_test sl(tx);
               :        sweep_scanline(sl, -1);
               :        return sl.hit();
               :    }
               :
               :    //------------------------------------------------------------------------ 
               :    template<class Clip> 
     7  0.0030 :    cover_type* rasterizer_compound_aa<Clip>::allocate_cover_buffer(unsigned len) /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::allocate_cover_buffer(unsigned int) total:     11  0.0046 */
               :    {
     4  0.0017 :        m_cover_buf.allocate(len, 256);
               :        return &m_cover_buf[0];
               :    }
               :
               :    //------------------------------------------------------------------------ 
               :    template<class Clip> 
     2 8.4e-04 :    void rasterizer_compound_aa<Clip>::allocate_master_alpha() /* agg::rasterizer_compound_aa<agg::rasterizer_sl_clip<agg::ras_conv_dbl> >::allocate_master_alpha() total:     25  0.0105 */
               :    {
     2 8.4e-04 :        while((int)m_master_alpha.size() <= m_max_style)
               :        {
               :            m_master_alpha.add(aa_mask);
               :        }
     2 8.4e-04 :    }
               :
               :    //------------------------------------------------------------------------ 
               :    template<class Clip> 
               :    void rasterizer_compound_aa<Clip>::master_alpha(int style, double alpha)
               :    {
               :        if(style >= 0)
               :        {
               :            while((int)m_master_alpha.size() <= style)
               :            {
               :                m_master_alpha.add(aa_mask);
               :            }
               :            m_master_alpha[style] = uround(alpha * aa_mask);
               :        }
               :    }
               :
               :}
               :
               :
               :
               :#endif
               :
/* 
 * Total samples for file : "/usr/include/agg2/agg_span_interpolator_linear.h"
 * 
 *   6068  2.5578
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_SPAN_INTERPOLATOR_LINEAR_INCLUDED
               :#define AGG_SPAN_INTERPOLATOR_LINEAR_INCLUDED
               :
               :#include "agg_basics.h"
               :#include "agg_dda_line.h"
               :#include "agg_trans_affine.h"
               :
               :namespace agg
               :{
               :
               :    //================================================span_interpolator_linear
               :    template<class Transformer = trans_affine, unsigned SubpixelShift = 8> 
               :    class span_interpolator_linear
               :    {
               :    public:
               :        typedef Transformer trans_type;
               :
               :        enum subpixel_scale_e
               :        {
               :            subpixel_shift = SubpixelShift,
               :            subpixel_scale  = 1 << subpixel_shift
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_interpolator_linear() {}
    31  0.0131 :        span_interpolator_linear(const trans_type& trans) : m_trans(&trans) {}
               :        span_interpolator_linear(const trans_type& trans,
               :                                 double x, double y, unsigned len) :
               :            m_trans(&trans)
               :        {
               :            begin(x, y, len);
               :        }
               :
               :        //----------------------------------------------------------------
               :        const trans_type& transformer() const { return *m_trans; }
               :        void transformer(const trans_type& trans) { m_trans = &trans; }
               :
               :        //----------------------------------------------------------------
               :        void begin(double x, double y, unsigned len)
               :        {
               :            double tx;
               :            double ty;
               :
               :            tx = x;
               :            ty = y;
               :            m_trans->transform(&tx, &ty);
    12  0.0051 :            int x1 = iround(tx * subpixel_scale);
    62  0.0261 :            int y1 = iround(ty * subpixel_scale);
               :
   387  0.1631 :            tx = x + len;
               :            ty = y;
               :            m_trans->transform(&tx, &ty);
   139  0.0586 :            int x2 = iround(tx * subpixel_scale);
    16  0.0067 :            int y2 = iround(ty * subpixel_scale);
               :
   127  0.0535 :            m_li_x = dda2_line_interpolator(x1, x2, len);
   101  0.0426 :            m_li_y = dda2_line_interpolator(y1, y2, len);
               :        }
               :
               :        //----------------------------------------------------------------
               :        void resynchronize(double xe, double ye, unsigned len)
               :        {
               :            m_trans->transform(&xe, &ye);
               :            m_li_x = dda2_line_interpolator(m_li_x.y(), iround(xe * subpixel_scale), len);
               :            m_li_y = dda2_line_interpolator(m_li_y.y(), iround(ye * subpixel_scale), len);
               :        }
               :    
               :        //----------------------------------------------------------------
               :        void operator++()
               :        {
               :            ++m_li_x;
               :            ++m_li_y;
               :        }
               :
               :        //----------------------------------------------------------------
               :        void coordinates(int* x, int* y) const
               :        {
               :            *x = m_li_x.y();
               :            *y = m_li_y.y();
               :        }
               :
               :    private:
               :        const trans_type* m_trans;
               :        dda2_line_interpolator m_li_x;
               :        dda2_line_interpolator m_li_y;
               :    };
               :
               :
               :
               :
               :
               :
               :    //=====================================span_interpolator_linear_subdiv
               :    template<class Transformer = trans_affine, unsigned SubpixelShift = 8> 
               :    class span_interpolator_linear_subdiv
               :    {
               :    public:
               :        typedef Transformer trans_type;
               :
               :        enum subpixel_scale_e
               :        {
               :            subpixel_shift = SubpixelShift,
               :            subpixel_scale = 1 << subpixel_shift
               :        };
               :
               :
               :        //----------------------------------------------------------------
               :        span_interpolator_linear_subdiv() :
               :            m_subdiv_shift(4),
               :            m_subdiv_size(1 << m_subdiv_shift),
               :            m_subdiv_mask(m_subdiv_size - 1) {}
               :
               :        span_interpolator_linear_subdiv(const trans_type& trans, 
               :                                        unsigned subdiv_shift = 4) : 
               :            m_subdiv_shift(subdiv_shift),
               :            m_subdiv_size(1 << m_subdiv_shift),
               :            m_subdiv_mask(m_subdiv_size - 1),
               :            m_trans(&trans) {}
               :
               :        span_interpolator_linear_subdiv(const trans_type& trans,
               :                                        double x, double y, unsigned len,
               :                                        unsigned subdiv_shift = 4) :
               :            m_subdiv_shift(subdiv_shift),
               :            m_subdiv_size(1 << m_subdiv_shift),
               :            m_subdiv_mask(m_subdiv_size - 1),
               :            m_trans(&trans)
               :        {
               :            begin(x, y, len);
               :        }
               :
               :        //----------------------------------------------------------------
               :        const trans_type& transformer() const { return *m_trans; }
               :        void transformer(const trans_type& trans) { m_trans = &trans; }
               :
               :        //----------------------------------------------------------------
               :        unsigned subdiv_shift() const { return m_subdiv_shift; }
               :        void subdiv_shift(unsigned shift) 
               :        {
               :            m_subdiv_shift = shift;
               :            m_subdiv_size = 1 << m_subdiv_shift;
               :            m_subdiv_mask = m_subdiv_size - 1;
               :        }
               :
               :        //----------------------------------------------------------------
               :        void begin(double x, double y, unsigned len)
               :        {
               :            double tx;
               :            double ty;
     7  0.0030 :            m_pos   = 1;
     8  0.0034 :            m_src_x = iround(x * subpixel_scale) + subpixel_scale;
               :            m_src_y = y;
     7  0.0030 :            m_len   = len;
               :
               :            if(len > m_subdiv_size) len = m_subdiv_size;
               :            tx = x;
               :            ty = y;
               :            m_trans->transform(&tx, &ty);
     6  0.0025 :            int x1 = iround(tx * subpixel_scale);
     6  0.0025 :            int y1 = iround(ty * subpixel_scale);
               :
    72  0.0304 :            tx = x + len;
               :            ty = y;
               :            m_trans->transform(&tx, &ty);
               :
    39  0.0164 :            m_li_x = dda2_line_interpolator(x1, iround(tx * subpixel_scale), len);
     9  0.0038 :            m_li_y = dda2_line_interpolator(y1, iround(ty * subpixel_scale), len);
               :        }
               :
               :        //----------------------------------------------------------------
               :        void operator++()
               :        {
               :            ++m_li_x;
               :            ++m_li_y;
   944  0.3979 :            if(m_pos >= m_subdiv_size)
               :            {
   122  0.0514 :                unsigned len = m_len;
               :                if(len > m_subdiv_size) len = m_subdiv_size;
  1428  0.6019 :                double tx = double(m_src_x) / double(subpixel_scale) + len;
   214  0.0902 :                double ty = m_src_y;
    13  0.0055 :                m_trans->transform(&tx, &ty);
   509  0.2146 :                m_li_x = dda2_line_interpolator(m_li_x.y(), iround(tx * subpixel_scale), len);
   137  0.0577 :                m_li_y = dda2_line_interpolator(m_li_y.y(), iround(ty * subpixel_scale), len);
     1 4.2e-04 :                m_pos = 0;
               :            }
   482  0.2032 :            m_src_x += subpixel_scale;
   792  0.3339 :            ++m_pos;
   397  0.1673 :            --m_len;
               :        }
               :
               :        //----------------------------------------------------------------
               :        void coordinates(int* x, int* y) const
               :        {
               :            *x = m_li_x.y();
               :            *y = m_li_y.y();
               :        }
               :
               :    private:
               :        unsigned m_subdiv_shift;
               :        unsigned m_subdiv_size;
               :        unsigned m_subdiv_mask;
               :        const trans_type* m_trans;
               :        dda2_line_interpolator m_li_x;
               :        dda2_line_interpolator m_li_y;
               :        int      m_src_x;
               :        double   m_src_y;
               :        unsigned m_pos;
               :        unsigned m_len;
               :    };
               :
               :
               :}
               :
               :
               :
               :#endif
               :
               :
/* 
 * Total samples for file : "/usr/include/agg2/agg_span_image_filter_rgb.h"
 * 
 *   6067  2.5574
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               ://
               :// Adaptation for high precision colors has been sponsored by 
               :// Liberty Technology Systems, Inc., visit http://lib-sys.com
               ://
               :// Liberty Technology Systems, Inc. is the provider of
               :// PostScript and PDF technology for software developers.
               :// 
               ://----------------------------------------------------------------------------
               :#ifndef AGG_SPAN_IMAGE_FILTER_RGB_INCLUDED
               :#define AGG_SPAN_IMAGE_FILTER_RGB_INCLUDED
               :
               :#include "agg_basics.h"
               :#include "agg_color_rgba.h"
               :#include "agg_span_image_filter.h"
               :
               :
               :namespace agg
               :{
               :
               :    //===============================================span_image_filter_rgb_nn
               :    template<class Source, class Interpolator> 
               :    class span_image_filter_rgb_nn : 
               :    public span_image_filter<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_filter<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_filter_rgb_nn() {}
               :        span_image_filter_rgb_nn(source_type& src, 
               :                                 interpolator_type& inter) :
               :            base_type(src, inter, 0) 
               :        {}
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
     1 4.2e-04 :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
   779  0.3284 :            do
               :            {
               :                base_type::interpolator().coordinates(&x, &y);
               :                const value_type* fg_ptr = (const value_type*)
               :                    base_type::source().span(x >> image_subpixel_shift, 
               :                                             y >> image_subpixel_shift, 
   518  0.2184 :                                             1);
  3124  1.3169 :                span->r = fg_ptr[order_type::R];
   451  0.1901 :                span->g = fg_ptr[order_type::G];
   744  0.3136 :                span->b = fg_ptr[order_type::B];
    71  0.0299 :                span->a = base_mask;
   379  0.1598 :                ++span;
               :                ++base_type::interpolator();
               :
               :            } while(--len);
               :        }
               :    };
               :
               :
               :
               :    //==========================================span_image_filter_rgb_bilinear
               :    template<class Source, class Interpolator> 
               :    class span_image_filter_rgb_bilinear : 
               :    public span_image_filter<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_filter<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_filter_rgb_bilinear() {}
               :        span_image_filter_rgb_bilinear(source_type& src, 
               :                                       interpolator_type& inter) :
               :            base_type(src, inter, 0) 
               :        {}
               :
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :            calc_type fg[3];
               :            const value_type *fg_ptr;
               :            do
               :            {
               :                int x_hr;
               :                int y_hr;
               :
               :                base_type::interpolator().coordinates(&x_hr, &y_hr);
               :
               :                x_hr -= base_type::filter_dx_int();
               :                y_hr -= base_type::filter_dy_int();
               :
               :                int x_lr = x_hr >> image_subpixel_shift;
               :                int y_lr = y_hr >> image_subpixel_shift;
               :
               :                unsigned weight;
               :
               :                fg[0] = 
               :                fg[1] = 
               :                fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
               :
               :                x_hr &= image_subpixel_mask;
               :                y_hr &= image_subpixel_mask;
               :
               :                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
               :                weight = (image_subpixel_scale - x_hr) * 
               :                         (image_subpixel_scale - y_hr);
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_x();
               :                weight = x_hr * (image_subpixel_scale - y_hr);
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_y();
               :                weight = (image_subpixel_scale - x_hr) * y_hr;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_x();
               :                weight = x_hr * y_hr;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                span->r = value_type(fg[order_type::R] >> (image_subpixel_shift * 2));
               :                span->g = value_type(fg[order_type::G] >> (image_subpixel_shift * 2));
               :                span->b = value_type(fg[order_type::B] >> (image_subpixel_shift * 2));
               :                span->a = base_mask;
               :
               :                ++span;
               :                ++base_type::interpolator();
               :
               :            } while(--len);
               :        }
               :    };
               :
               :
               :
               :    //=====================================span_image_filter_rgb_bilinear_clip
               :    template<class Source, class Interpolator> 
               :    class span_image_filter_rgb_bilinear_clip : 
               :    public span_image_filter<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_filter<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_filter_rgb_bilinear_clip() {}
               :        span_image_filter_rgb_bilinear_clip(source_type& src, 
               :                                            const color_type& back_color,
               :                                            interpolator_type& inter) :
               :            base_type(src, inter, 0),
               :            m_back_color(back_color)
               :        {}
               :        const color_type& background_color() const { return m_back_color; }
               :        void background_color(const color_type& v)   { m_back_color = v; }
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :            calc_type fg[3];
               :            calc_type src_alpha;
               :            value_type back_r = m_back_color.r;
               :            value_type back_g = m_back_color.g;
               :            value_type back_b = m_back_color.b;
               :            value_type back_a = m_back_color.a;
               :
               :            const value_type *fg_ptr;
               :
               :            int maxx = base_type::source().width() - 1;
               :            int maxy = base_type::source().height() - 1;
               :
               :            do
               :            {
               :                int x_hr;
               :                int y_hr;
               :                
               :                base_type::interpolator().coordinates(&x_hr, &y_hr);
               :
               :                x_hr -= base_type::filter_dx_int();
               :                y_hr -= base_type::filter_dy_int();
               :
               :                int x_lr = x_hr >> image_subpixel_shift;
               :                int y_lr = y_hr >> image_subpixel_shift;
               :                unsigned weight;
               :
               :                if(x_lr >= 0    && y_lr >= 0 &&
               :                   x_lr <  maxx && y_lr <  maxy) 
               :                {
               :                    fg[0] = 
               :                    fg[1] = 
               :                    fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
               :
               :                    x_hr &= image_subpixel_mask;
               :                    y_hr &= image_subpixel_mask;
               :
               :                    fg_ptr = (const value_type*)
               :                        base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                    weight = (image_subpixel_scale - x_hr) * 
               :                             (image_subpixel_scale - y_hr);
               :                    fg[0] += weight * *fg_ptr++;
               :                    fg[1] += weight * *fg_ptr++;
               :                    fg[2] += weight * *fg_ptr++;
               :
               :                    weight = x_hr * (image_subpixel_scale - y_hr);
               :                    fg[0] += weight * *fg_ptr++;
               :                    fg[1] += weight * *fg_ptr++;
               :                    fg[2] += weight * *fg_ptr++;
               :
               :                    ++y_lr;
               :                    fg_ptr = (const value_type*)
               :                        base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                    weight = (image_subpixel_scale - x_hr) * y_hr;
               :                    fg[0] += weight * *fg_ptr++;
               :                    fg[1] += weight * *fg_ptr++;
               :                    fg[2] += weight * *fg_ptr++;
               :
               :                    weight = x_hr * y_hr;
               :                    fg[0] += weight * *fg_ptr++;
               :                    fg[1] += weight * *fg_ptr++;
               :                    fg[2] += weight * *fg_ptr++;
               :
               :                    fg[0] >>= image_subpixel_shift * 2;
               :                    fg[1] >>= image_subpixel_shift * 2;
               :                    fg[2] >>= image_subpixel_shift * 2;
               :                    src_alpha = base_mask;
               :                }
               :                else
               :                {
               :                    if(x_lr < -1   || y_lr < -1 ||
               :                       x_lr > maxx || y_lr > maxy)
               :                    {
               :                        fg[order_type::R] = back_r;
               :                        fg[order_type::G] = back_g;
               :                        fg[order_type::B] = back_b;
               :                        src_alpha         = back_a;
               :                    }
               :                    else
               :                    {
               :                        fg[0] = 
               :                        fg[1] = 
               :                        fg[2] = 
               :                        src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
               :
               :                        x_hr &= image_subpixel_mask;
               :                        y_hr &= image_subpixel_mask;
               :
               :                        weight = (image_subpixel_scale - x_hr) * 
               :                                 (image_subpixel_scale - y_hr);
               :                        if(x_lr >= 0    && y_lr >= 0 &&
               :                           x_lr <= maxx && y_lr <= maxy)
               :                        {
               :                            fg_ptr = (const value_type*)
               :                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                            fg[0] += weight * *fg_ptr++;
               :                            fg[1] += weight * *fg_ptr++;
               :                            fg[2] += weight * *fg_ptr++;
               :                            src_alpha += weight * base_mask;
               :                        }
               :                        else
               :                        {
               :                            fg[order_type::R] += back_r * weight;
               :                            fg[order_type::G] += back_g * weight;
               :                            fg[order_type::B] += back_b * weight;
               :                            src_alpha         += back_a * weight;
               :                        }
               :
               :                        x_lr++;
               :
               :                        weight = x_hr * (image_subpixel_scale - y_hr);
               :                        if(x_lr >= 0    && y_lr >= 0 &&
               :                           x_lr <= maxx && y_lr <= maxy)
               :                        {
               :                            fg_ptr = (const value_type*)
               :                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                            fg[0]     += weight * *fg_ptr++;
               :                            fg[1]     += weight * *fg_ptr++;
               :                            fg[2]     += weight * *fg_ptr++;
               :                            src_alpha += weight * base_mask;
               :                        }
               :                        else
               :                        {
               :                            fg[order_type::R] += back_r * weight;
               :                            fg[order_type::G] += back_g * weight;
               :                            fg[order_type::B] += back_b * weight;
               :                            src_alpha         += back_a * weight;
               :                        }
               :
               :                        x_lr--;
               :                        y_lr++;
               :
               :                        weight = (image_subpixel_scale - x_hr) * y_hr;
               :                        if(x_lr >= 0    && y_lr >= 0 &&
               :                           x_lr <= maxx && y_lr <= maxy)
               :                        {
               :                            fg_ptr = (const value_type*)
               :                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                            fg[0] += weight * *fg_ptr++;
               :                            fg[1] += weight * *fg_ptr++;
               :                            fg[2] += weight * *fg_ptr++;
               :                            src_alpha += weight * base_mask;
               :                        }
               :                        else
               :                        {
               :                            fg[order_type::R] += back_r * weight;
               :                            fg[order_type::G] += back_g * weight;
               :                            fg[order_type::B] += back_b * weight;
               :                            src_alpha         += back_a * weight;
               :                        }
               :
               :                        x_lr++;
               :
               :                        weight = x_hr * y_hr;
               :                        if(x_lr >= 0    && y_lr >= 0 &&
               :                           x_lr <= maxx && y_lr <= maxy)
               :                        {
               :                            fg_ptr = (const value_type*)
               :                                base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
               :
               :                            fg[0] += weight * *fg_ptr++;
               :                            fg[1] += weight * *fg_ptr++;
               :                            fg[2] += weight * *fg_ptr++;
               :                            src_alpha += weight * base_mask;
               :                        }
               :                        else
               :                        {
               :                            fg[order_type::R] += back_r * weight;
               :                            fg[order_type::G] += back_g * weight;
               :                            fg[order_type::B] += back_b * weight;
               :                            src_alpha         += back_a * weight;
               :                        }
               :
               :                        fg[0] >>= image_subpixel_shift * 2;
               :                        fg[1] >>= image_subpixel_shift * 2;
               :                        fg[2] >>= image_subpixel_shift * 2;
               :                        src_alpha >>= image_subpixel_shift * 2;
               :                    }
               :                }
               :
               :                span->r = (value_type)fg[order_type::R];
               :                span->g = (value_type)fg[order_type::G];
               :                span->b = (value_type)fg[order_type::B];
               :                span->a = (value_type)src_alpha;
               :                ++span;
               :                ++base_type::interpolator();
               :
               :            } while(--len);
               :        }
               :    private:
               :        color_type m_back_color;
               :    };
               :
               :
               :
               :    //===============================================span_image_filter_rgb_2x2
               :    template<class Source, class Interpolator> 
               :    class span_image_filter_rgb_2x2 : 
               :    public span_image_filter<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_filter<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_filter_rgb_2x2() {}
               :        span_image_filter_rgb_2x2(source_type& src, 
               :                                  interpolator_type& inter,
               :                                  const image_filter_lut& filter) :
               :            base_type(src, inter, &filter) 
               :        {}
               :
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :
               :            calc_type fg[3];
               :
               :            const value_type *fg_ptr;
               :            const int16* weight_array = base_type::filter().weight_array() + 
               :                                        ((base_type::filter().diameter()/2 - 1) << 
               :                                          image_subpixel_shift);
               :            do
               :            {
               :                int x_hr;
               :                int y_hr;
               :
               :                base_type::interpolator().coordinates(&x_hr, &y_hr);
               :
               :                x_hr -= base_type::filter_dx_int();
               :                y_hr -= base_type::filter_dy_int();
               :
               :                int x_lr = x_hr >> image_subpixel_shift;
               :                int y_lr = y_hr >> image_subpixel_shift;
               :
               :                unsigned weight;
               :                fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
               :
               :                x_hr &= image_subpixel_mask;
               :                y_hr &= image_subpixel_mask;
               :
               :                fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
               :                weight = (weight_array[x_hr + image_subpixel_scale] * 
               :                          weight_array[y_hr + image_subpixel_scale] + 
               :                          image_filter_scale / 2) >> 
               :                          image_filter_shift;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_x();
               :                weight = (weight_array[x_hr] * 
               :                          weight_array[y_hr + image_subpixel_scale] + 
               :                          image_filter_scale / 2) >> 
               :                          image_filter_shift;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_y();
               :                weight = (weight_array[x_hr + image_subpixel_scale] * 
               :                          weight_array[y_hr] + 
               :                          image_filter_scale / 2) >> 
               :                          image_filter_shift;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg_ptr = (const value_type*)base_type::source().next_x();
               :                weight = (weight_array[x_hr] * 
               :                          weight_array[y_hr] + 
               :                          image_filter_scale / 2) >> 
               :                          image_filter_shift;
               :                fg[0] += weight * *fg_ptr++;
               :                fg[1] += weight * *fg_ptr++;
               :                fg[2] += weight * *fg_ptr;
               :
               :                fg[0] >>= image_filter_shift;
               :                fg[1] >>= image_filter_shift;
               :                fg[2] >>= image_filter_shift;
               :
               :                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
               :                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
               :                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
               :
               :                span->r = (value_type)fg[order_type::R];
               :                span->g = (value_type)fg[order_type::G];
               :                span->b = (value_type)fg[order_type::B];
               :                span->a = base_mask;
               :
               :                ++span;
               :                ++base_type::interpolator();
               :
               :            } while(--len);
               :        }
               :    };
               :
               :
               :
               :    //===================================================span_image_filter_rgb
               :    template<class Source, class Interpolator> 
               :    class span_image_filter_rgb : 
               :    public span_image_filter<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_filter<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_filter_rgb() {}
               :        span_image_filter_rgb(source_type& src, 
               :                              interpolator_type& inter,
               :                              const image_filter_lut& filter) :
               :            base_type(src, inter, &filter) 
               :        {}
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :
               :            int fg[3];
               :            const value_type *fg_ptr;
               :
               :            unsigned     diameter     = base_type::filter().diameter();
               :            int          start        = base_type::filter().start();
               :            const int16* weight_array = base_type::filter().weight_array();
               :
               :            int x_count; 
               :            int weight_y;
               :
               :            do
               :            {
               :                base_type::interpolator().coordinates(&x, &y);
               :
               :                x -= base_type::filter_dx_int();
               :                y -= base_type::filter_dy_int();
               :
               :                int x_hr = x; 
               :                int y_hr = y; 
               :
               :                int x_lr = x_hr >> image_subpixel_shift;
               :                int y_lr = y_hr >> image_subpixel_shift;
               :
               :                fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
               :
               :                int x_fract = x_hr & image_subpixel_mask;
               :                unsigned y_count = diameter;
               :
               :                y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
               :                fg_ptr = (const value_type*)base_type::source().span(x_lr + start, 
               :                                                                     y_lr + start, 
               :                                                                     diameter);
               :                for(;;)
               :                {
               :                    x_count  = diameter;
               :                    weight_y = weight_array[y_hr];
               :                    x_hr = image_subpixel_mask - x_fract;
               :                    for(;;)
               :                    {
               :                        int weight = (weight_y * weight_array[x_hr] + 
               :                                     image_filter_scale / 2) >> 
               :                                     image_filter_shift;
               :
               :                        fg[0] += weight * *fg_ptr++;
               :                        fg[1] += weight * *fg_ptr++;
               :                        fg[2] += weight * *fg_ptr;
               :
               :                        if(--x_count == 0) break;
               :                        x_hr  += image_subpixel_scale;
               :                        fg_ptr = (const value_type*)base_type::source().next_x();
               :                    }
               :
               :                    if(--y_count == 0) break;
               :                    y_hr  += image_subpixel_scale;
               :                    fg_ptr = (const value_type*)base_type::source().next_y();
               :                }
               :
               :                fg[0] >>= image_filter_shift;
               :                fg[1] >>= image_filter_shift;
               :                fg[2] >>= image_filter_shift;
               :
               :                if(fg[0] < 0) fg[0] = 0;
               :                if(fg[1] < 0) fg[1] = 0;
               :                if(fg[2] < 0) fg[2] = 0;
               :
               :                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
               :                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
               :                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
               :
               :                span->r = (value_type)fg[order_type::R];
               :                span->g = (value_type)fg[order_type::G];
               :                span->b = (value_type)fg[order_type::B];
               :                span->a = base_mask;
               :
               :                ++span;
               :                ++base_type::interpolator();
               :
               :            } while(--len);
               :        }
               :    };
               :
               :
               :
               :    //==========================================span_image_resample_rgb_affine
               :    template<class Source> 
               :    class span_image_resample_rgb_affine : 
               :    public span_image_resample_affine<Source>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef span_image_resample_affine<source_type> base_type;
               :        typedef typename base_type::interpolator_type interpolator_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        {
               :            base_shift      = color_type::base_shift,
               :            base_mask       = color_type::base_mask,
               :            downscale_shift = image_filter_shift
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_resample_rgb_affine() {}
               :        span_image_resample_rgb_affine(source_type& src, 
               :                                       interpolator_type& inter,
               :                                       const image_filter_lut& filter) :
               :            base_type(src, inter, filter) 
               :        {}
               :
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :
               :            long_type fg[3];
               :
               :            int diameter     = base_type::filter().diameter();
               :            int filter_scale = diameter << image_subpixel_shift;
               :            int radius_x     = (diameter * base_type::m_rx) >> 1;
               :            int radius_y     = (diameter * base_type::m_ry) >> 1;
               :            int len_x_lr     = 
               :                (diameter * base_type::m_rx + image_subpixel_mask) >> 
               :                    image_subpixel_shift;
               :
               :            const int16* weight_array = base_type::filter().weight_array();
               :
               :            do
               :            {
               :                base_type::interpolator().coordinates(&x, &y);
               :
               :                x += base_type::filter_dx_int() - radius_x;
               :                y += base_type::filter_dy_int() - radius_y;
               :
               :                fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
               :
               :                int y_lr = y >> image_subpixel_shift;
               :                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
               :                                base_type::m_ry_inv) >> 
               :                                    image_subpixel_shift;
               :                int total_weight = 0;
               :                int x_lr = x >> image_subpixel_shift;
               :                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
               :                                base_type::m_rx_inv) >> 
               :                                    image_subpixel_shift;
               :
               :                int x_hr2 = x_hr;
               :                const value_type* fg_ptr = 
               :                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
               :                for(;;)
               :                {
               :                    int weight_y = weight_array[y_hr];
               :                    x_hr = x_hr2;
               :                    for(;;)
               :                    {
               :                        int weight = (weight_y * weight_array[x_hr] + 
               :                                     image_filter_scale / 2) >> 
               :                                     downscale_shift;
               :
               :                        fg[0] += *fg_ptr++ * weight;
               :                        fg[1] += *fg_ptr++ * weight;
               :                        fg[2] += *fg_ptr   * weight;
               :                        total_weight += weight;
               :                        x_hr  += base_type::m_rx_inv;
               :                        if(x_hr >= filter_scale) break;
               :                        fg_ptr = (const value_type*)base_type::source().next_x();
               :                    }
               :                    y_hr += base_type::m_ry_inv;
               :                    if(y_hr >= filter_scale) break;
               :                    fg_ptr = (const value_type*)base_type::source().next_y();
               :                }
               :
               :                fg[0] /= total_weight;
               :                fg[1] /= total_weight;
               :                fg[2] /= total_weight;
               :
               :                if(fg[0] < 0) fg[0] = 0;
               :                if(fg[1] < 0) fg[1] = 0;
               :                if(fg[2] < 0) fg[2] = 0;
               :
               :                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
               :                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
               :                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
               :
               :                span->r = (value_type)fg[order_type::R];
               :                span->g = (value_type)fg[order_type::G];
               :                span->b = (value_type)fg[order_type::B];
               :                span->a = base_mask;
               :
               :                ++span;
               :                ++base_type::interpolator();
               :            } while(--len);
               :        }
               :    };
               :
               :
               :
               :    //=================================================span_image_resample_rgb
               :    template<class Source, class Interpolator>
               :    class span_image_resample_rgb : 
               :    public span_image_resample<Source, Interpolator>
               :    {
               :    public:
               :        typedef Source source_type;
               :        typedef typename source_type::color_type color_type;
               :        typedef typename source_type::order_type order_type;
               :        typedef Interpolator interpolator_type;
               :        typedef span_image_resample<source_type, interpolator_type> base_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::long_type long_type;
               :        enum base_scale_e
               :        {
               :            base_shift = color_type::base_shift,
               :            base_mask  = color_type::base_mask,
               :            downscale_shift = image_filter_shift
               :        };
               :
               :        //--------------------------------------------------------------------
               :        span_image_resample_rgb() {}
               :        span_image_resample_rgb(source_type& src, 
               :                                interpolator_type& inter,
               :                                const image_filter_lut& filter) :
               :            base_type(src, inter, filter)
               :        {}
               :
               :        //--------------------------------------------------------------------
               :        void generate(color_type* span, int x, int y, unsigned len)
               :        {
               :            base_type::interpolator().begin(x + base_type::filter_dx_dbl(), 
               :                                            y + base_type::filter_dy_dbl(), len);
               :            long_type fg[3];
               :
               :            int diameter = base_type::filter().diameter();
               :            int filter_scale = diameter << image_subpixel_shift;
               :
               :            const int16* weight_array = base_type::filter().weight_array();
               :            do
               :            {
               :                int rx;
               :                int ry;
               :                int rx_inv = image_subpixel_scale;
               :                int ry_inv = image_subpixel_scale;
               :                base_type::interpolator().coordinates(&x,  &y);
               :                base_type::interpolator().local_scale(&rx, &ry);
               :                base_type::adjust_scale(&rx, &ry);
               :
               :                rx_inv = image_subpixel_scale * image_subpixel_scale / rx;
               :                ry_inv = image_subpixel_scale * image_subpixel_scale / ry;
               :
               :                int radius_x = (diameter * rx) >> 1;
               :                int radius_y = (diameter * ry) >> 1;
               :                int len_x_lr = 
               :                    (diameter * rx + image_subpixel_mask) >> 
               :                        image_subpixel_shift;
               :
               :                x += base_type::filter_dx_int() - radius_x;
               :                y += base_type::filter_dy_int() - radius_y;
               :
               :                fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
               :
               :                int y_lr = y >> image_subpixel_shift;
               :                int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * 
               :                               ry_inv) >> 
               :                                   image_subpixel_shift;
               :                int total_weight = 0;
               :                int x_lr = x >> image_subpixel_shift;
               :                int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * 
               :                               rx_inv) >> 
               :                                   image_subpixel_shift;
               :                int x_hr2 = x_hr;
               :                const value_type* fg_ptr = 
               :                    (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
               :
               :                for(;;)
               :                {
               :                    int weight_y = weight_array[y_hr];
               :                    x_hr = x_hr2;
               :                    for(;;)
               :                    {
               :                        int weight = (weight_y * weight_array[x_hr] + 
               :                                     image_filter_scale / 2) >> 
               :                                     downscale_shift;
               :                        fg[0] += *fg_ptr++ * weight;
               :                        fg[1] += *fg_ptr++ * weight;
               :                        fg[2] += *fg_ptr   * weight;
               :                        total_weight += weight;
               :                        x_hr  += rx_inv;
               :                        if(x_hr >= filter_scale) break;
               :                        fg_ptr = (const value_type*)base_type::source().next_x();
               :                    }
               :                    y_hr += ry_inv;
               :                    if(y_hr >= filter_scale) break;
               :                    fg_ptr = (const value_type*)base_type::source().next_y();
               :                }
               :
               :                fg[0] /= total_weight;
               :                fg[1] /= total_weight;
               :                fg[2] /= total_weight;
               :
               :                if(fg[0] < 0) fg[0] = 0;
               :                if(fg[1] < 0) fg[1] = 0;
               :                if(fg[2] < 0) fg[2] = 0;
               :
               :                if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
               :                if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
               :                if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
               :
               :                span->r = (value_type)fg[order_type::R];
               :                span->g = (value_type)fg[order_type::G];
               :                span->b = (value_type)fg[order_type::B];
               :                span->a = base_mask;
               :
               :                ++span;
               :                ++base_type::interpolator();
               :            } while(--len);
               :        }
               :    };
               :
               :
               :}
               :
               :
               :#endif
               :
               :
               :
/* 
 * Total samples for file : "/usr/include/agg2/agg_pixfmt_rgb.h"
 * 
 *   5737  2.4183
 */


               ://----------------------------------------------------------------------------
               :// Anti-Grain Geometry (AGG) - Version 2.5
               :// A high quality rendering engine for C++
               :// Copyright (C) 2002-2006 Maxim Shemanarev
               :// Contact: mcseem@antigrain.com
               ://          mcseemagg@yahoo.com
               ://          http://antigrain.com
               :// 
               :// AGG 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
               :// of the License, or (at your option) any later version.
               :// 
               :// AGG 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 AGG; if not, write to the Free Software
               :// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
               :// MA 02110-1301, USA.
               ://----------------------------------------------------------------------------
               ://
               :// Adaptation for high precision colors has been sponsored by 
               :// Liberty Technology Systems, Inc., visit http://lib-sys.com
               ://
               :// Liberty Technology Systems, Inc. is the provider of
               :// PostScript and PDF technology for software developers.
               :// 
               ://----------------------------------------------------------------------------
               :
               :#ifndef AGG_PIXFMT_RGB_INCLUDED
               :#define AGG_PIXFMT_RGB_INCLUDED
               :
               :#include <string.h>
               :#include "agg_basics.h"
               :#include "agg_color_rgba.h"
               :#include "agg_rendering_buffer.h"
               :
               :namespace agg
               :{
               :
               :    //=====================================================apply_gamma_dir_rgb
               :    template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgb
               :    {
               :    public:
               :        typedef typename ColorT::value_type value_type;
               :
               :        apply_gamma_dir_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
               :
               :        AGG_INLINE void operator () (value_type* p)
               :        {
               :            p[Order::R] = m_gamma.dir(p[Order::R]);
               :            p[Order::G] = m_gamma.dir(p[Order::G]);
               :            p[Order::B] = m_gamma.dir(p[Order::B]);
               :        }
               :
               :    private:
               :        const GammaLut& m_gamma;
               :    };
               :
               :
               :
               :    //=====================================================apply_gamma_inv_rgb
               :    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
               :    {
               :    public:
               :        typedef typename ColorT::value_type value_type;
               :
               :        apply_gamma_inv_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
               :
               :        AGG_INLINE void operator () (value_type* p)
               :        {
               :            p[Order::R] = m_gamma.inv(p[Order::R]);
               :            p[Order::G] = m_gamma.inv(p[Order::G]);
               :            p[Order::B] = m_gamma.inv(p[Order::B]);
               :        }
               :
               :    private:
               :        const GammaLut& m_gamma;
               :    };
               :
               :
               :    //=========================================================blender_rgb
               :    template<class ColorT, class Order> struct blender_rgb
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e { base_shift = color_type::base_shift };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb, 
               :                                         unsigned alpha, 
               :                                         unsigned cover=0)
               :        {
               :            p[Order::R] += (value_type)(((cr - p[Order::R]) * alpha) >> base_shift);
               :            p[Order::G] += (value_type)(((cg - p[Order::G]) * alpha) >> base_shift);
               :            p[Order::B] += (value_type)(((cb - p[Order::B]) * alpha) >> base_shift);
               :        }
               :    };
               :
               :
               :    //======================================================blender_rgb_pre
               :    template<class ColorT, class Order> struct blender_rgb_pre
               :    {
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e { base_shift = color_type::base_shift };
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha,
               :                                         unsigned cover)
               :        {
               :            alpha = color_type::base_mask - alpha;
               :            cover = (cover + 1) << (base_shift - 8);
               :            p[Order::R] = (value_type)((p[Order::R] * alpha + cr * cover) >> base_shift);
               :            p[Order::G] = (value_type)((p[Order::G] * alpha + cg * cover) >> base_shift);
               :            p[Order::B] = (value_type)((p[Order::B] * alpha + cb * cover) >> base_shift);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        static AGG_INLINE void blend_pix(value_type* p, 
               :                                         unsigned cr, unsigned cg, unsigned cb,
               :                                         unsigned alpha)
               :        {
               :            alpha = color_type::base_mask - alpha;
               :            p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
               :            p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
               :            p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
               :        }
               :
               :    };
               :
               :
               :
               :    //===================================================blender_rgb_gamma
               :    template<class ColorT, class Order, class Gamma> class blender_rgb_gamma
               :    {
               :    public:
               :        typedef ColorT color_type;
               :        typedef Order order_type;
               :        typedef Gamma gamma_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e { base_shift = color_type::base_shift };
               :
               :        //--------------------------------------------------------------------
               :        blender_rgb_gamma() : m_gamma(0) {}
               :        void gamma(const gamma_type& g) { m_gamma = &g; }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void blend_pix(value_type* p, 
               :                                  unsigned cr, unsigned cg, unsigned cb,
               :                                  unsigned alpha, 
               :                                  unsigned cover=0)
               :        {
               :            calc_type r = m_gamma->dir(p[Order::R]);
               :            calc_type g = m_gamma->dir(p[Order::G]);
               :            calc_type b = m_gamma->dir(p[Order::B]);
               :            p[Order::R] = m_gamma->inv((((m_gamma->dir(cr) - r) * alpha) >> base_shift) + r);
               :            p[Order::G] = m_gamma->inv((((m_gamma->dir(cg) - g) * alpha) >> base_shift) + g);
               :            p[Order::B] = m_gamma->inv((((m_gamma->dir(cb) - b) * alpha) >> base_shift) + b);
               :        }
               :
               :    private:
               :        const gamma_type* m_gamma;
               :    };
               :
               :
               :
               :    
               :    //==================================================pixfmt_alpha_blend_rgb
               :    template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb
               :    {
               :    public:
               :        typedef RenBuf   rbuf_type;
               :        typedef Blender  blender_type;
               :        typedef typename rbuf_type::row_data row_data;
               :        typedef typename blender_type::color_type color_type;
               :        typedef typename blender_type::order_type order_type;
               :        typedef typename color_type::value_type value_type;
               :        typedef typename color_type::calc_type calc_type;
               :        enum base_scale_e 
               :        {
               :            base_shift = color_type::base_shift,
               :            base_scale = color_type::base_scale,
               :            base_mask  = color_type::base_mask,
               :            pix_width  = sizeof(value_type) * 3
               :        };
               :
               :    private:
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_or_blend_pix(value_type* p, 
               :                                          const color_type& c, 
               :                                          unsigned cover)
               :        {
               :            if (c.a)
               :            {
               :                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
               :                if(alpha == base_mask)
               :                {
               :                    p[order_type::R] = c.r;
               :                    p[order_type::G] = c.g;
               :                    p[order_type::B] = c.b;
               :                }
               :                else
               :                {
               :                    m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_or_blend_pix(value_type* p, 
               :                                          const color_type& c)
               :        {
               :            if (c.a)
               :            {
               :                if(c.a == base_mask)
               :                {
               :                    p[order_type::R] = c.r;
               :                    p[order_type::G] = c.g;
               :                    p[order_type::B] = c.b;
               :                }
               :                else
               :                {
               :                    m_blender.blend_pix(p, c.r, c.g, c.b, c.a);
               :                }
               :            }
               :        }
               :
               :
               :    public:
               :        //--------------------------------------------------------------------
               :        explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
               :            m_rbuf(&rb)
               :        {}
               :        void attach(rbuf_type& rb) { m_rbuf = &rb; }
               :
               :        //--------------------------------------------------------------------
               :        template<class PixFmt>
               :        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
               :        {
               :            rect_i r(x1, y1, x2, y2);
               :            if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
               :            {
               :                int stride = pixf.stride();
               :                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
               :                               (r.x2 - r.x1) + 1,
               :                               (r.y2 - r.y1) + 1,
               :                               stride);
               :                return true;
               :            }
               :            return false;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        Blender& blender() { return m_blender; }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
  3325  1.4016 :        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
               :        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
               :        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
               :        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE int8u* pix_ptr(int x, int y) 
               :        { 
               :            return m_rbuf->row_ptr(y) + x * pix_width; 
               :        }
               :
               :        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
               :        { 
  2412  1.0167 :            return m_rbuf->row_ptr(y) + x * pix_width; 
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
               :        {
               :            ((value_type*)p)[order_type::R] = c.r;
               :            ((value_type*)p)[order_type::G] = c.g;
               :            ((value_type*)p)[order_type::B] = c.b;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE color_type pixel(int x, int y) const
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(y) + x + x + x;
               :            return color_type(p[order_type::R], 
               :                              p[order_type::G], 
               :                              p[order_type::B]);
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x;
               :            p[order_type::R] = c.r;
               :            p[order_type::G] = c.g;
               :            p[order_type::B] = c.b;
               :        }
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
               :        {
               :            copy_or_blend_pix((value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x, c, cover);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_hline(int x, int y, 
               :                                   unsigned len, 
               :                                   const color_type& c)
               :        {
               :            value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
               :            do
               :            {
               :                p[order_type::R] = c.r; 
               :                p[order_type::G] = c.g; 
               :                p[order_type::B] = c.b;
               :                p += 3;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        AGG_INLINE void copy_vline(int x, int y,
               :                                   unsigned len, 
               :                                   const color_type& c)
               :        {
               :            do
               :            {
               :                value_type* p = (value_type*)
               :                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :                p[order_type::R] = c.r; 
               :                p[order_type::G] = c.g; 
               :                p[order_type::B] = c.b;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_hline(int x, int y,
               :                         unsigned len, 
               :                         const color_type& c,
               :                         int8u cover)
               :        {
               :            if (c.a)
               :            {
               :                value_type* p = (value_type*)
               :                    m_rbuf->row_ptr(x, y, len) + x + x + x;
               :
               :                calc_type alpha = (calc_type(c.a) * (calc_type(cover) + 1)) >> 8;
               :                if(alpha == base_mask)
               :                {
               :                    do
               :                    {
               :                        p[order_type::R] = c.r; 
               :                        p[order_type::G] = c.g; 
               :                        p[order_type::B] = c.b;
               :                        p += 3;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do
               :                    {
               :                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
               :                        p += 3;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_vline(int x, int y,
               :                         unsigned len, 
               :                         const color_type& c,
               :                         int8u cover)
               :        {
               :            if (c.a)
               :            {
               :                value_type* p;
               :                calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
               :                if(alpha == base_mask)
               :                {
               :                    do
               :                    {
               :                        p = (value_type*)
               :                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                        p[order_type::R] = c.r; 
               :                        p[order_type::G] = c.g; 
               :                        p[order_type::B] = c.b;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do
               :                    {
               :                        p = (value_type*)
               :                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_hspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type& c,
               :                               const int8u* covers)
               :        {
               :            if (c.a)
               :            {
               :                value_type* p = (value_type*)
               :                    m_rbuf->row_ptr(x, y, len) + x + x + x;
               :
               :                do 
               :                {
               :                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
               :                    if(alpha == base_mask)
               :                    {
               :                        p[order_type::R] = c.r;
               :                        p[order_type::G] = c.g;
               :                        p[order_type::B] = c.b;
               :                    }
               :                    else
               :                    {
               :                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
               :                    }
               :                    p += 3;
               :                    ++covers;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_solid_vspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type& c,
               :                               const int8u* covers)
               :        {
               :            if (c.a)
               :            {
               :                do 
               :                {
               :                    value_type* p = (value_type*)
               :                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                    calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
               :                    if(alpha == base_mask)
               :                    {
               :                        p[order_type::R] = c.r;
               :                        p[order_type::G] = c.g;
               :                        p[order_type::B] = c.b;
               :                    }
               :                    else
               :                    {
               :                        m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
               :                    }
               :                    ++covers;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_hspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :            value_type* p = (value_type*)
               :                m_rbuf->row_ptr(x, y, len) + x + x + x;
               :
               :            do 
               :            {
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                ++colors;
               :                p += 3;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void copy_color_vspan(int x, int y,
               :                              unsigned len, 
               :                              const color_type* colors)
               :        {
               :            do 
               :            {
               :                value_type* p = (value_type*)
               :                    m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :                p[order_type::R] = colors->r;
               :                p[order_type::G] = colors->g;
               :                p[order_type::B] = colors->b;
               :                ++colors;
               :            }
               :            while(--len);
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_hspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type* colors,
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
               :            value_type* p = (value_type*)
               :                m_rbuf->row_ptr(x, y, len) + x + x + x;
               :
               :            if(covers)
               :            {
               :                do 
               :                {
               :                    copy_or_blend_pix(p, *colors++, *covers++);
               :                    p += 3;
               :                }
               :                while(--len);
               :            }
               :            else
               :            {
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        copy_or_blend_pix(p, *colors++);
               :                        p += 3;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        copy_or_blend_pix(p, *colors++, cover);
               :                        p += 3;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :
               :
               :        //--------------------------------------------------------------------
               :        void blend_color_vspan(int x, int y,
               :                               unsigned len, 
               :                               const color_type* colors,
               :                               const int8u* covers,
               :                               int8u cover)
               :        {
               :            value_type* p;
               :            if(covers)
               :            {
               :                do 
               :                {
               :                    p = (value_type*)
               :                        m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                    copy_or_blend_pix(p, *colors++, *covers++);
               :                }
               :                while(--len);
               :            }
               :            else
               :            {
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        p = (value_type*)
               :                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                        copy_or_blend_pix(p, *colors++);
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        p = (value_type*)
               :                            m_rbuf->row_ptr(x, y++, 1) + x + x + x;
               :
               :                        copy_or_blend_pix(p, *colors++, cover);
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class Function> void for_each_pixel(Function f)
               :        {
               :            unsigned y;
               :            for(y = 0; y < height(); ++y)
               :            {
               :                row_data r = m_rbuf->row(y);
               :                if(r.ptr)
               :                {
               :                    unsigned len = r.x2 - r.x1 + 1;
               :                    value_type* p = (value_type*)
               :                        m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
               :                    do
               :                    {
               :                        f(p);
               :                        p += 3;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
               :        {
               :            for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class RenBuf2>
               :        void copy_from(const RenBuf2& from, 
               :                       int xdst, int ydst,
               :                       int xsrc, int ysrc,
               :                       unsigned len)
               :        {
               :            const int8u* p = from.row_ptr(ysrc);
               :            if(p)
               :            {
               :                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
               :                        p + xsrc * pix_width, 
               :                        len * pix_width);
               :            }
               :        }
               :
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from(const SrcPixelFormatRenderer& from, 
               :                        int xdst, int ydst,
               :                        int xsrc, int ysrc,
               :                        unsigned len,
               :                        int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::order_type src_order;
               :
               :            const value_type* psrc = (const value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                psrc += xsrc * 4;
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;   
               :
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        value_type alpha = psrc[src_order::A];
               :                        if(alpha)
               :                        {
               :                            if(alpha == base_mask)
               :                            {
               :                                pdst[order_type::R] = psrc[src_order::R];
               :                                pdst[order_type::G] = psrc[src_order::G];
               :                                pdst[order_type::B] = psrc[src_order::B];
               :                            }
               :                            else
               :                            {
               :                                m_blender.blend_pix(pdst, 
               :                                                    psrc[src_order::R],
               :                                                    psrc[src_order::G],
               :                                                    psrc[src_order::B],
               :                                                    alpha);
               :                            }
               :                        }
               :                        psrc += 4;
               :                        pdst += 3;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    color_type color;
               :                    do 
               :                    {
               :                        color.r = psrc[src_order::R];
               :                        color.g = psrc[src_order::G];
               :                        color.b = psrc[src_order::B];
               :                        color.a = psrc[src_order::A];
               :                        copy_or_blend_pix(pdst, color, cover);
               :                        psrc += 4;
               :                        pdst += 3;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_color(const SrcPixelFormatRenderer& from, 
               :                              const color_type& color,
               :                              int xdst, int ydst,
               :                              int xsrc, int ysrc,
               :                              unsigned len,
               :                              int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
               :                do 
               :                {
               :                    copy_or_blend_pix(pdst, 
               :                                      color, 
               :                                      (*psrc * cover + base_mask) >> base_shift);
               :                    ++psrc;
               :                    pdst += 3;
               :                }
               :                while(--len);
               :            }
               :        }
               :
               :        //--------------------------------------------------------------------
               :        template<class SrcPixelFormatRenderer>
               :        void blend_from_lut(const SrcPixelFormatRenderer& from, 
               :                            const color_type* color_lut,
               :                            int xdst, int ydst,
               :                            int xsrc, int ysrc,
               :                            unsigned len,
               :                            int8u cover)
               :        {
               :            typedef typename SrcPixelFormatRenderer::value_type src_value_type;
               :            const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
               :            if(psrc)
               :            {
               :                value_type* pdst = 
               :                    (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
               :
               :                if(cover == 255)
               :                {
               :                    do 
               :                    {
               :                        const color_type& color = color_lut[*psrc];
               :                        m_blender.blend_pix(pdst, 
               :                                            color.r, color.g, color.b, color.a);
               :                        ++psrc;
               :                        pdst += 3;
               :                    }
               :                    while(--len);
               :                }
               :                else
               :                {
               :                    do 
               :                    {
               :                        copy_or_blend_pix(pdst, color_lut[*psrc], cover);
               :                        ++psrc;
               :                        pdst += 3;
               :                    }
               :                    while(--len);
               :                }
               :            }
               :        }
               :
               :    private:
               :        rbuf_type* m_rbuf;
               :        Blender    m_blender;
               :    };
               :
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8,  order_rgb>, rendering_buffer> pixfmt_rgb24;    //----pixfmt_rgb24
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba8,  order_bgr>, rendering_buffer> pixfmt_bgr24;    //----pixfmt_bgr24
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48;    //----pixfmt_rgb48
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48;    //----pixfmt_bgr48
               :
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_rgb>, rendering_buffer> pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8,  order_bgr>, rendering_buffer> pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
               :    typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
               :
               :    //-----------------------------------------------------pixfmt_rgb24_gamma
               :    template<class Gamma> class pixfmt_rgb24_gamma : 
               :    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
               :    {
               :    public:
               :        pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
               :            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb) 
               :        {
               :            this->blender().gamma(g);
               :        }
               :    };
               :        
               :    //-----------------------------------------------------pixfmt_bgr24_gamma
               :    template<class Gamma> class pixfmt_bgr24_gamma : 
               :    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
               :    {
               :    public:
               :        pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
               :            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb) 
               :        {
               :            this->blender().gamma(g);
               :        }
               :    };
               :
               :    //-----------------------------------------------------pixfmt_rgb48_gamma
               :    template<class Gamma> class pixfmt_rgb48_gamma : 
               :    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
               :    {
               :    public:
               :        pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
               :            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb) 
               :        {
               :            this->blender().gamma(g);
               :        }
               :    };
               :        
               :    //-----------------------------------------------------pixfmt_bgr48_gamma
               :    template<class Gamma> class pixfmt_bgr48_gamma : 
               :    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
               :    {
               :    public:
               :        pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
               :            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb) 
               :        {
               :            this->blender().gamma(g);
               :        }
               :    };
               :
               :
               :}
               :
               :#endif
               :