function BenchArtCircles(container, width, height, data, params) {
    var self, objects, surface, art;

    return self = {
        init: function () {
            if (params.renderer === 'canvas') {
                var canvas = params.cache('2d-alpha');
                canvas.width = width;
                canvas.height = height;
                container.node().appendChild(canvas);
                canvas.getContext('2d', {alpha: true});

                art = ArtCanvas;
                surface = art.Surface(width, height, canvas);
                surface._valid = false;
            } else {
                art = ArtSvg;
                surface = art.Surface(width, height);
                surface.inject(container.node());
            }

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                var o = art.Ellipse(c.radius * 2, c.radius * 2)
                    .fill(c.fillRgba)
                    .inject(surface);

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                objects[i].moveTo(data[i].x, data[i].y);
            }

            if(params.renderer === 'canvas') {
                surface.render();
            }
        },
        destroy: function () {
        }
    };
}

BenchArtCircles.framework = 'art';
BenchArtCircles.version = ArtCanvas.version;
BenchArtCircles.object = 'circle';
BenchArtCircles.renderers = ['canvas', 'svg'];

Bench.list.push(BenchArtCircles);

function BenchArtRectangles(container, width, height, data, params) {
    var self, objects, surface, art;

    return self = {
        init: function () {
            if (params.renderer === 'canvas') {
                var canvas = params.cache('2d-alpha');
                canvas.width = width;
                canvas.height = height;
                container.node().appendChild(canvas);
                canvas.getContext('2d', {alpha: true});

                art = ArtCanvas;
                surface = art.Surface(width, height, canvas);
                surface._valid = false;
            } else {
                art = ArtSvg;
                surface = art.Surface(width, height);
                surface.inject(container.node());
            }

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                var o = art.Rectangle(c.w, c.h)
                    .fill(c.fillRgba)
                    .inject(surface);

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                objects[i].moveTo(data[i].x, data[i].y);
            }

            if(params.renderer === 'canvas') {
                surface.render();
            }
        },
        destroy: function () {
        }
    };
}

BenchArtRectangles.version = ArtCanvas.version;
BenchArtRectangles.framework = 'art';
BenchArtRectangles.object = 'rectangle';
BenchArtRectangles.renderers = ['canvas', 'svg'];

Bench.list.push(BenchArtRectangles);

function BenchArtRounded(container, width, height, data, params) {
    var self, objects, surface, art;

    return self = {
        init: function () {
            if (params.renderer === 'canvas') {
                var canvas = params.cache('2d-alpha');
                canvas.width = width;
                canvas.height = height;
                container.node().appendChild(canvas);
                canvas.getContext('2d', {alpha: true});

                art = ArtCanvas;
                surface = art.Surface(width, height, canvas);
                surface._valid = false;
            } else {
                art = ArtSvg;
                surface = art.Surface(width, height);
                surface.inject(container.node());
            }

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                var o = art.Rectangle(c.w, c.h, c.cornerRadius)
                    .fill(c.fillRgba)
                    .stroke(c.strokeRgba, c.lineWidth)
                    .inject(surface);

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                objects[i].moveTo(data[i].x, data[i].y);
            }

            if(params.renderer === 'canvas') {
                surface.render();
            }
        },
        destroy: function () {
        }
    };
}

BenchArtRounded.version = ArtCanvas.version;
BenchArtRounded.framework = 'art';
BenchArtRounded.object = 'rounded';
BenchArtRounded.renderers = ['canvas', 'svg'];

Bench.list.push(BenchArtRounded);

function BenchArtText(container, width, height, data, params) {
    var self, objects, surface, art;

    return self = {
        init: function () {
            if (params.renderer === 'canvas') {
                var canvas = params.cache('2d-alpha');
                canvas.width = width;
                canvas.height = height;
                container.node().appendChild(canvas);
                canvas.getContext('2d', {alpha: true});

                art = ArtCanvas;
                surface = art.Surface(width, height, canvas);
                surface._valid = false;
            } else {
                art = ArtSvg;
                surface = art.Surface(width, height);
                surface.inject(container.node());
            }

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                var o = art.Text(c.text, c.textSize + 'px ' + c.fontFamily)
                    .fill(c.fillRgba)
                    .inject(surface);

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                objects[i].moveTo(data[i].x, data[i].y);
            }

            if(params.renderer === 'canvas') {
                surface.render();
            }
        },
        destroy: function () {
        }
    };
}

BenchArtText.version = ArtCanvas.version;
BenchArtText.framework = 'art';
BenchArtText.object = 'text';
BenchArtText.renderers = ['canvas', 'svg'];

Bench.list.push(BenchArtText);

function BenchD3CanvasCircles(container, width, height, data, params) {
    var self, ctx;

    return self = {
        init: function () {
            var canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);
            ctx = canvas.getContext('2d', {alpha: false});

            self.update();
        },
        update: function () {
            ctx.fillStyle = '#fff';
            ctx.fillRect(0, 0, width, height);

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                ctx.beginPath();
                ctx.arc(c.x, c.y, c.radius, 0, 2 * Math.PI);
                ctx.closePath();

                ctx.fillStyle = c.fillRgba;

                ctx.fill();
            }
        },
        destroy: function () {
            ctx = null;
        }
    };
}

BenchD3CanvasCircles.version = d3.version;
BenchD3CanvasCircles.framework = 'd3';
BenchD3CanvasCircles.object = 'circle';
BenchD3CanvasCircles.renderers = ['canvas'];

Bench.list.push(BenchD3CanvasCircles);

function BenchD3CanvasRectangles(container, width, height, data, params) {
    var self, ctx;

    return self = {
        init: function () {
            var canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);
            ctx = canvas.getContext('2d', {alpha: false});

            self.update();
        },
        update: function () {
            ctx.fillStyle = '#fff';
            ctx.fillRect(0, 0, width, height);

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                ctx.fillStyle = c.fillRgba;
                ctx.fillRect(c.x, c.y, c.w, c.h);
            }
        },
        destroy: function () {
            ctx = null;
        }
    };
}

BenchD3CanvasRectangles.version = d3.version;
BenchD3CanvasRectangles.framework = 'd3';
BenchD3CanvasRectangles.object = 'rectangle';
BenchD3CanvasRectangles.renderers = ['canvas'];

Bench.list.push(BenchD3CanvasRectangles);

function BenchD3CanvasRounded(container, width, height, data, params) {
    var self, ctx;

    return self = {
        init: function () {
            var canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);
            ctx = canvas.getContext('2d', {alpha: false});

            self.update();
        },
        update: function () {
            ctx.fillStyle = '#fff';
            ctx.fillRect(0, 0, width, height);

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                ctx.beginPath();
                ctx.moveTo(c.x + c.cornerRadius, c.y);
                ctx.lineTo(c.x + c.w - c.cornerRadius, c.y);
                ctx.quadraticCurveTo(c.x + c.w, c.y, c.x + c.w, c.y + c.cornerRadius);
                ctx.lineTo(c.x + c.w, c.y + c.h - c.cornerRadius);
                ctx.quadraticCurveTo(c.x + c.w, c.y + c.h, c.x + c.w - c.cornerRadius, c.y + c.h);
                ctx.lineTo(c.x + c.cornerRadius, c.y + c.h);
                ctx.quadraticCurveTo(c.x, c.y + c.h, c.x, c.y + c.h - c.cornerRadius);
                ctx.lineTo(c.x, c.y + c.cornerRadius);
                ctx.quadraticCurveTo(c.x, c.y, c.x + c.cornerRadius, c.y);
                ctx.closePath();

                ctx.fillStyle = c.fillRgba;
                ctx.strokeStyle = c.strokeRgba;
                ctx.lineWidth = c.lineWidth;

                ctx.fill();
                ctx.stroke();
            }
        },
        destroy: function () {
            ctx = null;
        }
    };
}

BenchD3CanvasRounded.version = d3.version;
BenchD3CanvasRounded.framework = 'd3';
BenchD3CanvasRounded.object = 'rounded';
BenchD3CanvasRounded.renderers = ['canvas'];

Bench.list.push(BenchD3CanvasRounded);

function BenchD3CanvasText(container, width, height, data, params) {
    var self, ctx;

    return self = {
        init: function () {
            var canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);
            ctx = canvas.getContext('2d', {alpha: false});

            self.update();
        },
        update: function () {
            ctx.fillStyle = '#fff';
            ctx.fillRect(0, 0, width, height);

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                ctx.fillStyle = c.fillRgba;
                ctx.font = c.textSize + 'px ' + c.fontFamily;
                ctx.fillText(c.text, c.x, c.y);
            }
        },
        destroy: function () {
            ctx = null;
        }
    };
}

BenchD3CanvasText.version = d3.version;
BenchD3CanvasText.framework = 'd3';
BenchD3CanvasText.object = 'text';
BenchD3CanvasText.renderers = ['canvas'];

Bench.list.push(BenchD3CanvasText);

function BenchD3CanvasTriangles(container, width, height, data, params) {
    var self, ctx;

    return self = {
        init: function () {
            var canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);
            ctx = canvas.getContext('2d', {alpha: false});

            self.update();
        },
        update: function () {
            ctx.fillStyle = '#fff';
            ctx.fillRect(0, 0, width, height);

            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                ctx.beginPath();
                ctx.moveTo(c.x + c.triangleSide / 2, c.y);
                ctx.lineTo(c.x, c.y + c.triangleHeight);
                ctx.lineTo(c.x + c.triangleSide, c.y + c.triangleHeight);
                ctx.closePath();

                ctx.fillStyle = c.fillRgba;
                ctx.fill();
            }
        },
        destroy: function () {
            ctx = null;
        }
    };
}

BenchD3CanvasTriangles.version = d3.version;
BenchD3CanvasTriangles.framework = 'd3';
BenchD3CanvasTriangles.object = 'triangles';
BenchD3CanvasTriangles.renderers = ['canvas'];
BenchD3CanvasTriangles.limits = {canvas: -1};

Bench.list.push(BenchD3CanvasTriangles);

function BenchD3SvgCircles(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('circle').data(data);
            renderer.enter().append('circle')
                .attr('r', function (d) {
                    return d.radius;
                })
                .attr('fill', function (d) {
                    return d.fillRgba;
                })
                .attr('cx', function (d) {
                    return d.x;
                })
                .attr('cy', function (d) {
                    return d.y;
                });
        },
        update: function () {
            renderer.attr('cx', function (d) {
                    return d.x;
                })
                .attr('cy', function (d) {
                    return d.y;
                });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgCircles.version = d3.version;
BenchD3SvgCircles.framework = 'd3';
BenchD3SvgCircles.object = 'circle';
BenchD3SvgCircles.renderers = ['svg'];

Bench.list.push(BenchD3SvgCircles);

function BenchD3SvgPathCircles(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('path').data(data);
            renderer.enter().append('path')
                .attr('fill', function (d) {
                    return d.fillRgba;
                });
        },
        update: function () {
            renderer.attr('d', function (c) {
                var ctx = new Path();

                ctx.arc(c.x, c.y, c.radius, 0, 2 * Math.PI);
                ctx.closePath();

                return ctx.toString();
            });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgPathCircles.version = d3.version;
BenchD3SvgPathCircles.framework = 'd3';
BenchD3SvgPathCircles.object = 'circle';
BenchD3SvgPathCircles.renderers = ['path'];

Bench.list.push(BenchD3SvgPathCircles);

function BenchD3SvgPathRectangles(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('path').data(data);
            renderer.enter().append('path')
                .attr('fill', function (d) {
                    return d.fillRgba;
                });
        },
        update: function () {
            renderer.attr('d', function (c) {
                var ctx = new Path();

                ctx.moveTo(c.x, c.y);
                ctx.lineTo(c.x + c.w, c.y);
                ctx.lineTo(c.x + c.w, c.y + c.h);
                ctx.lineTo(c.x, c.y + c.h);
                ctx.closePath();

                return ctx.toString();
            });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgPathRectangles.version = d3.version;
BenchD3SvgPathRectangles.framework = 'd3';
BenchD3SvgPathRectangles.object = 'rectangle';
BenchD3SvgPathRectangles.renderers = ['path'];

Bench.list.push(BenchD3SvgPathRectangles);

function BenchD3SvgPathRounded(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('path').data(data);
            renderer.enter().append('path')
                .attr('fill', function (d) {
                    return d.fillRgba;
                })
                .attr('stroke', function (d) {
                    return d.strokeRgba;
                })
                .attr('stroke-width', function (d) {
                    return d.lineWidth;
                });
        },
        update: function () {
            renderer.attr('d', function (c) {
                var ctx = new Path();

                ctx.moveTo(c.x + c.cornerRadius, c.y);
                ctx.lineTo(c.x + c.w - c.cornerRadius, c.y);
                ctx.quadraticCurveTo(c.x + c.w, c.y, c.x + c.w, c.y + c.cornerRadius);
                ctx.lineTo(c.x + c.w, c.y + c.h - c.cornerRadius);
                ctx.quadraticCurveTo(c.x + c.w, c.y + c.h, c.x + c.w - c.cornerRadius, c.y + c.h);
                ctx.lineTo(c.x + c.cornerRadius, c.y + c.h);
                ctx.quadraticCurveTo(c.x, c.y + c.h, c.x, c.y + c.h - c.cornerRadius);
                ctx.lineTo(c.x, c.y + c.cornerRadius);
                ctx.quadraticCurveTo(c.x, c.y, c.x + c.cornerRadius, c.y);
                ctx.closePath();

                return ctx.toString();
            });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgPathRounded.version = d3.version;
BenchD3SvgPathRounded.framework = 'd3';
BenchD3SvgPathRounded.object = 'rounded';
BenchD3SvgPathRounded.renderers = ['path'];

Bench.list.push(BenchD3SvgPathRounded);

function BenchD3SvgRectangles(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('rect').data(data);
            renderer.enter().append('rect')
                .attr('width', function (d) {
                    return d.w;
                })
                .attr('height', function (d) {
                    return d.h;
                })
                .attr('fill', function (d) {
                    return d.fillRgba;
                })
                .attr('x', function (d) {
                    return d.x;
                })
                .attr('y', function (d) {
                    return d.y;
                });
        },
        update: function () {
            renderer.attr('x', function (d) {
                    return d.x;
                })
                .attr('y', function (d) {
                    return d.y;
                });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgRectangles.version = d3.version;
BenchD3SvgRectangles.framework = 'd3';
BenchD3SvgRectangles.object = 'rectangle';
BenchD3SvgRectangles.renderers = ['svg'];

Bench.list.push(BenchD3SvgRectangles);

function BenchD3SvgRounded(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('rect').data(data);
            renderer.enter().append('rect')
                .attr('width', function (d) {
                    return d.w;
                })
                .attr('height', function (d) {
                    return d.h;
                })
                .attr('rx', function (d) {
                    return d.cornerRadius;
                })
                .attr('ry', function (d) {
                    return d.cornerRadius;
                })
                .attr('fill', function (d) {
                    return d.fillRgba;
                })
                .attr('stroke', function (d) {
                    return d.strokeRgba;
                })
                .attr('stroke-width', function (d) {
                    return d.lineWidth;
                })
                .attr('x', function (d) {
                    return d.x;
                })
                .attr('y', function (d) {
                    return d.y;
                });
        },
        update: function () {
            renderer.attr('x', function (d) {
                    return d.x;
                })
                .attr('y', function (d) {
                    return d.y;
                });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgRounded.version = d3.version;
BenchD3SvgRounded.framework = 'd3';
BenchD3SvgRounded.object = 'rounded';
BenchD3SvgRounded.renderers = ['svg'];

Bench.list.push(BenchD3SvgRounded);

function BenchD3SvgText(container, width, height, data) {
    var renderer, svg;

    return {
        init: function () {
            svg = container.append('svg').attr({width: width, height: height});
            renderer = svg.selectAll('text').data(data);
            renderer.enter().append('text')
                .text(function (d) {
                    return d.text;
                })
                .style('font-size', function (d) {
                    return d.textSize + 'px';
                })
                .style('font-family', function (d) {
                    return d.fontFamily;
                })
                .attr('fill', function (d) {
                    return d.fillRgba;
                })
                .attr('dx', function (d) {
                    return d.x;
                })
                .attr('dy', function (d) {
                    return d.y;
                });
        },
        update: function () {
            renderer.attr('dx', function (d) {
                    return d.x;
                })
                .attr('dy', function (d) {
                    return d.y;
                });
        },
        destroy: function () {
            renderer = null;
            svg = null;
        }
    };
}

BenchD3SvgText.version = d3.version;
BenchD3SvgText.framework = 'd3';
BenchD3SvgText.object = 'text';
BenchD3SvgText.renderers = ['svg'];

Bench.list.push(BenchD3SvgText);

function BenchEaselCircles(container, width, height, data, params) {
    var self, objects, stage;

    return self = {
        init: function () {
            var canvas = canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stage = new createjs.Stage(canvas);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new createjs.Shape();
                o.graphics
                    .beginFill(d.fillRgba)
                    .drawCircle(0, 0, d.radius);

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].x = c.x;
                objects[i].y = c.y;
            }

            stage.update();
        },
        destroy: function () {
            objects = null;
            stage = null;
        }
    };
}

BenchEaselCircles.version = createjs.EaselJS.version;
BenchEaselCircles.framework = 'easel';
BenchEaselCircles.object = 'circle';
BenchEaselCircles.renderers = ['canvas'];

Bench.list.push(BenchEaselCircles);

function BenchEaselRectangles(container, width, height, data, params) {
    var self, objects, stage;

    return self = {
        init: function () {
            var canvas = canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stage = new createjs.Stage(canvas);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new createjs.Shape();
                o.graphics
                    .beginFill(d.fillRgba)
                    .drawRect(0, 0, d.w, d.h);

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].x = c.x;
                objects[i].y = c.y;
            }

            stage.update();
        },
        destroy: function () {
            objects = null;
            stage = null;
        }
    };
}

BenchEaselRectangles.version = createjs.EaselJS.version;
BenchEaselRectangles.framework = 'easel';
BenchEaselRectangles.object = 'rectangle';
BenchEaselRectangles.renderers = ['canvas'];

Bench.list.push(BenchEaselRectangles);

function BenchEaselRounded(container, width, height, data, params) {
    var self, objects, stage;

    return self = {
        init: function () {
            var canvas = canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stage = new createjs.Stage(canvas);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new createjs.Shape();
                o.graphics
                    .beginFill(d.fillRgba)
                    .setStrokeStyle(d.lineWidth)
                    .beginStroke(d.strokeRgba)
                    .drawRoundRect(0, 0, d.w, d.h, d.cornerRadius);

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].x = c.x;
                objects[i].y = c.y;
            }

            stage.update();
        },
        destroy: function () {
            objects = null;
            stage = null;
        }
    };
}

BenchEaselRounded.version = createjs.EaselJS.version;
BenchEaselRounded.framework = 'easel';
BenchEaselRounded.object = 'rounded';
BenchEaselRounded.renderers = ['canvas'];

Bench.list.push(BenchEaselRounded);

function BenchEaselText(container, width, height, data, params) {
    var self, objects, stage;

    return self = {
        init: function () {
            var canvas = canvas = params.cache('2d');
            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stage = new createjs.Stage(canvas);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new createjs.Text(d.text, d.textSize + 'px ' + d.fontFamily, d.fillRgba);

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].x = c.x;
                objects[i].y = c.y;
            }

            stage.update();
        },
        destroy: function () {
            objects = null;
            stage = null;
        }
    };
}

BenchEaselText.version = createjs.EaselJS.version;
BenchEaselText.framework = 'easel';
BenchEaselText.object = 'text';
BenchEaselText.renderers = ['canvas'];

Bench.list.push(BenchEaselText);

function BenchPixiCircles(container, width, height, data, params) {
    var self, renderer, objects, stage;

    return self = {
        init: function () {
            PIXI.utils._saidHello = true;

            var map = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer'
            };

            var canvas;

            if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-pixi');
            } else if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            }

            params.renderer = map[params.renderer];

            renderer = new PIXI[params.renderer](width, height, {
                view: canvas,
                backgroundColor: 0xFFFFFF
            });

            container.node().appendChild(renderer.view);
            stage = new PIXI.Container();
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new PIXI.Graphics();

                o.beginFill(d.fillNumber, d.fillOpacity);
                o.drawCircle(0, 0, d.radius);
                o.endFill();

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(stage);
        },
        destroy: function () {
            objects = null;
            renderer.destroy();
            stage.destroy();
            stage = null;
            renderer = null;
        }
    };
}

BenchPixiCircles.version = PIXI.VERSION;
BenchPixiCircles.framework = 'pixi';
BenchPixiCircles.object = 'circle';
BenchPixiCircles.renderers = ['webgl', 'canvas'];

Bench.list.push(BenchPixiCircles);

function BenchPixiRectangles(container, width, height, data, params) {
    var self, renderer, objects, stage;

    return self = {
        init: function () {
            PIXI.utils._saidHello = true;

            var map = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer'
            };

            var canvas;

            if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-pixi');
            } else if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            }

            params.renderer = map[params.renderer];

            renderer = new PIXI[params.renderer](width, height, {
                view: canvas,
                backgroundColor: 0xFFFFFF
            });

            container.node().appendChild(renderer.view);
            stage = new PIXI.Container();
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new PIXI.Graphics();

                o.beginFill(d.fillNumber, d.fillOpacity);
                o.drawRect(0, 0, d.w, d.h);
                o.endFill();

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(stage);
        },
        destroy: function () {
            objects = null;
            renderer.destroy();
            stage.destroy();
            stage = null;
            renderer = null;
        }
    };
}

BenchPixiRectangles.version = PIXI.VERSION;
BenchPixiRectangles.framework = 'pixi';
BenchPixiRectangles.object = 'rectangle';
BenchPixiRectangles.renderers = ['webgl', 'canvas'];

Bench.list.push(BenchPixiRectangles);

function BenchPixiRounded(container, width, height, data, params) {
    var self, renderer, objects, stage;

    return self = {
        init: function () {
            PIXI.utils._saidHello = true;

            var map = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer'
            };

            var canvas;

            if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-pixi');
            } else if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            }

            params.renderer = map[params.renderer];

            renderer = new PIXI[params.renderer](width, height, {
                view: canvas,
                backgroundColor: 0xFFFFFF
            });

            container.node().appendChild(renderer.view);
            stage = new PIXI.Container();
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new PIXI.Graphics();

                o.lineStyle(d.lineWidth, d.strokeNumber, d.strokeOpacity);
                o.beginFill(d.fillNumber, d.fillOpacity);
                o.drawRoundedRect(0, 0, d.w, d.h, d.cornerRadius);
                o.endFill();

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(stage);
        },
        destroy: function () {
            objects = null;
            renderer.destroy();
            stage.destroy();
            stage = null;
            renderer = null;
        }
    };
}

BenchPixiRounded.version = PIXI.VERSION;
BenchPixiRounded.framework = 'pixi';
BenchPixiRounded.object = 'rounded';
BenchPixiRounded.renderers = ['webgl', 'canvas'];

Bench.list.push(BenchPixiRounded);

function BenchPixiText(container, width, height, data, params) {
    var self, renderer, objects, stage;

    return self = {
        init: function () {
            PIXI.utils._saidHello = true;

            var map = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer'
            };

            var canvas;

            if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-pixi');
            } else if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            }

            params.renderer = map[params.renderer];

            renderer = new PIXI[params.renderer](width, height, {
                view: canvas,
                backgroundColor: 0xFFFFFF
            });

            container.node().appendChild(renderer.view);
            stage = new PIXI.Container();
            renderer.render(stage);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = new PIXI.Text(d.text, {font: d.textSize + 'px ' + d.fontFamily, fill: d.fillRgba});

                stage.addChild(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(stage);
        },
        destroy: function () {
            objects = null;
            renderer.destroy();
            stage.destroy();
            stage = null;
            renderer = null;
        }
    };
}

BenchPixiText.version = PIXI.VERSION;
BenchPixiText.framework = 'pixi';
BenchPixiText.object = 'text';
BenchPixiText.renderers = ['webgl', 'canvas'];

Bench.list.push(BenchPixiText);

function BenchStackGLCircles(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas = params.cache('webgl-stackgl');

            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stackgl.init(canvas, [1, 1, 1, 1]);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var o = stackgl.circle(d.radius, d.circleSegments, d.fillRgbaArray);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].t[0] = c.x;
                objects[i].t[1] = c.y;
            }

            stackgl.update(objects);
        },
        destroy: function () {
            stackgl.dispose();
            renderer = null;
            scene = null;
            camera = null;
        }
    };
}

BenchStackGLCircles.version = stackgl.version;
BenchStackGLCircles.framework = 'stackgl';
BenchStackGLCircles.object = 'circle';
BenchStackGLCircles.renderers = ['webgl'];

Bench.list.push(BenchStackGLCircles);

function BenchStackGLRectangles(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas = params.cache('webgl-stackgl');

            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stackgl.init(canvas, [1, 1, 1, 1]);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var o = stackgl.rectangle(d.w, d.h, d.fillRgbaArray);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].t[0] = c.x;
                objects[i].t[1] = c.y;
            }

            stackgl.update(objects);
        },
        destroy: function () {
            stackgl.dispose();
            renderer = null;
            scene = null;
            camera = null;
        }
    };
}

BenchStackGLRectangles.version = stackgl.version;
BenchStackGLRectangles.framework = 'stackgl';
BenchStackGLRectangles.object = 'rectangle';
BenchStackGLRectangles.renderers = ['webgl'];

Bench.list.push(BenchStackGLRectangles);

function BenchStackGLText(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas = params.cache('webgl-stackgl');

            canvas.width = width;
            canvas.height = height;
            container.node().appendChild(canvas);

            stackgl.init(canvas, [1, 1, 1, 1]);
            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var o = stackgl.text(d.text, d.textSize, d.fontFamily, d.fillRgbaArray);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].t[0] = c.x;
                objects[i].t[1] = c.y;
            }

            stackgl.update(objects);
        },
        destroy: function () {
            stackgl.dispose();
            renderer = null;
            scene = null;
            camera = null;
        }
    };
}

BenchStackGLText.version = stackgl.version;
BenchStackGLText.framework = 'stackgl';
BenchStackGLText.object = 'text';
BenchStackGLText.renderers = ['webgl'];

Bench.list.push(BenchStackGLText);

function BenchThreeCircles(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas;

            if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            } else if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-three');
            }

            params.renderer = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer',
                svg: 'SVGRenderer',
                css: 'CSS3DRenderer'
            }[params.renderer];

            scene = new THREE.Scene();

            var log = console.log;
            console.log = function () {
            };

            renderer = new THREE[params.renderer]({
                premultipliedAlpha: false,
                alpha: false,
                antialias: false,
                view: canvas
            });

            console.log = log;

            renderer.setClearColor(new THREE.Color(0xFFFFFF, 1.0));
            renderer.setSize(width, height);

            container.node().appendChild(renderer.domElement);

            camera = new THREE.OrthographicCamera(0, width, height, 0, 1, 1000);
            camera.position.z = 100;
            camera.lookAt(new THREE.Vector3(0, 0, 0));

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var meshMaterial = new THREE.MeshBasicMaterial({
                    color: d.fillNumber,
                    opacity: d.fillOpacity,
                    transparent: true
                });
                var o;

                if (params.renderer === 'CSS3DRenderer') {
                    var element = document.createElement('div');
                    element.style.width = (d.radius * 2) + 'px';
                    element.style.height = (d.radius * 2) + 'px';
                    element.style.background = d.fillRgba;
                    element.style.borderRadius = d.radius + 'px';
                    o = new THREE.CSS3DObject(element);
                } else {
                    o = new THREE.Mesh(new THREE.CircleGeometry(d.radius, d.circleSegments), meshMaterial);
                }

                scene.add(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(scene, camera);
        },
        destroy: function () {
            for (var i = 0; i < objects.length; i++) {
                var o = objects[i];

                if (o.geometry) {
                    o.geometry.dispose();
                }

                if (o.material) {
                    o.material.dispose();
                }

                scene.remove(o);
            }

            scene = null;
            camera = null;
            renderer = null;
        }
    };
}

BenchThreeCircles.version = THREE.REVISION;
BenchThreeCircles.framework = 'three';
BenchThreeCircles.object = 'circle';
BenchThreeCircles.renderers = ['webgl', 'canvas', 'svg', 'css'];
BenchThreeCircles.limits = {svg: 60};

Bench.list.push(BenchThreeCircles);

function BenchThreeRectangles(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas;

            if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            } else if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-three');
            }

            params.renderer = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer',
                svg: 'SVGRenderer',
                css: 'CSS3DRenderer'
            }[params.renderer];

            scene = new THREE.Scene();

            var log = console.log;
            console.log = function () {
            };

            renderer = new THREE[params.renderer]({
                premultipliedAlpha: false,
                alpha: false,
                antialias: false,
                view: canvas
            });

            console.log = log;

            renderer.setClearColor(new THREE.Color(0xFFFFFF, 1.0));
            renderer.setSize(width, height);

            container.node().appendChild(renderer.domElement);

            camera = new THREE.OrthographicCamera(0, width, height, 0, 1, 1000);
            camera.position.z = 100;
            camera.lookAt(new THREE.Vector3(0, 0, 0));

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var meshMaterial = new THREE.MeshBasicMaterial({
                    color: d.fillNumber,
                    opacity: d.fillOpacity,
                    transparent: true
                });
                var o;

                if (params.renderer === 'CSS3DRenderer') {
                    var element = document.createElement('div');
                    element.style.width = d.w + 'px';
                    element.style.height = d.h + 'px';
                    element.style.background = d.fillRgba;
                    o = new THREE.CSS3DObject(element);
                } else {
                    o = new THREE.Mesh(new THREE.PlaneGeometry(d.w, d.h, 1, 1), meshMaterial);
                }

                scene.add(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(scene, camera);
        },
        destroy: function () {
            for (var i = 0; i < objects.length; i++) {
                var o = objects[i];

                if (o.geometry) {
                    o.geometry.dispose();
                }

                if (o.material) {
                    o.material.dispose();
                }

                scene.remove(o);
            }

            scene = null;
            camera = null;
            renderer = null;
        }
    };
}

BenchThreeRectangles.version = THREE.REVISION;
BenchThreeRectangles.framework = 'three';
BenchThreeRectangles.object = 'rectangle';
BenchThreeRectangles.renderers = ['webgl', 'canvas', 'svg', 'css'];
BenchThreeRectangles.limits = {svg: 240};

Bench.list.push(BenchThreeRectangles);

function BenchThreeRounded(container, width, height, data, params) {
    var self, renderer, objects, scene, camera;

    return self = {
        init: function () {
            var canvas;

            if (params.renderer === 'canvas') {
                canvas = params.cache('2d');
            } else if (params.renderer === 'webgl') {
                canvas = params.cache('webgl-three');
            }

            params.renderer = {
                webgl: 'WebGLRenderer',
                canvas: 'CanvasRenderer',
                svg: 'SVGRenderer',
                css: 'CSS3DRenderer'
            }[params.renderer];

            scene = new THREE.Scene();

            var log = console.log;
            console.log = function () {
            };

            renderer = new THREE[params.renderer]({
                premultipliedAlpha: false,
                alpha: false,
                antialias: false,
                view: canvas
            });

            console.log = log;

            renderer.setClearColor(new THREE.Color(0xFFFFFF, 1.0));
            renderer.setSize(width, height);

            container.node().appendChild(renderer.domElement);

            camera = new THREE.OrthographicCamera(0, width, height, 0, 1, 1000);
            camera.position.z = 100;
            camera.lookAt(new THREE.Vector3(0, 0, 0));

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];
                var meshMaterial = new THREE.MeshBasicMaterial({
                    color: d.fillNumber,
                    transparent: true,
                    opacity: d.fillOpacity
                });
                var o;

                if (params.renderer === 'CSS3DRenderer') {
                    var element = document.createElement('div');
                    element.style.width = (d.w - d.lineWidth) + 'px';
                    element.style.height = (d.h - d.lineWidth) + 'px';
                    element.style.background = d.fillRgba;
                    element.style.border = d.lineWidth + 'px solid ' + d.strokeRgba;
                    element.style.borderRadius = d.cornerRadius + 'px';
                    o = new THREE.CSS3DObject(element);
                } else {
                    o = new THREE.Mesh(new THREE.PlaneGeometry(d.w, d.h, 1, 1), meshMaterial);
                }

                scene.add(o);
                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];
                objects[i].position.x = c.x;
                objects[i].position.y = c.y;
            }

            renderer.render(scene, camera);
        },
        destroy: function () {
            for (var i = 0; i < objects.length; i++) {
                var o = objects[i];

                if (o.geometry) {
                    o.geometry.dispose();
                }

                if (o.material) {
                    o.material.dispose();
                }

                scene.remove(o);
            }

            scene = null;
            camera = null;
            renderer = null;
        }
    };
}

BenchThreeRounded.version = THREE.REVISION;
BenchThreeRounded.framework = 'three';
BenchThreeRounded.object = 'rounded';
BenchThreeRounded.renderers = ['css'];

Bench.list.push(BenchThreeRounded);

function BenchTwoCircles(container, width, height, data, params) {
    var self, renderer, objects;

    return self = {
        init: function () {
            renderer = Two.Instances.filter(function (d) {
                return {webgl: 'WebGLRenderer', canvas: 'CanvasRenderer'}[params.renderer] === d.type;
            })[0];

            renderer = renderer || new Two({
                    type: Two.Types[params.renderer],
                    width: width,
                    height: height
                });

            renderer.appendTo(container.node());

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = renderer.makeCircle(0, 0, d.radius);

                o.fill = d.fillRgba;
                o.noStroke();

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].translation.set(c.x, c.y);
            }

            renderer.update();
        },
        destroy: function () {
            objects = null;
            renderer.clear();

            if (params.renderer === 'svg') {
                Two.Instances.pop();
            } else {
                // Garbage leftovers?
                renderer.scene.subtractions.splice(0);
            }

            renderer = null;
        }
    };
}

BenchTwoCircles.version = Two.Version.replace('v', '');
BenchTwoCircles.framework = 'two';
BenchTwoCircles.object = 'circle';
BenchTwoCircles.renderers = ['webgl', 'canvas', 'svg'];
BenchTwoCircles.limits = {webgl: 720, canvas: 720, svg: 720};

Bench.list.push(BenchTwoCircles);

function BenchTwoRectangles(container, width, height, data, params) {
    var self, renderer, objects;

    return self = {
        init: function () {
            renderer = Two.Instances.filter(function (d) {
                return {webgl: 'WebGLRenderer', canvas: 'CanvasRenderer'}[params.renderer] === d.type;
            })[0];

            renderer = renderer || new Two({
                    type: Two.Types[params.renderer],
                    width: width,
                    height: height
                });

            renderer.appendTo(container.node());

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = renderer.makeRectangle(0, 0, d.w, d.h);

                o.fill = d.fillRgba;
                o.noStroke();

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].translation.set(c.x, c.y);
            }

            renderer.update();
        },
        destroy: function () {
            objects = null;
            renderer.clear();

            if (params.renderer === 'svg') {
                Two.Instances.pop();
            } else {
                // Garbage leftovers?
                renderer.scene.subtractions.splice(0);
            }

            renderer = null;
        }
    };
}

BenchTwoRectangles.version = Two.Version.replace('v', '');
BenchTwoRectangles.framework = 'two';
BenchTwoRectangles.object = 'rectangle';
BenchTwoRectangles.renderers = ['webgl', 'canvas', 'svg'];
BenchTwoRectangles.limits = {webgl: 720, canvas: 720, svg: 720};

Bench.list.push(BenchTwoRectangles);

function BenchTwoRounded(container, width, height, data, params) {
    var self, renderer, objects;

    return self = {
        init: function () {
            renderer = Two.Instances.filter(function (d) {
                return {webgl: 'WebGLRenderer', canvas: 'CanvasRenderer'}[params.renderer] === d.type;
            })[0];

            renderer = renderer || new Two({
                    type: Two.Types[params.renderer],
                    width: width,
                    height: height
                });

            renderer.appendTo(container.node());

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = renderer.makeRoundedRectangle(0, 0, d.w, d.h, d.cornerRadius);

                o.fill = d.fillRgba;
                o.stroke = d.strokeRgba;
                o.linewidth = d.lineWidth;

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].translation.set(c.x, c.y);
            }

            renderer.update();
        },
        destroy: function () {
            objects = null;
            renderer.clear();

            if (params.renderer === 'svg') {
                Two.Instances.pop();
            } else {
                // Garbage leftovers?
                renderer.scene.subtractions.splice(0);
            }

            renderer = null;
        }
    };
}

BenchTwoRounded.version = Two.Version.replace('v', '');
BenchTwoRounded.framework = 'two';
BenchTwoRounded.object = 'rounded';
BenchTwoRounded.renderers = ['webgl', 'canvas', 'svg'];
BenchTwoRounded.limits = {webgl: 720, canvas: 720, svg: 720};

Bench.list.push(BenchTwoRounded);

function BenchTwoTriangles(container, width, height, data, params) {
    var self, renderer, objects;

    return self = {
        init: function () {
            renderer = Two.Instances.filter(function (d) {
                return {webgl: 'WebGLRenderer', canvas: 'CanvasRenderer'}[params.renderer] === d.type;
            })[0];

            renderer = renderer || new Two({
                    type: Two.Types[params.renderer],
                    width: width,
                    height: height
                });

            renderer.appendTo(container.node());

            objects = [];

            for (var i = 0; i < data.length; i++) {
                var d = data[i];

                var o = renderer.makePolygon(0, 0, d.triangleRadius);

                o.fill = d.fillRgba;
                o.noStroke();

                objects.push(o);
            }

            self.update();
        },
        update: function () {
            for (var i = 0; i < data.length; i++) {
                var c = data[i];

                objects[i].translation.set(c.x, c.y);
            }

            renderer.update();
        },
        destroy: function () {
            objects = null;
            renderer.clear();

            if (params.renderer === 'svg') {
                Two.Instances.pop();
            } else {
                // Garbage leftovers?
                renderer.scene.subtractions.splice(0);
            }

            renderer = null;
        }
    };
}

BenchTwoTriangles.version = Two.Version.replace('v', '');
BenchTwoTriangles.framework = 'two';
BenchTwoTriangles.object = 'triangle';
BenchTwoTriangles.renderers = ['webgl', 'canvas', 'svg'];
BenchTwoTriangles.limits = {webgl: -1, canvas: -1, svg: -1};

Bench.list.push(BenchTwoTriangles);