Merge pull request #14126 from mapbox/gfx-refactor-4

Graphics refactor #4

153 files changed, 2390 insertions, 2499 deletions

diff --git a/src/core-files.json b/src/core-files.json
index 6415f03182..272faaf9b6 100644
--- a/src/core-files.json
+++ b/src/core-files.json
@@ -16,7 +16,9 @@
         "src/mbgl/geometry/dem_data.cpp",
         "src/mbgl/geometry/feature_index.cpp",
         "src/mbgl/geometry/line_atlas.cpp",
+        "src/mbgl/gfx/attribute.cpp",
         "src/mbgl/gl/attribute.cpp",
+        "src/mbgl/gl/binary_program.cpp",
         "src/mbgl/gl/context.cpp",
         "src/mbgl/gl/debugging.cpp",
         "src/mbgl/gl/debugging_extension.cpp",
@@ -51,12 +53,42 @@
         "src/mbgl/math/log2.cpp",
         "src/mbgl/platform/gl_functions.cpp",
         "src/mbgl/programs/background_program.cpp",
-        "src/mbgl/programs/binary_program.cpp",
         "src/mbgl/programs/circle_program.cpp",
+        "src/mbgl/programs/clipping_mask_program.cpp",
         "src/mbgl/programs/collision_box_program.cpp",
+        "src/mbgl/programs/debug_program.cpp",
         "src/mbgl/programs/extrusion_texture_program.cpp",
         "src/mbgl/programs/fill_extrusion_program.cpp",
         "src/mbgl/programs/fill_program.cpp",
+        "src/mbgl/programs/gl/background.cpp",
+        "src/mbgl/programs/gl/background_pattern.cpp",
+        "src/mbgl/programs/gl/circle.cpp",
+        "src/mbgl/programs/gl/clipping_mask.cpp",
+        "src/mbgl/programs/gl/collision_box.cpp",
+        "src/mbgl/programs/gl/collision_circle.cpp",
+        "src/mbgl/programs/gl/debug.cpp",
+        "src/mbgl/programs/gl/extrusion_texture.cpp",
+        "src/mbgl/programs/gl/fill.cpp",
+        "src/mbgl/programs/gl/fill_extrusion.cpp",
+        "src/mbgl/programs/gl/fill_extrusion_pattern.cpp",
+        "src/mbgl/programs/gl/fill_outline.cpp",
+        "src/mbgl/programs/gl/fill_outline_pattern.cpp",
+        "src/mbgl/programs/gl/fill_pattern.cpp",
+        "src/mbgl/programs/gl/heatmap.cpp",
+        "src/mbgl/programs/gl/heatmap_texture.cpp",
+        "src/mbgl/programs/gl/hillshade.cpp",
+        "src/mbgl/programs/gl/hillshade_prepare.cpp",
+        "src/mbgl/programs/gl/line.cpp",
+        "src/mbgl/programs/gl/line_gradient.cpp",
+        "src/mbgl/programs/gl/line_pattern.cpp",
+        "src/mbgl/programs/gl/line_sdf.cpp",
+        "src/mbgl/programs/gl/preludes.cpp",
+        "src/mbgl/programs/gl/raster.cpp",
+        "src/mbgl/programs/gl/shader_source.cpp",
+        "src/mbgl/programs/gl/shaders.cpp",
+        "src/mbgl/programs/gl/symbol_icon.cpp",
+        "src/mbgl/programs/gl/symbol_sdf_icon.cpp",
+        "src/mbgl/programs/gl/symbol_sdf_text.cpp",
         "src/mbgl/programs/heatmap_program.cpp",
         "src/mbgl/programs/heatmap_texture_program.cpp",
         "src/mbgl/programs/hillshade_prepare_program.cpp",
@@ -109,34 +141,6 @@
         "src/mbgl/renderer/sources/render_vector_source.cpp",
         "src/mbgl/renderer/style_diff.cpp",
         "src/mbgl/renderer/tile_pyramid.cpp",
-        "src/mbgl/shaders/background.cpp",
-        "src/mbgl/shaders/background_pattern.cpp",
-        "src/mbgl/shaders/circle.cpp",
-        "src/mbgl/shaders/clipping_mask.cpp",
-        "src/mbgl/shaders/collision_box.cpp",
-        "src/mbgl/shaders/collision_circle.cpp",
-        "src/mbgl/shaders/debug.cpp",
-        "src/mbgl/shaders/extrusion_texture.cpp",
-        "src/mbgl/shaders/fill.cpp",
-        "src/mbgl/shaders/fill_extrusion.cpp",
-        "src/mbgl/shaders/fill_extrusion_pattern.cpp",
-        "src/mbgl/shaders/fill_outline.cpp",
-        "src/mbgl/shaders/fill_outline_pattern.cpp",
-        "src/mbgl/shaders/fill_pattern.cpp",
-        "src/mbgl/shaders/heatmap.cpp",
-        "src/mbgl/shaders/heatmap_texture.cpp",
-        "src/mbgl/shaders/hillshade.cpp",
-        "src/mbgl/shaders/hillshade_prepare.cpp",
-        "src/mbgl/shaders/line.cpp",
-        "src/mbgl/shaders/line_gradient.cpp",
-        "src/mbgl/shaders/line_pattern.cpp",
-        "src/mbgl/shaders/line_sdf.cpp",
-        "src/mbgl/shaders/preludes.cpp",
-        "src/mbgl/shaders/raster.cpp",
-        "src/mbgl/shaders/shaders.cpp",
-        "src/mbgl/shaders/source.cpp",
-        "src/mbgl/shaders/symbol_icon.cpp",
-        "src/mbgl/shaders/symbol_sdf.cpp",
         "src/mbgl/sprite/sprite_loader.cpp",
         "src/mbgl/sprite/sprite_loader_worker.cpp",
         "src/mbgl/sprite/sprite_parser.cpp",
@@ -505,12 +509,14 @@
         "mbgl/gfx/attribute.hpp": "src/mbgl/gfx/attribute.hpp",
         "mbgl/gfx/color_mode.hpp": "src/mbgl/gfx/color_mode.hpp",
         "mbgl/gfx/context.hpp": "src/mbgl/gfx/context.hpp",
+        "mbgl/gfx/context_impl.hpp": "src/mbgl/gfx/context_impl.hpp",
         "mbgl/gfx/cull_face_mode.hpp": "src/mbgl/gfx/cull_face_mode.hpp",
         "mbgl/gfx/depth_mode.hpp": "src/mbgl/gfx/depth_mode.hpp",
         "mbgl/gfx/draw_mode.hpp": "src/mbgl/gfx/draw_mode.hpp",
+        "mbgl/gfx/draw_scope.hpp": "src/mbgl/gfx/draw_scope.hpp",
         "mbgl/gfx/index_buffer.hpp": "src/mbgl/gfx/index_buffer.hpp",
         "mbgl/gfx/index_vector.hpp": "src/mbgl/gfx/index_vector.hpp",
-        "mbgl/gfx/primitives.hpp": "src/mbgl/gfx/primitives.hpp",
+        "mbgl/gfx/program.hpp": "src/mbgl/gfx/program.hpp",
         "mbgl/gfx/stencil_mode.hpp": "src/mbgl/gfx/stencil_mode.hpp",
         "mbgl/gfx/texture.hpp": "src/mbgl/gfx/texture.hpp",
         "mbgl/gfx/types.hpp": "src/mbgl/gfx/types.hpp",
@@ -518,10 +524,12 @@
         "mbgl/gfx/vertex_buffer.hpp": "src/mbgl/gfx/vertex_buffer.hpp",
         "mbgl/gfx/vertex_vector.hpp": "src/mbgl/gfx/vertex_vector.hpp",
         "mbgl/gl/attribute.hpp": "src/mbgl/gl/attribute.hpp",
+        "mbgl/gl/binary_program.hpp": "src/mbgl/gl/binary_program.hpp",
         "mbgl/gl/context.hpp": "src/mbgl/gl/context.hpp",
         "mbgl/gl/debugging.hpp": "src/mbgl/gl/debugging.hpp",
         "mbgl/gl/debugging_extension.hpp": "src/mbgl/gl/debugging_extension.hpp",
         "mbgl/gl/defines.hpp": "src/mbgl/gl/defines.hpp",
+        "mbgl/gl/draw_scope_resource.hpp": "src/mbgl/gl/draw_scope_resource.hpp",
         "mbgl/gl/enum.hpp": "src/mbgl/gl/enum.hpp",
         "mbgl/gl/extension.hpp": "src/mbgl/gl/extension.hpp",
         "mbgl/gl/features.hpp": "src/mbgl/gl/features.hpp",
@@ -553,26 +561,40 @@
         "mbgl/map/transform_state.hpp": "src/mbgl/map/transform_state.hpp",
         "mbgl/map/zoom_history.hpp": "src/mbgl/map/zoom_history.hpp",
         "mbgl/programs/attributes.hpp": "src/mbgl/programs/attributes.hpp",
+        "mbgl/programs/background_pattern_program.hpp": "src/mbgl/programs/background_pattern_program.hpp",
         "mbgl/programs/background_program.hpp": "src/mbgl/programs/background_program.hpp",
-        "mbgl/programs/binary_program.hpp": "src/mbgl/programs/binary_program.hpp",
         "mbgl/programs/circle_program.hpp": "src/mbgl/programs/circle_program.hpp",
         "mbgl/programs/clipping_mask_program.hpp": "src/mbgl/programs/clipping_mask_program.hpp",
         "mbgl/programs/collision_box_program.hpp": "src/mbgl/programs/collision_box_program.hpp",
+        "mbgl/programs/collision_circle_program.hpp": "src/mbgl/programs/collision_circle_program.hpp",
         "mbgl/programs/debug_program.hpp": "src/mbgl/programs/debug_program.hpp",
         "mbgl/programs/extrusion_texture_program.hpp": "src/mbgl/programs/extrusion_texture_program.hpp",
+        "mbgl/programs/fill_extrusion_pattern_program.hpp": "src/mbgl/programs/fill_extrusion_pattern_program.hpp",
         "mbgl/programs/fill_extrusion_program.hpp": "src/mbgl/programs/fill_extrusion_program.hpp",
+        "mbgl/programs/fill_outline_pattern_program.hpp": "src/mbgl/programs/fill_outline_pattern_program.hpp",
+        "mbgl/programs/fill_outline_program.hpp": "src/mbgl/programs/fill_outline_program.hpp",
+        "mbgl/programs/fill_pattern_program.hpp": "src/mbgl/programs/fill_pattern_program.hpp",
         "mbgl/programs/fill_program.hpp": "src/mbgl/programs/fill_program.hpp",
+        "mbgl/programs/gl/preludes.hpp": "src/mbgl/programs/gl/preludes.hpp",
+        "mbgl/programs/gl/shader_source.hpp": "src/mbgl/programs/gl/shader_source.hpp",
+        "mbgl/programs/gl/shaders.hpp": "src/mbgl/programs/gl/shaders.hpp",
         "mbgl/programs/heatmap_program.hpp": "src/mbgl/programs/heatmap_program.hpp",
         "mbgl/programs/heatmap_texture_program.hpp": "src/mbgl/programs/heatmap_texture_program.hpp",
         "mbgl/programs/hillshade_prepare_program.hpp": "src/mbgl/programs/hillshade_prepare_program.hpp",
         "mbgl/programs/hillshade_program.hpp": "src/mbgl/programs/hillshade_program.hpp",
+        "mbgl/programs/line_gradient_program.hpp": "src/mbgl/programs/line_gradient_program.hpp",
+        "mbgl/programs/line_pattern_program.hpp": "src/mbgl/programs/line_pattern_program.hpp",
         "mbgl/programs/line_program.hpp": "src/mbgl/programs/line_program.hpp",
+        "mbgl/programs/line_sdf_program.hpp": "src/mbgl/programs/line_sdf_program.hpp",
         "mbgl/programs/program.hpp": "src/mbgl/programs/program.hpp",
         "mbgl/programs/program_parameters.hpp": "src/mbgl/programs/program_parameters.hpp",
         "mbgl/programs/programs.hpp": "src/mbgl/programs/programs.hpp",
         "mbgl/programs/raster_program.hpp": "src/mbgl/programs/raster_program.hpp",
         "mbgl/programs/segment.hpp": "src/mbgl/programs/segment.hpp",
+        "mbgl/programs/symbol_icon_program.hpp": "src/mbgl/programs/symbol_icon_program.hpp",
         "mbgl/programs/symbol_program.hpp": "src/mbgl/programs/symbol_program.hpp",
+        "mbgl/programs/symbol_sdf_icon_program.hpp": "src/mbgl/programs/symbol_sdf_icon_program.hpp",
+        "mbgl/programs/symbol_sdf_text_program.hpp": "src/mbgl/programs/symbol_sdf_text_program.hpp",
         "mbgl/programs/textures.hpp": "src/mbgl/programs/textures.hpp",
         "mbgl/programs/uniforms.hpp": "src/mbgl/programs/uniforms.hpp",
         "mbgl/renderer/bucket.hpp": "src/mbgl/renderer/bucket.hpp",
@@ -628,34 +650,6 @@
         "mbgl/renderer/tile_pyramid.hpp": "src/mbgl/renderer/tile_pyramid.hpp",
         "mbgl/renderer/transition_parameters.hpp": "src/mbgl/renderer/transition_parameters.hpp",
         "mbgl/renderer/update_parameters.hpp": "src/mbgl/renderer/update_parameters.hpp",
-        "mbgl/shaders/background.hpp": "src/mbgl/shaders/background.hpp",
-        "mbgl/shaders/background_pattern.hpp": "src/mbgl/shaders/background_pattern.hpp",
-        "mbgl/shaders/circle.hpp": "src/mbgl/shaders/circle.hpp",
-        "mbgl/shaders/clipping_mask.hpp": "src/mbgl/shaders/clipping_mask.hpp",
-        "mbgl/shaders/collision_box.hpp": "src/mbgl/shaders/collision_box.hpp",
-        "mbgl/shaders/collision_circle.hpp": "src/mbgl/shaders/collision_circle.hpp",
-        "mbgl/shaders/debug.hpp": "src/mbgl/shaders/debug.hpp",
-        "mbgl/shaders/extrusion_texture.hpp": "src/mbgl/shaders/extrusion_texture.hpp",
-        "mbgl/shaders/fill.hpp": "src/mbgl/shaders/fill.hpp",
-        "mbgl/shaders/fill_extrusion.hpp": "src/mbgl/shaders/fill_extrusion.hpp",
-        "mbgl/shaders/fill_extrusion_pattern.hpp": "src/mbgl/shaders/fill_extrusion_pattern.hpp",
-        "mbgl/shaders/fill_outline.hpp": "src/mbgl/shaders/fill_outline.hpp",
-        "mbgl/shaders/fill_outline_pattern.hpp": "src/mbgl/shaders/fill_outline_pattern.hpp",
-        "mbgl/shaders/fill_pattern.hpp": "src/mbgl/shaders/fill_pattern.hpp",
-        "mbgl/shaders/heatmap.hpp": "src/mbgl/shaders/heatmap.hpp",
-        "mbgl/shaders/heatmap_texture.hpp": "src/mbgl/shaders/heatmap_texture.hpp",
-        "mbgl/shaders/hillshade.hpp": "src/mbgl/shaders/hillshade.hpp",
-        "mbgl/shaders/hillshade_prepare.hpp": "src/mbgl/shaders/hillshade_prepare.hpp",
-        "mbgl/shaders/line.hpp": "src/mbgl/shaders/line.hpp",
-        "mbgl/shaders/line_gradient.hpp": "src/mbgl/shaders/line_gradient.hpp",
-        "mbgl/shaders/line_pattern.hpp": "src/mbgl/shaders/line_pattern.hpp",
-        "mbgl/shaders/line_sdf.hpp": "src/mbgl/shaders/line_sdf.hpp",
-        "mbgl/shaders/preludes.hpp": "src/mbgl/shaders/preludes.hpp",
-        "mbgl/shaders/raster.hpp": "src/mbgl/shaders/raster.hpp",
-        "mbgl/shaders/shaders.hpp": "src/mbgl/shaders/shaders.hpp",
-        "mbgl/shaders/source.hpp": "src/mbgl/shaders/source.hpp",
-        "mbgl/shaders/symbol_icon.hpp": "src/mbgl/shaders/symbol_icon.hpp",
-        "mbgl/shaders/symbol_sdf.hpp": "src/mbgl/shaders/symbol_sdf.hpp",
         "mbgl/sprite/sprite_loader.hpp": "src/mbgl/sprite/sprite_loader.hpp",
         "mbgl/sprite/sprite_loader_observer.hpp": "src/mbgl/sprite/sprite_loader_observer.hpp",
         "mbgl/sprite/sprite_loader_worker.hpp": "src/mbgl/sprite/sprite_loader_worker.hpp",
diff --git a/src/mbgl/gfx/attribute.cpp b/src/mbgl/gfx/attribute.cpp
new file mode 100644
index 0000000000..ed5d4032f4
--- /dev/null
+++ b/src/mbgl/gfx/attribute.cpp
@@ -0,0 +1,21 @@
+#include <mbgl/gfx/attribute.hpp>
+
+#include <limits>
+#include <cassert>
+
+namespace mbgl {
+namespace gfx {
+
+optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset) {
+    assert(vertexOffset <= std::numeric_limits<uint32_t>::max());
+    if (binding) {
+        AttributeBinding result = *binding;
+        result.vertexOffset = static_cast<uint32_t>(vertexOffset);
+        return result;
+    } else {
+        return binding;
+    }
+}
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/src/mbgl/gfx/attribute.hpp b/src/mbgl/gfx/attribute.hpp
index 0dce6b2a06..4f44d68d7b 100644
--- a/src/mbgl/gfx/attribute.hpp
+++ b/src/mbgl/gfx/attribute.hpp
@@ -1,8 +1,11 @@
 #pragma once
 
 #include <mbgl/gfx/types.hpp>
+#include <mbgl/gfx/vertex_buffer.hpp>
 #include <mbgl/util/type_list.hpp>
 #include <mbgl/util/indexed_tuple.hpp>
+#include <mbgl/util/ignore.hpp>
+#include <mbgl/util/optional.hpp>
 
 #include <array>
 #include <type_traits>
@@ -79,6 +82,21 @@ struct VertexDescriptor {
     AttributeDescriptor attributes[5];
 };
 
+class AttributeBinding {
+public:
+    AttributeDescriptor attribute;
+    uint8_t vertexStride;
+    const VertexBufferResource* vertexBufferResource;
+    uint32_t vertexOffset;
+
+    friend bool operator==(const AttributeBinding& lhs, const AttributeBinding& rhs) {
+        return lhs.attribute == rhs.attribute &&
+               lhs.vertexStride == rhs.vertexStride &&
+               lhs.vertexBufferResource == rhs.vertexBufferResource &&
+               lhs.vertexOffset == rhs.vertexOffset;
+    }
+};
+
 // Attribute binding requires member offsets. The only standard way to
 // obtain an offset is the offsetof macro. The offsetof macro has defined
 // behavior only for standard layout types. That rules out std::tuple and
@@ -89,32 +107,32 @@ struct VertexDescriptor {
 namespace detail {
 
 template <class...>
-struct Vertex;
+struct VertexType;
 
 template <class A1>
-struct Vertex<A1> {
-    using Type = Vertex<A1>;
+struct VertexType<A1> {
+    using Type = VertexType<A1>;
     typename A1::Value a1;
 } MBGL_VERTEX_ALIGN;
 
 template <class A1, class A2>
-struct Vertex<A1, A2> {
-    using Type = Vertex<A1, A2>;
+struct VertexType<A1, A2> {
+    using Type = VertexType<A1, A2>;
     typename A1::Value a1;
     typename A2::Value a2;
 } MBGL_VERTEX_ALIGN;
 
 template <class A1, class A2, class A3>
-struct Vertex<A1, A2, A3> {
-    using Type = Vertex<A1, A2, A3>;
+struct VertexType<A1, A2, A3> {
+    using Type = VertexType<A1, A2, A3>;
     typename A1::Value a1;
     typename A2::Value a2;
     typename A3::Value a3;
 } MBGL_VERTEX_ALIGN;
 
 template <class A1, class A2, class A3, class A4>
-struct Vertex<A1, A2, A3, A4> {
-    using Type = Vertex<A1, A2, A3, A4>;
+struct VertexType<A1, A2, A3, A4> {
+    using Type = VertexType<A1, A2, A3, A4>;
     typename A1::Value a1;
     typename A2::Value a2;
     typename A3::Value a3;
@@ -122,8 +140,8 @@ struct Vertex<A1, A2, A3, A4> {
 } MBGL_VERTEX_ALIGN;
 
 template <class A1, class A2, class A3, class A4, class A5>
-struct Vertex<A1, A2, A3, A4, A5> {
-    using Type = Vertex<A1, A2, A3, A4, A5>;
+struct VertexType<A1, A2, A3, A4, A5> {
+    using Type = VertexType<A1, A2, A3, A4, A5>;
     typename A1::Value a1;
     typename A2::Value a2;
     typename A3::Value a3;
@@ -135,8 +153,8 @@ template <class>
 struct Descriptor;
 
 template <class A1>
-struct Descriptor<Vertex<A1>> {
-    using Type = Vertex<A1>;
+struct Descriptor<VertexType<A1>> {
+    using Type = VertexType<A1>;
     static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes");
     static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout");
     static constexpr const VertexDescriptor data = { sizeof(Type), 1, {
@@ -145,11 +163,11 @@ struct Descriptor<Vertex<A1>> {
 };
 
 template <class A1>
-constexpr const VertexDescriptor Descriptor<Vertex<A1>>::data;
+constexpr const VertexDescriptor Descriptor<VertexType<A1>>::data;
 
 template <class A1, class A2>
-struct Descriptor<Vertex<A1, A2>> {
-    using Type = Vertex<A1, A2>;
+struct Descriptor<VertexType<A1, A2>> {
+    using Type = VertexType<A1, A2>;
     static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes");
     static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout");
     static constexpr const VertexDescriptor data = { sizeof(Type), 2, {
@@ -159,11 +177,11 @@ struct Descriptor<Vertex<A1, A2>> {
 };
 
 template <class A1, class A2>
-constexpr const VertexDescriptor Descriptor<Vertex<A1, A2>>::data;
+constexpr const VertexDescriptor Descriptor<VertexType<A1, A2>>::data;
 
 template <class A1, class A2, class A3>
-struct Descriptor<Vertex<A1, A2, A3>> {
-    using Type = Vertex<A1, A2, A3>;
+struct Descriptor<VertexType<A1, A2, A3>> {
+    using Type = VertexType<A1, A2, A3>;
     static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes");
     static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout");
     static constexpr const VertexDescriptor data = { sizeof(Type), 3, {
@@ -174,11 +192,11 @@ struct Descriptor<Vertex<A1, A2, A3>> {
 };
 
 template <class A1, class A2, class A3>
-constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3>>::data;
+constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3>>::data;
 
 template <class A1, class A2, class A3, class A4>
-struct Descriptor<Vertex<A1, A2, A3, A4>> {
-    using Type = Vertex<A1, A2, A3, A4>;
+struct Descriptor<VertexType<A1, A2, A3, A4>> {
+    using Type = VertexType<A1, A2, A3, A4>;
     static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes");
     static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout");
     static constexpr const VertexDescriptor data = { sizeof(Type), 4, {
@@ -190,11 +208,11 @@ struct Descriptor<Vertex<A1, A2, A3, A4>> {
 };
 
 template <class A1, class A2, class A3, class A4>
-constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3, A4>>::data;
+constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3, A4>>::data;
 
 template <class A1, class A2, class A3, class A4, class A5>
-struct Descriptor<Vertex<A1, A2, A3, A4, A5>> {
-    using Type = Vertex<A1, A2, A3, A4, A5>;
+struct Descriptor<VertexType<A1, A2, A3, A4, A5>> {
+    using Type = VertexType<A1, A2, A3, A4, A5>;
     static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes");
     static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout");
     static constexpr const VertexDescriptor data = { sizeof(Type), 5, {
@@ -207,11 +225,14 @@ struct Descriptor<Vertex<A1, A2, A3, A4, A5>> {
 };
 
 template <class A1, class A2, class A3, class A4, class A5>
-constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3, A4, A5>>::data;
+constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3, A4, A5>>::data;
+
+template <class>
+struct Vertex;
 
 template <class... As>
 struct Vertex<TypeList<As...>> {
-    using Type = Vertex<typename As::Type...>;
+    using Type = VertexType<typename As::Type...>;
 };
 
 } // namespace detail
@@ -219,8 +240,52 @@ struct Vertex<TypeList<As...>> {
 template <class A>
 using Vertex = typename detail::Vertex<A>::Type;
 
-template <class V>
-using VertexDescriptorOf = detail::Descriptor<V>;
+template <class T>
+using VertexType = typename detail::VertexType<T>;
+
+template <size_t I = 0, class... As>
+AttributeBinding attributeBinding(const VertexBuffer<detail::VertexType<As...>>& buffer) {
+    using Descriptor = detail::Descriptor<detail::VertexType<As...>>;
+    static_assert(I < Descriptor::data.count, "attribute index must be in range");
+    return {
+        Descriptor::data.attributes[I],
+        Descriptor::data.stride,
+        buffer.resource.get(),
+        0,
+    };
+}
+
+optional<gfx::AttributeBinding> offsetAttributeBinding(const optional<gfx::AttributeBinding>& binding, std::size_t vertexOffset);
+
+template <class>
+class AttributeBindings;
+
+template <class... As>
+class AttributeBindings<TypeList<As...>> final
+    : public IndexedTuple<TypeList<As...>,
+                          TypeList<ExpandToType<As, optional<AttributeBinding>>...>> {
+    using Base = IndexedTuple<TypeList<As...>,
+                          TypeList<ExpandToType<As, optional<AttributeBinding>>...>>;
+
+public:
+    AttributeBindings(const VertexBuffer<Vertex<TypeList<As...>>>& buffer)
+        : Base{ attributeBinding<TypeIndex<As, As...>::value>(buffer)... } {
+    }
+
+    template <class... Args>
+    AttributeBindings(Args&&... args) : Base(std::forward<Args>(args)...) {
+    }
+
+    AttributeBindings offset(const std::size_t vertexOffset) const {
+        return { offsetAttributeBinding(Base::template get<As>(), vertexOffset)... };
+    }
+
+    uint32_t activeCount() const {
+        uint32_t result = 0;
+        util::ignore({ ((result += bool(Base::template get<As>())), 0)... });
+        return result;
+    }
+};
 
 } // namespace gfx
 } // namespace mbgl
diff --git a/src/mbgl/gfx/context.hpp b/src/mbgl/gfx/context.hpp
index 5ec73b8a41..90b62c94a4 100644
--- a/src/mbgl/gfx/context.hpp
+++ b/src/mbgl/gfx/context.hpp
@@ -5,14 +5,22 @@
 #include <mbgl/gfx/index_vector.hpp>
 #include <mbgl/gfx/index_buffer.hpp>
 #include <mbgl/gfx/texture.hpp>
+#include <mbgl/gfx/draw_scope.hpp>
+#include <mbgl/gfx/program.hpp>
 #include <mbgl/gfx/types.hpp>
 
 namespace mbgl {
+
+class ProgramParameters;
+
 namespace gfx {
 
 class Context {
 protected:
-    Context() = default;
+    Context(ContextType type_) : backend(type_) {
+    }
+
+    const ContextType backend;
 
 public:
     Context(Context&&) = delete;
@@ -89,6 +97,22 @@ protected:
         Size, const void* data, TexturePixelType, TextureChannelDataType) = 0;
     virtual void updateTextureResource(const TextureResource&, Size, const void* data,
         TexturePixelType, TextureChannelDataType) = 0;
+
+public:
+    DrawScope createDrawScope() {
+        return { createDrawScopeResource() };
+    }
+
+protected:
+    virtual std::unique_ptr<DrawScopeResource> createDrawScopeResource() = 0;
+
+public:
+    template <typename Name>
+    std::unique_ptr<Program<Name>> createProgram(const ProgramParameters&);
+
+private:
+    template <typename Backend, typename Name>
+    std::unique_ptr<Program<Name>> createProgram(const ProgramParameters&);
 };
 
 } // namespace gfx
diff --git a/src/mbgl/gfx/context_impl.hpp b/src/mbgl/gfx/context_impl.hpp
new file mode 100644
index 0000000000..0145535bb3
--- /dev/null
+++ b/src/mbgl/gfx/context_impl.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <mbgl/gfx/context.hpp>
+
+namespace mbgl {
+
+namespace gl {
+class Context;
+} // namespace gl
+
+namespace gfx {
+
+template <typename Name>
+std::unique_ptr<Program<Name>> Context::createProgram(const ProgramParameters& programParameters) {
+    if (backend == ContextType::OpenGL) {
+        return createProgram<gl::Context, Name>(programParameters);
+    }
+    assert(false);
+    return nullptr;
+}
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/src/mbgl/gfx/draw_mode.hpp b/src/mbgl/gfx/draw_mode.hpp
index a0a9b6c575..e18a38903e 100644
--- a/src/mbgl/gfx/draw_mode.hpp
+++ b/src/mbgl/gfx/draw_mode.hpp
@@ -1,72 +1,77 @@
 #pragma once
 
 #include <mbgl/gfx/types.hpp>
-#include <mbgl/gfx/primitives.hpp>
 
 #include <cassert>
 
 namespace mbgl {
 namespace gfx {
 
-class Points {
-public:
-    using Primitive = Point;
-
-    static constexpr std::size_t bufferGroupSize = 1;
-    static constexpr PrimitiveType primitiveType = PrimitiveType::Points;
-
-    explicit Points(float pointSize_) : pointSize(pointSize_) {}
-
-    float pointSize;
-};
+class DrawMode {
+protected:
+    DrawMode(DrawModeType type_, float size_)
+        : type(type_), size(size_) {
+    }
 
-class Lines {
 public:
-    using Primitive = Line;
+    const DrawModeType type;
+    const float size;
+};
 
-    static constexpr std::size_t bufferGroupSize = 2;
-    static constexpr PrimitiveType primitiveType = PrimitiveType::Lines;
+template <class> struct BufferGroupSizeOf;
+template <class> struct PrimitiveTypeOf;
 
-    explicit Lines(float lineWidth_) : lineWidth(lineWidth_) {
-        assert(lineWidth > 0);
+class Points : public DrawMode {
+public:
+    explicit Points(float pointSize_) : DrawMode(DrawModeType::Points, pointSize_) {
+        assert(size > 0);
     }
-
-    float lineWidth;
 };
 
-class LineStrip {
+template <> struct BufferGroupSizeOf<Points> : std::integral_constant<std::size_t, 1> {};
+template <> struct PrimitiveTypeOf<Points> : std::integral_constant<PrimitiveType, PrimitiveType::Point> {};
+
+class Lines : public DrawMode {
 public:
-    // LineStrip is a form of "Line" rendering, but the element buffer
-    // cannot be grouped into logical elements beyond a single Point.
-    using Primitive = Line;
+    explicit Lines(float lineWidth_) : DrawMode(DrawModeType::Lines, lineWidth_) {
+        assert(size > 0);
+    }
+};
 
-    static constexpr std::size_t bufferGroupSize = 1;
-    static constexpr PrimitiveType primitiveType = PrimitiveType::LineStrip;
+template <> struct BufferGroupSizeOf<Lines> : std::integral_constant<std::size_t, 2> {};
+template <> struct PrimitiveTypeOf<Lines> : std::integral_constant<PrimitiveType, PrimitiveType::Line> {};
 
-    explicit LineStrip(float lineWidth_) : lineWidth(lineWidth_) {
-        assert(lineWidth > 0);
+// LineStrip is a form of "Line" rendering, but the element buffer
+// cannot be grouped into logical elements beyond a single Point.
+class LineStrip : public DrawMode {
+public:
+    explicit LineStrip(float lineWidth_) : DrawMode(DrawModeType::LineStrip, lineWidth_) {
+        assert(size > 0);
     }
-
-    float lineWidth;
 };
 
-class Triangles {
-public:
-    using Primitive = Triangle;
+template <> struct BufferGroupSizeOf<LineStrip> : std::integral_constant<std::size_t, 1> {};
+template <> struct PrimitiveTypeOf<LineStrip> : std::integral_constant<PrimitiveType, PrimitiveType::Line> {};
 
-    static constexpr std::size_t bufferGroupSize = 3;
-    static constexpr PrimitiveType primitiveType = PrimitiveType::Triangles;
+class Triangles : public DrawMode {
+public:
+    explicit Triangles() : DrawMode(DrawModeType::Triangles, 0) {
+    }
 };
 
-class TriangleStrip {
-public:
-    // TriangleStrip is a form of "Triangle" rendering, but the element buffer
-    // cannot be grouped into logical elements beyond a single Point.
-    using Primitive = Triangle;
+template <> struct BufferGroupSizeOf<Triangles> : std::integral_constant<std::size_t, 3> {};
+template <> struct PrimitiveTypeOf<Triangles> : std::integral_constant<PrimitiveType, PrimitiveType::Triangle> {};
 
-    static constexpr std::size_t bufferGroupSize = 1;
-    static constexpr PrimitiveType primitiveType = PrimitiveType::TriangleStrip;
+// TriangleStrip is a form of "Triangle" rendering, but the element buffer
+// cannot be grouped into logical elements beyond a single Point.
+class TriangleStrip : public DrawMode {
+public:
+    explicit TriangleStrip() : DrawMode(DrawModeType::TriangleStrip, 0) {
+    }
 };
 
+template <> struct BufferGroupSizeOf<TriangleStrip> : std::integral_constant<std::size_t, 1> {};
+template <> struct PrimitiveTypeOf<TriangleStrip> : std::integral_constant<PrimitiveType, PrimitiveType::Triangle> {};
+
 } // namespace gfx
 } // namespace mbgl
diff --git a/src/mbgl/gfx/draw_scope.hpp b/src/mbgl/gfx/draw_scope.hpp
new file mode 100644
index 0000000000..60aae7a44c
--- /dev/null
+++ b/src/mbgl/gfx/draw_scope.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <memory>
+
+namespace mbgl {
+namespace gfx {
+
+class DrawScopeResource {
+protected:
+    DrawScopeResource() = default;
+public:
+    virtual ~DrawScopeResource() = default;
+};
+
+class DrawScope {
+public:
+    std::unique_ptr<DrawScopeResource> resource;
+};
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/src/mbgl/gfx/index_vector.hpp b/src/mbgl/gfx/index_vector.hpp
index dc760feb90..826d43bee3 100644
--- a/src/mbgl/gfx/index_vector.hpp
+++ b/src/mbgl/gfx/index_vector.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/gfx/draw_mode.hpp>
 #include <mbgl/util/ignore.hpp>
 
 #include <vector>
@@ -10,7 +11,7 @@ namespace gfx {
 template <class DrawMode>
 class IndexVector {
 public:
-    static constexpr std::size_t groupSize = DrawMode::bufferGroupSize;
+    static constexpr std::size_t groupSize = BufferGroupSizeOf<DrawMode>::value;
 
     template <class... Args>
     void emplace_back(Args&&... args) {
diff --git a/src/mbgl/gfx/primitives.hpp b/src/mbgl/gfx/primitives.hpp
deleted file mode 100644
index f92b1ec525..0000000000
--- a/src/mbgl/gfx/primitives.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-namespace mbgl {
-namespace gfx {
-
-class Point {
-public:
-    static constexpr std::size_t vertexCount = 1;
-};
-
-class Line {
-public:
-    static constexpr std::size_t vertexCount = 2;
-};
-
-class Triangle {
-public:
-    static constexpr std::size_t vertexCount = 3;
-};
-
-} // namespace gfx
-} // namespace mbgl
diff --git a/src/mbgl/gfx/program.hpp b/src/mbgl/gfx/program.hpp
new file mode 100644
index 0000000000..94ba3b18ef
--- /dev/null
+++ b/src/mbgl/gfx/program.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <cstddef>
+
+namespace mbgl {
+namespace gfx {
+
+class Context;
+class DrawMode;
+class DepthMode;
+class StencilMode;
+class ColorMode;
+class CullFaceMode;
+class DrawScope;
+class IndexBuffer;
+template <class> class UniformValues;
+template <class> class AttributeBindings;
+template <class> class TextureBindings;
+
+template <class Name>
+class Program {
+protected:
+    Program() = default;
+
+public:
+    virtual ~Program() = default;
+
+    Program(Program&&) = delete;
+    Program(const Program&) = delete;
+    Program& operator=(Program&&) = delete;
+    Program& operator=(const Program&) = delete;
+
+    using AttributeList = typename Name::AttributeList;
+    using UniformList = typename Name::UniformList;
+    using TextureList = typename Name::TextureList;
+
+    virtual void draw(Context&,
+                      const DrawMode&,
+                      const DepthMode&,
+                      const StencilMode&,
+                      const ColorMode&,
+                      const CullFaceMode&,
+                      const UniformValues<UniformList>&,
+                      DrawScope&,
+                      const AttributeBindings<AttributeList>&,
+                      const TextureBindings<TextureList>&,
+                      const IndexBuffer&,
+                      std::size_t indexOffset,
+                      std::size_t indexLength) = 0;
+};
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/src/mbgl/gfx/texture.hpp b/src/mbgl/gfx/texture.hpp
index 758bdd1b09..a957c4ebdf 100644
--- a/src/mbgl/gfx/texture.hpp
+++ b/src/mbgl/gfx/texture.hpp
@@ -52,21 +52,19 @@ public:
     TextureWrapType wrapY;
 };
 
-namespace detail {
-
 template <class>
 class TextureBindings;
 
 template <class... Ts>
-class TextureBindings<TypeList<Ts...>> {
+class TextureBindings<TypeList<Ts...>> final
+    : public IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>> {
+    using Base = IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>>;
+
 public:
-    using Type = IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>>;
+    template <class... Args>
+    TextureBindings(Args&&... args) : Base(std::forward<Args>(args)...) {
+    }
 };
 
-} // namespace detail
-
-template <class TextureTypeList>
-using TextureBindings = typename detail::TextureBindings<TextureTypeList>::Type;
-
 } // namespace gfx
 } // namespace mbgl
diff --git a/src/mbgl/gfx/types.hpp b/src/mbgl/gfx/types.hpp
index 4c6a040b1f..da2bc14ddd 100644
--- a/src/mbgl/gfx/types.hpp
+++ b/src/mbgl/gfx/types.hpp
@@ -5,7 +5,17 @@
 namespace mbgl {
 namespace gfx {
 
+enum class ContextType : uint8_t {
+    OpenGL,
+};
+
 enum class PrimitiveType : uint8_t {
+    Point,
+    Line,
+    Triangle,
+};
+
+enum class DrawModeType : uint8_t {
     Points,
     Lines,
     LineLoop,
diff --git a/src/mbgl/gfx/uniform.hpp b/src/mbgl/gfx/uniform.hpp
index bc6e7c1866..f6896b9138 100644
--- a/src/mbgl/gfx/uniform.hpp
+++ b/src/mbgl/gfx/uniform.hpp
@@ -31,21 +31,20 @@
 
 namespace mbgl {
 namespace gfx {
-namespace detail {
 
 template <class>
 class UniformValues;
 
 template <class... Us>
-class UniformValues<TypeList<Us...>> {
+class UniformValues<TypeList<Us...>> final
+    : public IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>> {
+    using Base = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>;
+
 public:
-    using Type = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>;
+    template <class... Args>
+    UniformValues(Args&&... args) : Base(std::forward<Args>(args)...) {
+    }
 };
 
-} // namespace detail
-
-template <class UniformTypeList>
-using UniformValues = typename detail::UniformValues<UniformTypeList>::Type;
-
 } // namespace gfx
 } // namespace mbgl
diff --git a/src/mbgl/gl/attribute.cpp b/src/mbgl/gl/attribute.cpp
index 1b43ad2b64..4983a8c204 100644
--- a/src/mbgl/gl/attribute.cpp
+++ b/src/mbgl/gl/attribute.cpp
@@ -7,17 +7,6 @@ namespace gl {
 
 using namespace platform;
 
-optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset) {
-    assert(vertexOffset <= std::numeric_limits<uint32_t>::max());
-    if (binding) {
-        AttributeBinding result = *binding;
-        result.vertexOffset = static_cast<uint32_t>(vertexOffset);
-        return result;
-    } else {
-        return binding;
-    }
-}
-
 void bindAttributeLocation(Context& context, ProgramID id, AttributeLocation location, const char* name) {
     // We're using sequentially numberered attribute locations starting with 0. Therefore we can use
     // the location as a proxy for the number of attributes.
diff --git a/src/mbgl/gl/attribute.hpp b/src/mbgl/gl/attribute.hpp
index dc112c1ad8..c4fe8b993f 100644
--- a/src/mbgl/gl/attribute.hpp
+++ b/src/mbgl/gl/attribute.hpp
@@ -2,7 +2,6 @@
 
 #include <mbgl/gfx/attribute.hpp>
 #include <mbgl/gl/types.hpp>
-#include <mbgl/gfx/vertex_buffer.hpp>
 #include <mbgl/util/ignore.hpp>
 #include <mbgl/util/indexed_tuple.hpp>
 #include <mbgl/util/optional.hpp>
@@ -18,83 +17,50 @@
 namespace mbgl {
 namespace gl {
 
-class AttributeBinding {
-public:
-    gfx::AttributeDescriptor attribute;
-    uint8_t vertexStride;
-    const gfx::VertexBufferResource* vertexBufferResource;
-    uint32_t vertexOffset;
-
-    friend bool operator==(const AttributeBinding& lhs, const AttributeBinding& rhs) {
-        return lhs.attribute == rhs.attribute &&
-               lhs.vertexStride == rhs.vertexStride &&
-               lhs.vertexBufferResource == rhs.vertexBufferResource &&
-               lhs.vertexOffset == rhs.vertexOffset;
-    }
-};
-
-using AttributeBindingArray = std::vector<optional<AttributeBinding>>;
-
-    /*
-        Create a binding for this attribute.  The `attributeSize` parameter may be used to
-        override the number of components available in the buffer for each vertex.  Thus,
-        a buffer with only one float for each vertex can be bound to a `vec2` attribute
-    */
-template <std::size_t I, typename Vertex>
-AttributeBinding attributeBinding(const gfx::VertexBuffer<Vertex>& buffer) {
-    static_assert(I < gfx::VertexDescriptorOf<Vertex>::data.count, "vertex attribute index out of range");
-    return {
-        gfx::VertexDescriptorOf<Vertex>::data.attributes[I],
-        gfx::VertexDescriptorOf<Vertex>::data.stride,
-        buffer.resource.get(),
-        0,
-    };
-}
-
-optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset);
+using AttributeBindingArray = std::vector<optional<gfx::AttributeBinding>>;
+using NamedAttributeLocations = std::vector<std::pair<const std::string, AttributeLocation>>;
 
 class Context;
 void bindAttributeLocation(Context&, ProgramID, AttributeLocation, const char * name);
 std::set<std::string> getActiveAttributes(ProgramID);
 
 template <class>
-class Attributes;
+class AttributeLocations;
 
 template <class... As>
-class Attributes<TypeList<As...>> final {
-public:
-    using Types = TypeList<As...>;
-    using Locations = IndexedTuple<
-        TypeList<As...>,
-        TypeList<ExpandToType<As, optional<AttributeLocation>>...>>;
-    using Bindings = IndexedTuple<
-        TypeList<As...>,
-        TypeList<ExpandToType<As, optional<AttributeBinding>>...>>;
-    using NamedLocations = std::vector<std::pair<const std::string, AttributeLocation>>;
-
-    static Locations bindLocations(Context& context, const ProgramID& id) {
-        std::set<std::string> activeAttributes = getActiveAttributes(id);
-
-        AttributeLocation location = 0;
-        auto maybeBindLocation = [&](const char* name) -> optional<AttributeLocation> {
-            if (activeAttributes.count(name)) {
-                bindAttributeLocation(context, id, location, name);
-                return location++;
-            } else {
-                return {};
-            }
-        };
+class AttributeLocations<TypeList<As...>> final {
+private:
+    using Locations =
+        IndexedTuple<TypeList<As...>, TypeList<ExpandToType<As, optional<AttributeLocation>>...>>;
+
+    Locations locations;
 
-        return Locations { maybeBindLocation(As::name())... };
+public:
+    AttributeLocations(Context& context, const ProgramID& id)
+        : locations([&] {
+              std::set<std::string> activeAttributes = getActiveAttributes(id);
+
+              AttributeLocation location = 0;
+              auto maybeBindLocation = [&](const char* name) -> optional<AttributeLocation> {
+                  if (activeAttributes.count(name)) {
+                      bindAttributeLocation(context, id, location, name);
+                      return location++;
+                  } else {
+                      return {};
+                  }
+              };
+
+              return Locations{ maybeBindLocation(As::name())... };
+          }()) {
     }
 
-    template <class Program>
-    static Locations loadNamedLocations(const Program& program) {
-        return Locations{ program.attributeLocation(As::name())... };
+    template <class BinaryProgram>
+    AttributeLocations(const BinaryProgram& program)
+        : locations{ program.attributeLocation(As::name())... } {
     }
 
-    static NamedLocations getNamedLocations(const Locations& locations) {
-        NamedLocations result;
+    NamedAttributeLocations getNamedLocations() const {
+        NamedAttributeLocations result;
 
         auto maybeAddLocation = [&] (const std::string& name, const optional<AttributeLocation>& location) {
             if (location) {
@@ -107,20 +73,12 @@ public:
         return result;
     }
 
-    static Bindings bindings(const gfx::VertexBuffer<gfx::Vertex<Types>>& buffer) {
-        return Bindings { attributeBinding<TypeIndex<As, As...>::value>(buffer)... };
-    }
-
-    static Bindings offsetBindings(const Bindings& bindings, std::size_t vertexOffset) {
-        return Bindings { offsetAttributeBinding(bindings.template get<As>(), vertexOffset)... };
-    }
-
-    static AttributeBindingArray toBindingArray(const Locations& locations, const Bindings& bindings) {
+    AttributeBindingArray toBindingArray(const gfx::AttributeBindings<TypeList<As...>>& bindings) const {
         AttributeBindingArray result;
         result.resize(sizeof...(As));
 
         auto maybeAddBinding = [&] (const optional<AttributeLocation>& location,
-                                    const optional<AttributeBinding>& binding) {
+                                    const optional<gfx::AttributeBinding>& binding) {
             if (location) {
                 result.at(*location) = binding;
             }
@@ -130,12 +88,6 @@ public:
 
         return result;
     }
-
-    static uint32_t activeBindingCount(const Bindings& bindings) {
-        uint32_t result = 0;
-        util::ignore({ ((result += bool(bindings.template get<As>())), 0)... });
-        return result;
-    }
 };
 
 } // namespace gl
diff --git a/src/mbgl/programs/binary_program.cpp b/src/mbgl/gl/binary_program.cpp
index 598a547252..9fdbdb8ee1 100644
--- a/src/mbgl/programs/binary_program.cpp
+++ b/src/mbgl/gl/binary_program.cpp
@@ -1,4 +1,4 @@
-#include <mbgl/programs/binary_program.hpp>
+#include <mbgl/gl/binary_program.hpp>
 
 #include <protozero/pbf_reader.hpp>
 #include <protozero/pbf_writer.hpp>
@@ -31,6 +31,7 @@ static std::pair<const std::string, Binding> parseBinding(protozero::pbf_reader&
 }
 
 namespace mbgl {
+namespace gl {
 
 BinaryProgram::BinaryProgram(std::string&& data) {
     bool hasFormat = false, hasCode = false;
@@ -137,4 +138,5 @@ gl::UniformLocation BinaryProgram::textureLocation(const std::string& name) cons
     return -1;
 }
 
+} // namespace gl
 } // namespace mbgl
diff --git a/src/mbgl/programs/binary_program.hpp b/src/mbgl/gl/binary_program.hpp
index 1ae874800b..38160b62b5 100644
--- a/src/mbgl/programs/binary_program.hpp
+++ b/src/mbgl/gl/binary_program.hpp
@@ -7,6 +7,7 @@
 #include <vector>
 
 namespace mbgl {
+namespace gl {
 
 class BinaryProgram {
 public:
@@ -45,4 +46,5 @@ private:
     std::vector<std::pair<const std::string, gl::UniformLocation>> textures;
 };
 
+} // namespace gl
 } // namespace mbgl
diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp
index ca06ab660d..5193381251 100644
--- a/src/mbgl/gl/context.cpp
+++ b/src/mbgl/gl/context.cpp
@@ -3,6 +3,7 @@
 #include <mbgl/gl/vertex_buffer_resource.hpp>
 #include <mbgl/gl/index_buffer_resource.hpp>
 #include <mbgl/gl/texture_resource.hpp>
+#include <mbgl/gl/draw_scope_resource.hpp>
 #include <mbgl/gl/texture.hpp>
 #include <mbgl/gl/debugging_extension.hpp>
 #include <mbgl/gl/vertex_array_extension.hpp>
@@ -66,7 +67,7 @@ static_assert(underlying_type(UniformDataType::SamplerCube) == GL_SAMPLER_CUBE,
 static_assert(std::is_same<BinaryProgramFormat, GLenum>::value, "OpenGL type mismatch");
 
 Context::Context()
-    : maximumVertexBindingCount([] {
+    : gfx::Context(gfx::ContextType::OpenGL), maximumVertexBindingCount([] {
           GLint value;
           MBGL_CHECK_ERROR(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value));
           return value;
@@ -190,6 +191,8 @@ UniqueProgram Context::createProgram(ShaderID vertexShader, ShaderID fragmentSha
     MBGL_CHECK_ERROR(glAttachShader(result, vertexShader));
     MBGL_CHECK_ERROR(glAttachShader(result, fragmentShader));
 
+    linkProgram(result);
+
     return result;
 }
 
@@ -544,6 +547,10 @@ void Context::updateTextureResource(const gfx::TextureResource& resource,
                                   Enum<gfx::TextureChannelDataType>::to(type), data));
 }
 
+std::unique_ptr<gfx::DrawScopeResource> Context::createDrawScopeResource() {
+    return std::make_unique<gl::DrawScopeResource>(createVertexArray());
+}
+
 void Context::reset() {
     std::copy(pooledTextures.begin(), pooledTextures.end(), std::back_inserter(abandonedTextures));
     pooledTextures.resize(0);
@@ -628,29 +635,6 @@ void Context::setCullFaceMode(const gfx::CullFaceMode& mode) {
     cullFaceWinding = mode.winding;
 }
 
-#if not MBGL_USE_GLES2
-void Context::setDrawMode(const gfx::Points& points) {
-    pointSize = points.pointSize;
-}
-#else
-void Context::setDrawMode(const gfx::Points&) {
-}
-#endif // MBGL_USE_GLES2
-
-void Context::setDrawMode(const gfx::Lines& lines) {
-    lineWidth = lines.lineWidth;
-}
-
-void Context::setDrawMode(const gfx::LineStrip& lineStrip) {
-    lineWidth = lineStrip.lineWidth;
-}
-
-void Context::setDrawMode(const gfx::Triangles&) {
-}
-
-void Context::setDrawMode(const gfx::TriangleStrip&) {
-}
-
 void Context::setDepthMode(const gfx::DepthMode& depth) {
     if (depth.func == gfx::DepthFunctionType::Always && depth.mask != gfx::DepthMaskType::ReadWrite) {
         depthTest = false;
@@ -697,11 +681,27 @@ void Context::setColorMode(const gfx::ColorMode& color) {
     colorMask = color.mask;
 }
 
-void Context::draw(gfx::PrimitiveType primitiveType,
+void Context::draw(const gfx::DrawMode& drawMode,
                    std::size_t indexOffset,
                    std::size_t indexLength) {
+    switch (drawMode.type) {
+    case gfx::DrawModeType::Points:
+#if not MBGL_USE_GLES2
+        // In OpenGL ES 2, the point size is set in the vertex shader.
+        pointSize = drawMode.size;
+#endif // MBGL_USE_GLES2
+        break;
+    case gfx::DrawModeType::Lines:
+    case gfx::DrawModeType::LineLoop:
+    case gfx::DrawModeType::LineStrip:
+        lineWidth = drawMode.size;
+        break;
+    default:
+        break;
+    }
+
     MBGL_CHECK_ERROR(glDrawElements(
-        Enum<gfx::PrimitiveType>::to(primitiveType),
+        Enum<gfx::DrawModeType>::to(drawMode.type),
         static_cast<GLsizei>(indexLength),
         GL_UNSIGNED_SHORT,
         reinterpret_cast<GLvoid*>(sizeof(uint16_t) * indexOffset)));
diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp
index 51b79200ba..fe09390cc6 100644
--- a/src/mbgl/gl/context.hpp
+++ b/src/mbgl/gl/context.hpp
@@ -52,7 +52,6 @@ public:
     void verifyProgramLinkage(ProgramID);
     void linkProgram(ProgramID);
     UniqueTexture createUniqueTexture();
-    VertexArray createVertexArray();
 
 #if MBGL_HAS_BINARY_PROGRAMS
     bool supportsProgramBinaries() const;
@@ -100,18 +99,12 @@ public:
                optional<float> depth,
                optional<int32_t> stencil);
 
-    void setDrawMode(const gfx::Points&);
-    void setDrawMode(const gfx::Lines&);
-    void setDrawMode(const gfx::LineStrip&);
-    void setDrawMode(const gfx::Triangles&);
-    void setDrawMode(const gfx::TriangleStrip&);
-
     void setDepthMode(const gfx::DepthMode&);
     void setStencilMode(const gfx::StencilMode&);
     void setColorMode(const gfx::ColorMode&);
     void setCullFaceMode(const gfx::CullFaceMode&);
 
-    void draw(gfx::PrimitiveType,
+    void draw(const gfx::DrawMode&,
               std::size_t indexOffset,
               std::size_t indexLength);
 
@@ -216,6 +209,8 @@ private:
     std::unique_ptr<gfx::TextureResource> createTextureResource(Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override;
     void updateTextureResource(const gfx::TextureResource&, Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override;
 
+    std::unique_ptr<gfx::DrawScopeResource> createDrawScopeResource() override;
+
     UniqueFramebuffer createFramebuffer();
     UniqueRenderbuffer createRenderbuffer(RenderbufferType, Size size);
     std::unique_ptr<uint8_t[]> readFramebuffer(Size, gfx::TexturePixelType, bool flip);
@@ -223,6 +218,7 @@ private:
     void drawPixels(Size size, const void* data, gfx::TexturePixelType);
 #endif // MBGL_USE_GLES2
 
+    VertexArray createVertexArray();
     bool supportsVertexArrays() const;
 
     friend detail::ProgramDeleter;
diff --git a/src/mbgl/gl/draw_scope_resource.hpp b/src/mbgl/gl/draw_scope_resource.hpp
new file mode 100644
index 0000000000..4c446cd4fe
--- /dev/null
+++ b/src/mbgl/gl/draw_scope_resource.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <mbgl/gfx/draw_scope.hpp>
+#include <mbgl/gl/vertex_array.hpp>
+
+namespace mbgl {
+namespace gl {
+
+class DrawScopeResource : public gfx::DrawScopeResource {
+public:
+    DrawScopeResource(VertexArray&& vertexArray_) : vertexArray(std::move(vertexArray_)) {
+    }
+
+    VertexArray vertexArray;
+};
+
+} // namespace gl
+} // namespace mbgl
diff --git a/src/mbgl/gl/enum.cpp b/src/mbgl/gl/enum.cpp
index c1a51944de..673d43b5d6 100644
--- a/src/mbgl/gl/enum.cpp
+++ b/src/mbgl/gl/enum.cpp
@@ -6,15 +6,15 @@ namespace mbgl {
 namespace gl {
 
 template <>
-platform::GLenum Enum<gfx::PrimitiveType>::to(const gfx::PrimitiveType value) {
+platform::GLenum Enum<gfx::DrawModeType>::to(const gfx::DrawModeType value) {
     switch (value) {
-        case gfx::PrimitiveType::Points: return GL_POINTS;
-        case gfx::PrimitiveType::Lines: return GL_LINES;
-        case gfx::PrimitiveType::LineLoop: return GL_LINE_LOOP;
-        case gfx::PrimitiveType::LineStrip: return GL_LINE_STRIP;
-        case gfx::PrimitiveType::Triangles: return GL_TRIANGLES;
-        case gfx::PrimitiveType::TriangleStrip: return GL_TRIANGLE_STRIP;
-        case gfx::PrimitiveType::TriangleFan: return GL_TRIANGLE_FAN;
+        case gfx::DrawModeType::Points: return GL_POINTS;
+        case gfx::DrawModeType::Lines: return GL_LINES;
+        case gfx::DrawModeType::LineLoop: return GL_LINE_LOOP;
+        case gfx::DrawModeType::LineStrip: return GL_LINE_STRIP;
+        case gfx::DrawModeType::Triangles: return GL_TRIANGLES;
+        case gfx::DrawModeType::TriangleStrip: return GL_TRIANGLE_STRIP;
+        case gfx::DrawModeType::TriangleFan: return GL_TRIANGLE_FAN;
     }
     return GL_INVALID_ENUM;
 }
diff --git a/src/mbgl/gl/program.hpp b/src/mbgl/gl/program.hpp
index ffa3e07391..9028ffdf53 100644
--- a/src/mbgl/gl/program.hpp
+++ b/src/mbgl/gl/program.hpp
@@ -1,80 +1,79 @@
 #pragma once
 
+#include <mbgl/gfx/program.hpp>
 #include <mbgl/gl/types.hpp>
 #include <mbgl/gl/object.hpp>
 #include <mbgl/gl/context.hpp>
+#include <mbgl/gl/draw_scope_resource.hpp>
 #include <mbgl/gfx/vertex_buffer.hpp>
 #include <mbgl/gfx/index_buffer.hpp>
+#include <mbgl/gfx/uniform.hpp>
 #include <mbgl/gl/vertex_array.hpp>
 #include <mbgl/gl/attribute.hpp>
 #include <mbgl/gl/uniform.hpp>
 #include <mbgl/gl/texture.hpp>
-
+#include <mbgl/gl/features.hpp>
+#include <mbgl/gl/binary_program.hpp>
 #include <mbgl/util/io.hpp>
+
 #include <mbgl/util/logging.hpp>
-#include <mbgl/programs/binary_program.hpp>
 #include <mbgl/programs/program_parameters.hpp>
-#include <mbgl/shaders/shaders.hpp>
+#include <mbgl/programs/gl/shaders.hpp>
 
 #include <string>
 
 namespace mbgl {
 namespace gl {
 
-template <class P, class As, class Us, class TextureList>
-class Program {
+template <class Name>
+class Program final : public gfx::Program<Name> {
 public:
-    using Primitive = P;
-    using Attributes = As;
-    using Uniforms = Us;
-
-    using UniformValues = typename Uniforms::Values;
-    using AttributeBindings = typename Attributes::Bindings;
-    using TextureBindings = gfx::TextureBindings<TextureList>;
-
+    using AttributeList = typename Name::AttributeList;
+    using UniformList = typename Name::UniformList;
+    using TextureList = typename Name::TextureList;
+  
     Program(Context& context, const std::string& vertexSource, const std::string& fragmentSource)
         : program(
               context.createProgram(context.createShader(ShaderType::Vertex, vertexSource),
                                     context.createShader(ShaderType::Fragment, fragmentSource))),
-          uniformsState((context.linkProgram(program), Uniforms::bindLocations(program))),
-          attributeLocations(Attributes::bindLocations(context, program)) {
-        // Re-link program after manually binding only active attributes in Attributes::bindLocations
+          attributeLocations(context, program) {
+        // Re-link program after manually binding only active attributes in Attributes::queryLocations
         context.linkProgram(program);
 
         // We have to re-initialize the uniforms state from the bindings as the uniform locations
         // get shifted on some implementations
-        uniformsState = Uniforms::bindLocations(program);
+        uniformStates.queryLocations(program);
 
         // Texture units are specified via uniforms as well, so we need query their locations
-        textures.queryLocations(program);
+        textureStates.queryLocations(program);
     }
 
     template <class BinaryProgram>
     Program(Context& context, const BinaryProgram& binaryProgram)
         : program(context.createProgram(binaryProgram.format(), binaryProgram.code())),
-          uniformsState(Uniforms::loadNamedLocations(binaryProgram)),
-          attributeLocations(Attributes::loadNamedLocations(binaryProgram)) {
-        textures.loadNamedLocations(binaryProgram);
+          attributeLocations(binaryProgram) {
+        uniformStates.loadNamedLocations(binaryProgram);
+        textureStates.loadNamedLocations(binaryProgram);
     }
-    
-    static Program createProgram(gl::Context& context,
-                                 const ProgramParameters& programParameters,
-                                 const char* name,
-                                 const char* vertexSource_,
-                                 const char* fragmentSource_) {
-        const std::string vertexSource = shaders::vertexSource(programParameters, vertexSource_);
-        const std::string fragmentSource = shaders::fragmentSource(programParameters, fragmentSource_);
+
+    static std::unique_ptr<Program> createProgram(gl::Context& context,
+                                                  const ProgramParameters& programParameters,
+                                                  const char* name,
+                                                  const char* vertexSource_,
+                                                  const char* fragmentSource_) {
+        const std::string vertexSource = programs::gl::vertexSource(programParameters, vertexSource_);
+        const std::string fragmentSource = programs::gl::fragmentSource(programParameters, fragmentSource_);
 
 #if MBGL_HAS_BINARY_PROGRAMS
         optional<std::string> cachePath = programParameters.cachePath(name);
         if (cachePath && context.supportsProgramBinaries()) {
-            const std::string identifier = shaders::programIdentifier(vertexSource, fragmentSource);
+            const std::string identifier = programs::gl::programIdentifier(vertexSource, fragmentSource);
 
             try {
                 if (auto cachedBinaryProgram = util::readFile(*cachePath)) {
                     const BinaryProgram binaryProgram(std::move(*cachedBinaryProgram));
                     if (binaryProgram.identifier() == identifier) {
-                        return Program { context, binaryProgram };
+                        return std::make_unique<Program>(context, binaryProgram);
                     } else {
                         Log::Warning(Event::OpenGL,
                                      "Cached program %s changed. Recompilation required.",
@@ -87,11 +86,11 @@ public:
             }
 
             // Compile the shader
-            Program result{ context, vertexSource, fragmentSource };
+            auto result = std::make_unique<Program>(context, vertexSource, fragmentSource);
 
             try {
                 if (const auto binaryProgram =
-                        result.template get<BinaryProgram>(context, identifier)) {
+                        result->template get<BinaryProgram>(context, identifier)) {
                     util::write_file(*cachePath, binaryProgram->serialize());
                     Log::Warning(Event::OpenGL, "Caching program in: %s", (*cachePath).c_str());
                 }
@@ -104,37 +103,37 @@ public:
 #endif
 
         (void)name;
-        return Program { context, vertexSource, fragmentSource };
+        return std::make_unique<Program>(context, vertexSource, fragmentSource);
     }
 
     template <class BinaryProgram>
     optional<BinaryProgram> get(Context& context, const std::string& identifier) const {
         if (auto binaryProgram = context.getBinaryProgram(program)) {
-            return BinaryProgram{ binaryProgram->first, std::move(binaryProgram->second),
-                                  identifier, Attributes::getNamedLocations(attributeLocations),
-                                  Uniforms::getNamedLocations(uniformsState),
-                                  textures.getNamedLocations() };
+            return BinaryProgram{ binaryProgram->first,
+                                  std::move(binaryProgram->second),
+                                  identifier,
+                                  attributeLocations.getNamedLocations(),
+                                  uniformStates.getNamedLocations(),
+                                  textureStates.getNamedLocations() };
         }
         return {};
     }
 
-    template <class DrawMode>
-    void draw(Context& context,
-              DrawMode drawMode,
-              gfx::DepthMode depthMode,
-              gfx::StencilMode stencilMode,
-              gfx::ColorMode colorMode,
-              gfx::CullFaceMode cullFaceMode,
-              const UniformValues& uniformValues,
-              gl::VertexArray& vertexArray,
-              const AttributeBindings& attributeBindings,
-              const TextureBindings& textureBindings,
+    void draw(gfx::Context& genericContext,
+              const gfx::DrawMode& drawMode,
+              const gfx::DepthMode& depthMode,
+              const gfx::StencilMode& stencilMode,
+              const gfx::ColorMode& colorMode,
+              const gfx::CullFaceMode& cullFaceMode,
+              const gfx::UniformValues<UniformList>& uniformValues,
+              gfx::DrawScope& drawScope,
+              const gfx::AttributeBindings<AttributeList>& attributeBindings,
+              const gfx::TextureBindings<TextureList>& textureBindings,
               const gfx::IndexBuffer& indexBuffer,
               std::size_t indexOffset,
-              std::size_t indexLength) {
-        static_assert(std::is_same<Primitive, typename DrawMode::Primitive>::value, "incompatible draw mode");
+              std::size_t indexLength) override {
+        auto& context = reinterpret_cast<gl::Context&>(genericContext);
 
-        context.setDrawMode(drawMode);
         context.setDepthMode(depthMode);
         context.setStencilMode(stencilMode);
         context.setColorMode(colorMode);
@@ -142,15 +141,16 @@ public:
 
         context.program = program;
 
-        Uniforms::bind(uniformsState, uniformValues);
+        uniformStates.bind(uniformValues);
 
-        textures.bind(context, textureBindings);
+        textureStates.bind(context, textureBindings);
 
+        auto& vertexArray = reinterpret_cast<gl::DrawScopeResource&>(*drawScope.resource).vertexArray;
         vertexArray.bind(context,
                         indexBuffer,
-                        Attributes::toBindingArray(attributeLocations, attributeBindings));
+                        attributeLocations.toBindingArray(attributeBindings));
 
-        context.draw(drawMode.primitiveType,
+        context.draw(drawMode,
                      indexOffset,
                      indexLength);
     }
@@ -158,9 +158,9 @@ public:
 private:
     UniqueProgram program;
 
-    typename Uniforms::State uniformsState;
-    typename Attributes::Locations attributeLocations;
-    gl::Textures<TextureList> textures;
+    gl::AttributeLocations<AttributeList> attributeLocations;
+    gl::UniformStates<UniformList> uniformStates;
+    gl::TextureStates<TextureList> textureStates;
 };
 
 } // namespace gl
diff --git a/src/mbgl/gl/texture.hpp b/src/mbgl/gl/texture.hpp
index 8230be1652..0569adc3b0 100644
--- a/src/mbgl/gl/texture.hpp
+++ b/src/mbgl/gl/texture.hpp
@@ -15,13 +15,15 @@ class Context;
 void bindTexture(gl::Context&, uint8_t unit, const gfx::TextureBinding&);
 
 template <class>
-class Textures;
+class TextureStates;
 
 template <class... Ts>
-class Textures<TypeList<Ts...>> {
+class TextureStates<TypeList<Ts...>> {
+private:
     using State =
         IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, gl::UniformState<uint8_t>>...>>;
-    using NamedLocations = std::vector<std::pair<const std::string, gl::UniformLocation>>;
+
+    State state;
 
 public:
     void queryLocations(const ProgramID& id) {
@@ -33,8 +35,8 @@ public:
         state = State{ program.textureLocation(Ts::name())... };
     }
 
-    NamedLocations getNamedLocations() const {
-        return NamedLocations{ { Ts::name(), state.template get<Ts>().location }... };
+    NamedUniformLocations getNamedLocations() const {
+        return NamedUniformLocations{ { Ts::name(), state.template get<Ts>().location }... };
     }
 
     void bind(gl::Context& context, const gfx::TextureBindings<TypeList<Ts...>>& bindings) {
@@ -43,9 +45,6 @@ public:
                gl::bindTexture(context, TypeIndex<Ts, Ts...>::value, bindings.template get<Ts>()),
                0)... });
     }
-
-private:
-    State state;
 };
 
 } // namespace gl
diff --git a/src/mbgl/gl/uniform.hpp b/src/mbgl/gl/uniform.hpp
index 3827015bb3..770f3e2294 100644
--- a/src/mbgl/gl/uniform.hpp
+++ b/src/mbgl/gl/uniform.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/gfx/uniform.hpp>
 #include <mbgl/gl/types.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/ignore.hpp>
@@ -49,23 +50,25 @@ public:
     optional<Value> current = {};
 };
 
-UniformLocation uniformLocation(ProgramID, const char * name);
+UniformLocation uniformLocation(ProgramID, const char* name);
+
+using NamedUniformLocations = std::vector<std::pair<const std::string, UniformLocation>>;
 
 template <class>
-class Uniforms;
+class UniformStates;
 
 template <class... Us>
-class Uniforms<TypeList<Us...>> final {
-public:
-    using Types = TypeList<Us...>;
+class UniformStates<TypeList<Us...>> final {
+private:
     using State = IndexedTuple<TypeList<Us...>, TypeList<UniformState<typename Us::Value>...>>;
-    using Values = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>;
-    using NamedLocations = std::vector<std::pair<const std::string, UniformLocation>>;
 
-    static State bindLocations(const ProgramID& id) {
+    State state;
+
+public:
+    void queryLocations(const ProgramID& id) {
 #ifndef NDEBUG
         // Verify active uniform types match the enum
-        const auto active = activeUniforms(id);
+        const auto active = gl::activeUniforms(id);
 
         util::ignore(
             { // Some shader programs have uniforms declared, but not used, so they're not active.
@@ -75,19 +78,19 @@ public:
                    : false)... });
 #endif
 
-        return State(uniformLocation(id, Us::name())...);
+        state = State{ gl::uniformLocation(id, Us::name())... };
     }
 
-    template <class Program>
-    static State loadNamedLocations(const Program& program) {
-        return State(UniformState<typename Us::Value>(program.uniformLocation(Us::name()))...);
+    template <class BinaryProgram>
+    void loadNamedLocations(const BinaryProgram& program) {
+        state = State{ UniformState<typename Us::Value>(program.uniformLocation(Us::name()))... };
     }
 
-    static NamedLocations getNamedLocations(const State& state) {
-        return NamedLocations{ { Us::name(), state.template get<Us>().location }... };
+    NamedUniformLocations getNamedLocations() const {
+        return NamedUniformLocations{ { Us::name(), state.template get<Us>().location }... };
     }
 
-    static void bind(State& state, const Values& values) {
+    void bind(const gfx::UniformValues<TypeList<Us...>>& values) {
         util::ignore({ (state.template get<Us>() = values.template get<Us>(), 0)... });
     }
 };
diff --git a/src/mbgl/gl/value.cpp b/src/mbgl/gl/value.cpp
index 8f5b53fcac..bd08ac48fc 100644
--- a/src/mbgl/gl/value.cpp
+++ b/src/mbgl/gl/value.cpp
@@ -397,7 +397,7 @@ BindVertexArray::Type BindVertexArray::Get(const Context& context) {
     return binding;
 }
 
-const optional<AttributeBinding> VertexAttribute::Default {};
+const VertexAttribute::Type VertexAttribute::Default {};
 
 namespace {
 
@@ -484,7 +484,7 @@ GLint components(const gfx::AttributeDataType type) {
 
 } // namespace
 
-void VertexAttribute::Set(const optional<AttributeBinding>& binding, Context& context, AttributeLocation location) {
+void VertexAttribute::Set(const Type& binding, Context& context, AttributeLocation location) {
     if (binding) {
         context.vertexBuffer = reinterpret_cast<const gl::VertexBufferResource&>(*binding->vertexBufferResource).buffer;
         MBGL_CHECK_ERROR(glEnableVertexAttribArray(location));
diff --git a/src/mbgl/gl/value.hpp b/src/mbgl/gl/value.hpp
index 15812a49bd..5bd2132ecf 100644
--- a/src/mbgl/gl/value.hpp
+++ b/src/mbgl/gl/value.hpp
@@ -264,7 +264,7 @@ struct BindVertexArray {
 };
 
 struct VertexAttribute {
-    using Type = optional<gl::AttributeBinding>;
+    using Type = optional<gfx::AttributeBinding>;
     static const Type Default;
     static void Set(const Type&, Context&, AttributeLocation);
 };
diff --git a/src/mbgl/programs/background_pattern_program.hpp b/src/mbgl/programs/background_pattern_program.hpp
new file mode 100644
index 0000000000..4b66065670
--- /dev/null
+++ b/src/mbgl/programs/background_pattern_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/background_program.hpp>
diff --git a/src/mbgl/programs/background_program.cpp b/src/mbgl/programs/background_program.cpp
index 99c9c55e84..7d68f62fb1 100644
--- a/src/mbgl/programs/background_program.cpp
+++ b/src/mbgl/programs/background_program.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/programs/background_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 #include <mbgl/renderer/image_atlas.hpp>
 #include <mbgl/renderer/cross_faded_property_evaluator.hpp>
 #include <mbgl/tile/tile_id.hpp>
@@ -6,20 +7,22 @@
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<BackgroundProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<BackgroundPatternProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 using namespace style;
 
 static_assert(sizeof(BackgroundLayoutVertex) == 4, "expected BackgroundLayoutVertex size");
 
-BackgroundPatternProgram::UniformValues
-BackgroundPatternProgram::uniformValues(mat4 matrix,
-                                  float opacity,
-                                  Size atlasSize,
-                                  const ImagePosition& a,
-                                  const ImagePosition& b,
-                                  const CrossfadeParameters& fading,
-                                  const UnwrappedTileID& tileID,
-                                  const TransformState& state)
-{
+BackgroundPatternProgram::LayoutUniformValues
+BackgroundPatternProgram::layoutUniformValues(mat4 matrix,
+                                              float opacity,
+                                              Size atlasSize,
+                                              const ImagePosition& a,
+                                              const ImagePosition& b,
+                                              const CrossfadeParameters& fading,
+                                              const UnwrappedTileID& tileID,
+                                              const TransformState& state) {
     int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z);
     int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z));
     int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y;
diff --git a/src/mbgl/programs/background_program.hpp b/src/mbgl/programs/background_program.hpp
index 9899fb695a..b1ade6dc84 100644
--- a/src/mbgl/programs/background_program.hpp
+++ b/src/mbgl/programs/background_program.hpp
@@ -4,14 +4,9 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/background.hpp>
-#include <mbgl/shaders/background_pattern.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/size.hpp>
-#include <mbgl/style/layers/background_layer_properties.hpp>
-
-#include <string>
 
 namespace mbgl {
 
@@ -45,8 +40,8 @@ using BackgroundPatternUniforms = TypeList<
     uniforms::u_tile_units_to_pixels>;
 
 class BackgroundProgram : public Program<
-    shaders::background,
-    gfx::Triangle,
+    BackgroundProgram,
+    gfx::PrimitiveType::Triangle,
     BackgroundLayoutAttributes,
     BackgroundUniforms,
     TypeList<>,
@@ -57,8 +52,8 @@ public:
 };
 
 class BackgroundPatternProgram : public Program<
-    shaders::background_pattern,
-    gfx::Triangle,
+    BackgroundPatternProgram,
+    gfx::PrimitiveType::Triangle,
     BackgroundLayoutAttributes,
     BackgroundPatternUniforms,
     TypeList<
@@ -68,22 +63,22 @@ class BackgroundPatternProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(mat4 matrix,
-                                       float opacity,
-                                       Size atlasSize,
-                                       const ImagePosition&,
-                                       const ImagePosition&,
-                                       const CrossfadeParameters&,
-                                       const UnwrappedTileID&,
-                                       const TransformState&);
+    static LayoutUniformValues layoutUniformValues(mat4 matrix,
+                                                   float opacity,
+                                                   Size atlasSize,
+                                                   const ImagePosition&,
+                                                   const ImagePosition&,
+                                                   const CrossfadeParameters&,
+                                                   const UnwrappedTileID&,
+                                                   const TransformState&);
 };
 
 using BackgroundLayoutVertex = BackgroundProgram::LayoutVertex;
-using BackgroundAttributes = BackgroundProgram::Attributes;
+using BackgroundAttributes = BackgroundProgram::AttributeList;
 
 class BackgroundLayerPrograms final : public LayerTypePrograms  {
 public:
-    BackgroundLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    BackgroundLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : background(context, programParameters),
           backgroundPattern(context, programParameters) {}
     BackgroundProgram background;
diff --git a/src/mbgl/programs/circle_program.cpp b/src/mbgl/programs/circle_program.cpp
index 99b47dd5c0..577410d94e 100644
--- a/src/mbgl/programs/circle_program.cpp
+++ b/src/mbgl/programs/circle_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/circle_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<CircleProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(CircleLayoutVertex) == 4, "expected CircleLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/circle_program.hpp b/src/mbgl/programs/circle_program.hpp
index 5a381d8fa9..0caa1b2a15 100644
--- a/src/mbgl/programs/circle_program.hpp
+++ b/src/mbgl/programs/circle_program.hpp
@@ -3,7 +3,6 @@
 #include <mbgl/programs/program.hpp>
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
-#include <mbgl/shaders/circle.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/style/layers/circle_layer_properties.hpp>
 
@@ -14,8 +13,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(bool, u_scale_with_map);
 } // namespace uniforms
 
 class CircleProgram : public Program<
-    shaders::circle,
-    gfx::Triangle,
+    CircleProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<
         attributes::a_pos>,
     TypeList<
@@ -47,11 +46,11 @@ public:
 };
 
 using CircleLayoutVertex = CircleProgram::LayoutVertex;
-using CircleAttributes = CircleProgram::Attributes;
+using CircleAttributes = CircleProgram::AttributeList;
 
 class CircleLayerPrograms final : public LayerTypePrograms  {
 public:
-    CircleLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    CircleLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : circle(context, programParameters) {}
     ProgramMap<CircleProgram> circle;
 };
diff --git a/src/mbgl/programs/clipping_mask_program.cpp b/src/mbgl/programs/clipping_mask_program.cpp
new file mode 100644
index 0000000000..9b1a9ef4fc
--- /dev/null
+++ b/src/mbgl/programs/clipping_mask_program.cpp
@@ -0,0 +1,8 @@
+#include <mbgl/programs/clipping_mask_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
+
+namespace mbgl {
+
+template std::unique_ptr<gfx::Program<ClippingMaskProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/clipping_mask_program.hpp b/src/mbgl/programs/clipping_mask_program.hpp
index 033d466116..874708a52f 100644
--- a/src/mbgl/programs/clipping_mask_program.hpp
+++ b/src/mbgl/programs/clipping_mask_program.hpp
@@ -3,14 +3,13 @@
 #include <mbgl/programs/program.hpp>
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
-#include <mbgl/shaders/clipping_mask.hpp>
 #include <mbgl/style/properties.hpp>
 
 namespace mbgl {
 
 class ClippingMaskProgram : public Program<
-    shaders::clipping_mask,
-    gfx::Triangle,
+    ClippingMaskProgram,
+    gfx::PrimitiveType::Triangle,
     PositionOnlyLayoutAttributes,
     TypeList<
         uniforms::u_matrix>,
@@ -22,6 +21,6 @@ public:
 };
 
 using ClippingMaskLayoutVertex = ClippingMaskProgram::LayoutVertex;
-using ClippingMaskAttributes = ClippingMaskProgram::Attributes;
+using ClippingMaskAttributes = ClippingMaskProgram::AttributeList;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/collision_box_program.cpp b/src/mbgl/programs/collision_box_program.cpp
index 584013640e..885894526e 100644
--- a/src/mbgl/programs/collision_box_program.cpp
+++ b/src/mbgl/programs/collision_box_program.cpp
@@ -1,7 +1,11 @@
 #include <mbgl/programs/collision_box_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<CollisionBoxProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<CollisionCircleProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(CollisionBoxProgram::LayoutVertex) == 24, "expected CollisionBoxVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/collision_box_program.hpp b/src/mbgl/programs/collision_box_program.hpp
index cd7f0bfd68..7b81752a94 100644
--- a/src/mbgl/programs/collision_box_program.hpp
+++ b/src/mbgl/programs/collision_box_program.hpp
@@ -3,8 +3,6 @@
 #include <mbgl/programs/program.hpp>
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
-#include <mbgl/shaders/collision_box.hpp>
-#include <mbgl/shaders/collision_circle.hpp>
 #include <mbgl/style/properties.hpp>
 #include <mbgl/util/geometry.hpp>
 
@@ -21,8 +19,8 @@ using CollisionBoxLayoutAttributes = TypeList<
 using CollisionBoxDynamicAttributes = TypeList<attributes::a_placed>;
 
 class CollisionBoxProgram : public Program<
-    shaders::collision_box,
-    gfx::Line,
+    CollisionBoxProgram,
+    gfx::PrimitiveType::Line,
     TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>,
     TypeList<
         uniforms::u_matrix,
@@ -62,48 +60,48 @@ public:
     }
 
 	template <class DrawMode>
-    void draw(gl::Context& context,
-              DrawMode drawMode,
-              gfx::DepthMode depthMode,
-              gfx::StencilMode stencilMode,
-              gfx::ColorMode colorMode,
-              gfx::CullFaceMode cullFaceMode,
-              const UniformValues& uniformValues,
+    void draw(gfx::Context& context,
+              const DrawMode& drawMode,
+              const gfx::DepthMode& depthMode,
+              const gfx::StencilMode& stencilMode,
+              const gfx::ColorMode& colorMode,
+              const gfx::CullFaceMode& cullFaceMode,
+              const LayoutUniformValues& layoutUniformValues,
               const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer,
               const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer,
               const gfx::IndexBuffer& indexBuffer,
-              const SegmentVector<Attributes>& segments,
+              const SegmentVector<AttributeList>& segments,
               const Binders& paintPropertyBinders,
               const typename PaintProperties::PossiblyEvaluated& currentProperties,
               const TextureBindings& textureBindings,
               float currentZoom,
               const std::string& layerID) {
-        typename AllUniforms::Values allUniformValues = uniformValues
+        UniformValues uniformValues = layoutUniformValues
             .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
 
-        typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer)
-            .concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer))
+        AttributeBindings allAttributeBindings = gfx::AttributeBindings<CollisionBoxLayoutAttributes>(layoutVertexBuffer)
+            .concat(gfx::AttributeBindings<CollisionBoxDynamicAttributes>(dynamicVertexBuffer))
             .concat(paintPropertyBinders.attributeBindings(currentProperties));
 
         assert(layoutVertexBuffer.elements == dynamicVertexBuffer.elements);
 
         for (auto& segment : segments) {
-            auto vertexArrayIt = segment.vertexArrays.find(layerID);
+            auto drawScopeIt = segment.drawScopes.find(layerID);
 
-            if (vertexArrayIt == segment.vertexArrays.end()) {
-                vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
+            if (drawScopeIt == segment.drawScopes.end()) {
+                drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first;
             }
 
-            program.draw(
+            program->draw(
                     context,
                     std::move(drawMode),
                     std::move(depthMode),
                     std::move(stencilMode),
                     std::move(colorMode),
                     std::move(cullFaceMode),
-                    allUniformValues,
-                    vertexArrayIt->second,
-                    Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
+                    uniformValues,
+                    drawScopeIt->second,
+                    allAttributeBindings.offset(segment.vertexOffset),
                     textureBindings,
                     indexBuffer,
                     segment.indexOffset,
@@ -114,8 +112,8 @@ public:
 
 
 class CollisionCircleProgram : public Program<
-    shaders::collision_circle,
-    gfx::Triangle,
+    CollisionCircleProgram,
+    gfx::PrimitiveType::Triangle,
     TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>,
     TypeList<
         uniforms::u_matrix,
@@ -150,46 +148,46 @@ public:
     }
 
     template <class DrawMode>
-    void draw(gl::Context& context,
-              DrawMode drawMode,
-              gfx::DepthMode depthMode,
-              gfx::StencilMode stencilMode,
-              gfx::ColorMode colorMode,
-              gfx::CullFaceMode cullFaceMode,
-              const UniformValues& uniformValues,
+    void draw(gfx::Context& context,
+              const DrawMode& drawMode,
+              const gfx::DepthMode& depthMode,
+              const gfx::StencilMode& stencilMode,
+              const gfx::ColorMode& colorMode,
+              const gfx::CullFaceMode& cullFaceMode,
+              const LayoutUniformValues& layoutUniformValues,
               const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer,
               const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer,
               const gfx::IndexBuffer& indexBuffer,
-              const SegmentVector<Attributes>& segments,
+              const SegmentVector<AttributeList>& segments,
               const Binders& paintPropertyBinders,
               const typename PaintProperties::PossiblyEvaluated& currentProperties,
               const TextureBindings& textureBindings,
               float currentZoom,
               const std::string& layerID) {
-        typename AllUniforms::Values allUniformValues = uniformValues
+        UniformValues uniformValues = layoutUniformValues
             .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
 
-        typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer)
-            .concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer))
+        AttributeBindings allAttributeBindings = gfx::AttributeBindings<CollisionBoxLayoutAttributes>(layoutVertexBuffer)
+            .concat(gfx::AttributeBindings<CollisionBoxDynamicAttributes>(dynamicVertexBuffer))
             .concat(paintPropertyBinders.attributeBindings(currentProperties));
 
         for (auto& segment : segments) {
-            auto vertexArrayIt = segment.vertexArrays.find(layerID);
+            auto drawScopeIt = segment.drawScopes.find(layerID);
 
-            if (vertexArrayIt == segment.vertexArrays.end()) {
-                vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
+            if (drawScopeIt == segment.drawScopes.end()) {
+                drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first;
             }
 
-            program.draw(
+            program->draw(
                     context,
                     std::move(drawMode),
                     std::move(depthMode),
                     std::move(stencilMode),
                     std::move(colorMode),
                     std::move(cullFaceMode),
-                    allUniformValues,
-                    vertexArrayIt->second,
-                    Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
+                    uniformValues,
+                    drawScopeIt->second,
+                    allAttributeBindings.offset(segment.vertexOffset),
                     textureBindings,
                     indexBuffer,
                     segment.indexOffset,
diff --git a/src/mbgl/programs/collision_circle_program.hpp b/src/mbgl/programs/collision_circle_program.hpp
new file mode 100644
index 0000000000..1fd36af360
--- /dev/null
+++ b/src/mbgl/programs/collision_circle_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/collision_box_program.hpp>
diff --git a/src/mbgl/programs/debug_program.cpp b/src/mbgl/programs/debug_program.cpp
new file mode 100644
index 0000000000..9b8df789e4
--- /dev/null
+++ b/src/mbgl/programs/debug_program.cpp
@@ -0,0 +1,8 @@
+#include <mbgl/programs/debug_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
+
+namespace mbgl {
+
+template std::unique_ptr<gfx::Program<DebugProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/debug_program.hpp b/src/mbgl/programs/debug_program.hpp
index 7fdfc84cc0..61125b55bf 100644
--- a/src/mbgl/programs/debug_program.hpp
+++ b/src/mbgl/programs/debug_program.hpp
@@ -3,14 +3,13 @@
 #include <mbgl/programs/program.hpp>
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
-#include <mbgl/shaders/debug.hpp>
 #include <mbgl/style/properties.hpp>
 
 namespace mbgl {
 
 class DebugProgram : public Program<
-    shaders::debug,
-    gfx::Line,
+    DebugProgram,
+    gfx::PrimitiveType::Line,
     TypeList<
         attributes::a_pos>,
     TypeList<
@@ -24,6 +23,6 @@ public:
 };
 
 using DebugLayoutVertex = DebugProgram::LayoutVertex;
-using DebugAttributes = DebugProgram::Attributes;
+using DebugAttributes = DebugProgram::AttributeList;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/extrusion_texture_program.cpp b/src/mbgl/programs/extrusion_texture_program.cpp
index afda4384b7..50fcd76221 100644
--- a/src/mbgl/programs/extrusion_texture_program.cpp
+++ b/src/mbgl/programs/extrusion_texture_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/extrusion_texture_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<ExtrusionTextureProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(ExtrusionTextureLayoutVertex) == 4, "expected ExtrusionTextureLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/extrusion_texture_program.hpp b/src/mbgl/programs/extrusion_texture_program.hpp
index 8281037b2a..bdeeabb8cd 100644
--- a/src/mbgl/programs/extrusion_texture_program.hpp
+++ b/src/mbgl/programs/extrusion_texture_program.hpp
@@ -4,15 +4,14 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/extrusion_texture.hpp>
 #include <mbgl/style/properties.hpp>
 #include <mbgl/util/geometry.hpp>
 
 namespace mbgl {
 
 class ExtrusionTextureProgram : public Program<
-    shaders::extrusion_texture,
-    gfx::Triangle,
+    ExtrusionTextureProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<attributes::a_pos>,
     TypeList<
         uniforms::u_matrix,
@@ -35,6 +34,6 @@ public:
 };
 
 using ExtrusionTextureLayoutVertex = ExtrusionTextureProgram::LayoutVertex;
-using ExtrusionTextureAttributes = ExtrusionTextureProgram::Attributes;
+using ExtrusionTextureAttributes = ExtrusionTextureProgram::AttributeList;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/fill_extrusion_pattern_program.hpp b/src/mbgl/programs/fill_extrusion_pattern_program.hpp
new file mode 100644
index 0000000000..b723ce0614
--- /dev/null
+++ b/src/mbgl/programs/fill_extrusion_pattern_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/fill_extrusion_program.hpp>
diff --git a/src/mbgl/programs/fill_extrusion_program.cpp b/src/mbgl/programs/fill_extrusion_program.cpp
index fb9c9f7b4a..7688d09299 100644
--- a/src/mbgl/programs/fill_extrusion_program.cpp
+++ b/src/mbgl/programs/fill_extrusion_program.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/programs/fill_extrusion_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 #include <mbgl/renderer/image_atlas.hpp>
 #include <mbgl/renderer/cross_faded_property_evaluator.hpp>
 #include <mbgl/tile/tile_id.hpp>
@@ -7,6 +8,9 @@
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<FillExtrusionProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<FillExtrusionPatternProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 using namespace style;
 
 static_assert(sizeof(FillExtrusionLayoutVertex) == 12, "expected FillExtrusionLayoutVertex size");
@@ -31,10 +35,8 @@ float lightIntensity(const EvaluatedLight& light) {
     return light.get<LightIntensity>();
 }
 
-FillExtrusionProgram::UniformValues
-FillExtrusionProgram::uniformValues(mat4 matrix,
-                                    const TransformState& state,
-                                    const EvaluatedLight& light) {
+FillExtrusionProgram::LayoutUniformValues FillExtrusionProgram::layoutUniformValues(
+    mat4 matrix, const TransformState& state, const EvaluatedLight& light) {
     return {
         uniforms::u_matrix::Value( matrix ),
         uniforms::u_lightcolor::Value( lightColor(light) ),
@@ -43,8 +45,8 @@ FillExtrusionProgram::uniformValues(mat4 matrix,
     };
 }
 
-FillExtrusionPatternProgram::UniformValues
-FillExtrusionPatternProgram::uniformValues(mat4 matrix,
+FillExtrusionPatternProgram::LayoutUniformValues
+FillExtrusionPatternProgram::layoutUniformValues(mat4 matrix,
                                            Size atlasSize,
                                            const CrossfadeParameters& crossfade,
                                            const UnwrappedTileID& tileID,
diff --git a/src/mbgl/programs/fill_extrusion_program.hpp b/src/mbgl/programs/fill_extrusion_program.hpp
index 0723770143..e1c3ca7f17 100644
--- a/src/mbgl/programs/fill_extrusion_program.hpp
+++ b/src/mbgl/programs/fill_extrusion_program.hpp
@@ -5,8 +5,6 @@
 #include <mbgl/programs/extrusion_texture_program.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/fill_extrusion.hpp>
-#include <mbgl/shaders/fill_extrusion_pattern.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/size.hpp>
@@ -53,8 +51,8 @@ using FillExtrusionPatternUniforms = TypeList<
     uniforms::u_lightintensity>;
 
 class FillExtrusionProgram : public Program<
-    shaders::fill_extrusion,
-    gfx::Triangle,
+    FillExtrusionProgram,
+    gfx::PrimitiveType::Triangle,
     FillExtrusionLayoutAttributes,
     FillExtrusionUniforms,
     TypeList<>,
@@ -83,15 +81,13 @@ public:
         };
     }
 
-    static UniformValues uniformValues(mat4,
-                                       const TransformState&,
-                                       const EvaluatedLight&);
-
+    static LayoutUniformValues
+    layoutUniformValues(mat4, const TransformState&, const EvaluatedLight&);
 };
 
 class FillExtrusionPatternProgram : public Program<
-    shaders::fill_extrusion_pattern,
-    gfx::Triangle,
+    FillExtrusionPatternProgram,
+    gfx::PrimitiveType::Triangle,
     FillExtrusionLayoutAttributes,
     FillExtrusionPatternUniforms,
     TypeList<
@@ -101,23 +97,23 @@ class FillExtrusionPatternProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(mat4,
-                                       Size atlasSize,
-                                       const CrossfadeParameters&,
-                                       const UnwrappedTileID&,
-                                       const TransformState&,
-                                       const float heightFactor,
-                                       const float pixelRatio,
-                                       const EvaluatedLight&);
+    static LayoutUniformValues layoutUniformValues(mat4,
+                                                   Size atlasSize,
+                                                   const CrossfadeParameters&,
+                                                   const UnwrappedTileID&,
+                                                   const TransformState&,
+                                                   const float heightFactor,
+                                                   const float pixelRatio,
+                                                   const EvaluatedLight&);
 };
 
 using FillExtrusionLayoutVertex = FillExtrusionProgram::LayoutVertex;
-using FillExtrusionAttributes = FillExtrusionProgram::Attributes;
+using FillExtrusionAttributes = FillExtrusionProgram::AttributeList;
 
 
 class FillExtrusionLayerPrograms final : public LayerTypePrograms {
 public:
-    FillExtrusionLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    FillExtrusionLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : fillExtrusion(context, programParameters),
           fillExtrusionPattern(context, programParameters),
           extrusionTexture(context, programParameters) {}
diff --git a/src/mbgl/programs/fill_outline_pattern_program.hpp b/src/mbgl/programs/fill_outline_pattern_program.hpp
new file mode 100644
index 0000000000..a2c26a168d
--- /dev/null
+++ b/src/mbgl/programs/fill_outline_pattern_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/fill_program.hpp>
diff --git a/src/mbgl/programs/fill_outline_program.hpp b/src/mbgl/programs/fill_outline_program.hpp
new file mode 100644
index 0000000000..a2c26a168d
--- /dev/null
+++ b/src/mbgl/programs/fill_outline_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/fill_program.hpp>
diff --git a/src/mbgl/programs/fill_pattern_program.hpp b/src/mbgl/programs/fill_pattern_program.hpp
new file mode 100644
index 0000000000..a2c26a168d
--- /dev/null
+++ b/src/mbgl/programs/fill_pattern_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/fill_program.hpp>
diff --git a/src/mbgl/programs/fill_program.cpp b/src/mbgl/programs/fill_program.cpp
index 2c290dd15d..e0dfc71f81 100644
--- a/src/mbgl/programs/fill_program.cpp
+++ b/src/mbgl/programs/fill_program.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/programs/fill_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 #include <mbgl/renderer/image_atlas.hpp>
 #include <mbgl/renderer/cross_faded_property_evaluator.hpp>
 #include <mbgl/tile/tile_id.hpp>
@@ -6,19 +7,23 @@
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<FillProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<FillPatternProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<FillOutlineProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<FillOutlinePatternProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 using namespace style;
 
 static_assert(sizeof(FillLayoutVertex) == 4, "expected FillLayoutVertex size");
 
-FillPatternProgram::UniformValues
-FillPatternProgram::uniformValues(mat4 matrix,
-                            Size framebufferSize,
-                            Size atlasSize,
-                            const CrossfadeParameters& crossfade,
-                            const UnwrappedTileID& tileID,
-                            const TransformState& state,
-                            const float pixelRatio)
-{
+FillPatternProgram::LayoutUniformValues
+FillPatternProgram::layoutUniformValues(mat4 matrix,
+                                        Size framebufferSize,
+                                        Size atlasSize,
+                                        const CrossfadeParameters& crossfade,
+                                        const UnwrappedTileID& tileID,
+                                        const TransformState& state,
+                                        const float pixelRatio) {
     const auto tileRatio = 1 / tileID.pixelsToTileUnits(1, state.getIntegerZoom());
     int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z);
     int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z));
diff --git a/src/mbgl/programs/fill_program.hpp b/src/mbgl/programs/fill_program.hpp
index 5c0fbdcb62..8519e482d6 100644
--- a/src/mbgl/programs/fill_program.hpp
+++ b/src/mbgl/programs/fill_program.hpp
@@ -4,10 +4,6 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/fill.hpp>
-#include <mbgl/shaders/fill_pattern.hpp>
-#include <mbgl/shaders/fill_outline.hpp>
-#include <mbgl/shaders/fill_outline_pattern.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/size.hpp>
@@ -38,8 +34,8 @@ using FillPatternUniforms = TypeList<
     uniforms::u_pixel_coord_lower>;
 
 class FillProgram : public Program<
-    shaders::fill,
-    gfx::Triangle,
+    FillProgram,
+    gfx::PrimitiveType::Triangle,
     FillLayoutAttributes,
     FillUniforms,
     TypeList<>,
@@ -59,8 +55,8 @@ public:
 };
 
 class FillPatternProgram : public Program<
-    shaders::fill_pattern,
-    gfx::Triangle,
+    FillPatternProgram,
+    gfx::PrimitiveType::Triangle,
     FillLayoutAttributes,
     FillPatternUniforms,
     TypeList<
@@ -70,18 +66,18 @@ class FillPatternProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(mat4 matrix,
-                                       Size framebufferSize,
-                                       Size atlasSize,
-                                       const CrossfadeParameters& crossfade,
-                                       const UnwrappedTileID&,
-                                       const TransformState&,
-                                       const float pixelRatio);
+    static LayoutUniformValues layoutUniformValues(mat4 matrix,
+                                                   Size framebufferSize,
+                                                   Size atlasSize,
+                                                   const CrossfadeParameters& crossfade,
+                                                   const UnwrappedTileID&,
+                                                   const TransformState&,
+                                                   const float pixelRatio);
 };
 
 class FillOutlineProgram : public Program<
-    shaders::fill_outline,
-    gfx::Line,
+    FillOutlineProgram,
+    gfx::PrimitiveType::Line,
     FillLayoutAttributes,
     FillUniforms,
     TypeList<>,
@@ -92,8 +88,8 @@ public:
 };
 
 class FillOutlinePatternProgram : public Program<
-    shaders::fill_outline_pattern,
-    gfx::Line,
+    FillOutlinePatternProgram,
+    gfx::PrimitiveType::Line,
     FillLayoutAttributes,
     FillPatternUniforms,
     TypeList<
@@ -105,11 +101,11 @@ public:
 };
 
 using FillLayoutVertex = FillProgram::LayoutVertex;
-using FillAttributes = FillProgram::Attributes;
+using FillAttributes = FillProgram::AttributeList;
 
 class FillLayerPrograms final : public LayerTypePrograms {
 public:
-    FillLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    FillLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : fill(context, programParameters),
           fillPattern(context, programParameters),
           fillOutline(context, programParameters),
diff --git a/src/mbgl/programs/gl/background.cpp b/src/mbgl/programs/gl/background.cpp
new file mode 100644
index 0000000000..da5ea25410
--- /dev/null
+++ b/src/mbgl/programs/gl/background.cpp
@@ -0,0 +1,47 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/background_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<BackgroundProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<BackgroundProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "background",
+        programs::gl::shaderSource() + 1429, programs::gl::shaderSource() + 1525);
+}
+
+} // namespace gfx
+} // namespace mbgl
+
+// Uncompressed source of background.vertex.glsl:
+/*
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+}
+
+*/
+
+// Uncompressed source of background.fragment.glsl:
+/*
+uniform vec4 u_color;
+uniform float u_opacity;
+
+void main() {
+    gl_FragColor = u_color * u_opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}
+
+*/
+
diff --git a/src/mbgl/shaders/background_pattern.cpp b/src/mbgl/programs/gl/background_pattern.cpp
index 35023455ea..af5d87129e 100644
--- a/src/mbgl/shaders/background_pattern.cpp
+++ b/src/mbgl/programs/gl/background_pattern.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/background_pattern.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/background_pattern_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<BackgroundPatternProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<BackgroundPatternProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "background_pattern",
+        programs::gl::shaderSource() + 1675, programs::gl::shaderSource() + 2266);
+}
 
-const char* background_pattern::name = "background_pattern";
-const char* background_pattern::vertexSource = source() + 1675;
-const char* background_pattern::fragmentSource = source() + 2266;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of background_pattern.vertex.glsl:
 /*
@@ -68,5 +76,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/circle.cpp b/src/mbgl/programs/gl/circle.cpp
index e5da9fb37e..04c3f60870 100644
--- a/src/mbgl/shaders/circle.cpp
+++ b/src/mbgl/programs/gl/circle.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/circle.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/circle_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<CircleProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<CircleProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "circle",
+        programs::gl::shaderSource() + 2927, programs::gl::shaderSource() + 6093);
+}
 
-const char* circle::name = "circle";
-const char* circle::vertexSource = source() + 2927;
-const char* circle::fragmentSource = source() + 6093;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of circle.vertex.glsl:
 /*
@@ -290,5 +298,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/programs/gl/clipping_mask.cpp b/src/mbgl/programs/gl/clipping_mask.cpp
new file mode 100644
index 0000000000..311877f065
--- /dev/null
+++ b/src/mbgl/programs/gl/clipping_mask.cpp
@@ -0,0 +1,40 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/clipping_mask_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<ClippingMaskProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<ClippingMaskProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "clipping_mask",
+        programs::gl::shaderSource() + 7848, programs::gl::shaderSource() + 7944);
+}
+
+} // namespace gfx
+} // namespace mbgl
+
+// Uncompressed source of clipping_mask.vertex.glsl:
+/*
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+}
+
+*/
+
+// Uncompressed source of clipping_mask.fragment.glsl:
+/*
+void main() {
+    gl_FragColor = vec4(1.0);
+}
+
+*/
+
diff --git a/src/mbgl/shaders/collision_box.cpp b/src/mbgl/programs/gl/collision_box.cpp
index b016d48cc8..9af67f7981 100644
--- a/src/mbgl/shaders/collision_box.cpp
+++ b/src/mbgl/programs/gl/collision_box.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/collision_box.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/collision_box_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<CollisionBoxProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<CollisionBoxProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "collision_box",
+        programs::gl::shaderSource() + 9956, programs::gl::shaderSource() + 10635);
+}
 
-const char* collision_box::name = "collision_box";
-const char* collision_box::vertexSource = source() + 9956;
-const char* collision_box::fragmentSource = source() + 10635;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of collision_box.vertex.glsl:
 /*
@@ -67,5 +75,3 @@ void main() {
 }
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/collision_circle.cpp b/src/mbgl/programs/gl/collision_circle.cpp
index 0700ecead5..843f9161bb 100644
--- a/src/mbgl/shaders/collision_circle.cpp
+++ b/src/mbgl/programs/gl/collision_circle.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/collision_circle.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/collision_circle_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<CollisionCircleProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<CollisionCircleProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "collision_circle",
+        programs::gl::shaderSource() + 10858, programs::gl::shaderSource() + 11774);
+}
 
-const char* collision_circle::name = "collision_circle";
-const char* collision_circle::vertexSource = source() + 10858;
-const char* collision_circle::fragmentSource = source() + 11774;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of collision_circle.vertex.glsl:
 /*
@@ -90,5 +98,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/programs/gl/debug.cpp b/src/mbgl/programs/gl/debug.cpp
new file mode 100644
index 0000000000..8b7aee5a0b
--- /dev/null
+++ b/src/mbgl/programs/gl/debug.cpp
@@ -0,0 +1,42 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/debug_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<DebugProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<DebugProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "debug",
+        programs::gl::shaderSource() + 12450, programs::gl::shaderSource() + 12546);
+}
+
+} // namespace gfx
+} // namespace mbgl
+
+// Uncompressed source of debug.vertex.glsl:
+/*
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+}
+
+*/
+
+// Uncompressed source of debug.fragment.glsl:
+/*
+uniform highp vec4 u_color;
+
+void main() {
+    gl_FragColor = u_color;
+}
+
+*/
+
diff --git a/src/mbgl/shaders/extrusion_texture.cpp b/src/mbgl/programs/gl/extrusion_texture.cpp
index c254413513..bd320d52cf 100644
--- a/src/mbgl/shaders/extrusion_texture.cpp
+++ b/src/mbgl/programs/gl/extrusion_texture.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/extrusion_texture.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/extrusion_texture_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<ExtrusionTextureProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<ExtrusionTextureProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "extrusion_texture",
+        programs::gl::shaderSource() + 27554, programs::gl::shaderSource() + 27734);
+}
 
-const char* extrusion_texture::name = "extrusion_texture";
-const char* extrusion_texture::vertexSource = source() + 27554;
-const char* extrusion_texture::fragmentSource = source() + 27734;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of extrusion_texture.vertex.glsl:
 /*
@@ -42,5 +50,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill.cpp b/src/mbgl/programs/gl/fill.cpp
index 93d69f7e4b..c15c2774ab 100644
--- a/src/mbgl/shaders/fill.cpp
+++ b/src/mbgl/programs/gl/fill.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill",
+        programs::gl::shaderSource() + 12610, programs::gl::shaderSource() + 13254);
+}
 
-const char* fill::name = "fill";
-const char* fill::vertexSource = source() + 12610;
-const char* fill::fragmentSource = source() + 13254;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill.vertex.glsl:
 /*
@@ -94,5 +102,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion.cpp b/src/mbgl/programs/gl/fill_extrusion.cpp
index 79241afcc3..45ebb68dd4 100644
--- a/src/mbgl/shaders/fill_extrusion.cpp
+++ b/src/mbgl/programs/gl/fill_extrusion.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill_extrusion.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_extrusion_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillExtrusionProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillExtrusionProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill_extrusion",
+        programs::gl::shaderSource() + 21238, programs::gl::shaderSource() + 23121);
+}
 
-const char* fill_extrusion::name = "fill_extrusion";
-const char* fill_extrusion::vertexSource = source() + 21238;
-const char* fill_extrusion::fragmentSource = source() + 23121;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill_extrusion.vertex.glsl:
 /*
@@ -132,5 +140,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion_pattern.cpp b/src/mbgl/programs/gl/fill_extrusion_pattern.cpp
index 8ac17828cf..9c2da87b11 100644
--- a/src/mbgl/shaders/fill_extrusion_pattern.cpp
+++ b/src/mbgl/programs/gl/fill_extrusion_pattern.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill_extrusion_pattern.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_extrusion_pattern_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillExtrusionPatternProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillExtrusionPatternProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill_extrusion_pattern",
+        programs::gl::shaderSource() + 23237, programs::gl::shaderSource() + 26157);
+}
 
-const char* fill_extrusion_pattern::name = "fill_extrusion_pattern";
-const char* fill_extrusion_pattern::vertexSource = source() + 23237;
-const char* fill_extrusion_pattern::fragmentSource = source() + 26157;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill_extrusion_pattern.vertex.glsl:
 /*
@@ -231,5 +239,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline.cpp b/src/mbgl/programs/gl/fill_outline.cpp
index 43d92857d5..07615b2138 100644
--- a/src/mbgl/shaders/fill_outline.cpp
+++ b/src/mbgl/programs/gl/fill_outline.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill_outline.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_outline_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillOutlineProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillOutlineProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill_outline",
+        programs::gl::shaderSource() + 13678, programs::gl::shaderSource() + 14503);
+}
 
-const char* fill_outline::name = "fill_outline";
-const char* fill_outline::vertexSource = source() + 13678;
-const char* fill_outline::fragmentSource = source() + 14503;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill_outline.vertex.glsl:
 /*
@@ -102,5 +110,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline_pattern.cpp b/src/mbgl/programs/gl/fill_outline_pattern.cpp
index eeb2177582..7e0bf19655 100644
--- a/src/mbgl/shaders/fill_outline_pattern.cpp
+++ b/src/mbgl/programs/gl/fill_outline_pattern.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill_outline_pattern.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_outline_pattern_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillOutlinePatternProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillOutlinePatternProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill_outline_pattern",
+        programs::gl::shaderSource() + 15092, programs::gl::shaderSource() + 16952);
+}
 
-const char* fill_outline_pattern::name = "fill_outline_pattern";
-const char* fill_outline_pattern::vertexSource = source() + 15092;
-const char* fill_outline_pattern::fragmentSource = source() + 16952;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill_outline_pattern.vertex.glsl:
 /*
@@ -176,5 +184,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_pattern.cpp b/src/mbgl/programs/gl/fill_pattern.cpp
index d062ae7ecc..256b1ede99 100644
--- a/src/mbgl/shaders/fill_pattern.cpp
+++ b/src/mbgl/programs/gl/fill_pattern.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/fill_pattern.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/fill_pattern_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<FillPatternProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<FillPatternProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "fill_pattern",
+        programs::gl::shaderSource() + 18259, programs::gl::shaderSource() + 20038);
+}
 
-const char* fill_pattern::name = "fill_pattern";
-const char* fill_pattern::vertexSource = source() + 18259;
-const char* fill_pattern::fragmentSource = source() + 20038;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of fill_pattern.vertex.glsl:
 /*
@@ -164,5 +172,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap.cpp b/src/mbgl/programs/gl/heatmap.cpp
index a768a6d4ad..59f8ad9f69 100644
--- a/src/mbgl/shaders/heatmap.cpp
+++ b/src/mbgl/programs/gl/heatmap.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/heatmap.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/heatmap_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<HeatmapProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<HeatmapProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "heatmap",
+        programs::gl::shaderSource() + 7983, programs::gl::shaderSource() + 9030);
+}
 
-const char* heatmap::name = "heatmap";
-const char* heatmap::vertexSource = source() + 7983;
-const char* heatmap::fragmentSource = source() + 9030;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of heatmap.vertex.glsl:
 /*
@@ -131,5 +139,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap_texture.cpp b/src/mbgl/programs/gl/heatmap_texture.cpp
index 9b881b416f..530e9fa18b 100644
--- a/src/mbgl/shaders/heatmap_texture.cpp
+++ b/src/mbgl/programs/gl/heatmap_texture.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/heatmap_texture.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/heatmap_texture_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<HeatmapTextureProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<HeatmapTextureProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "heatmap_texture",
+        programs::gl::shaderSource() + 9491, programs::gl::shaderSource() + 9671);
+}
 
-const char* heatmap_texture::name = "heatmap_texture";
-const char* heatmap_texture::vertexSource = source() + 9491;
-const char* heatmap_texture::fragmentSource = source() + 9671;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of heatmap_texture.vertex.glsl:
 /*
@@ -45,5 +53,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade.cpp b/src/mbgl/programs/gl/hillshade.cpp
index 48ddabcba1..dcf90f1149 100644
--- a/src/mbgl/shaders/hillshade.cpp
+++ b/src/mbgl/programs/gl/hillshade.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/hillshade.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/hillshade_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<HillshadeProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<HillshadeProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "hillshade",
+        programs::gl::shaderSource() + 29340, programs::gl::shaderSource() + 29511);
+}
 
-const char* hillshade::name = "hillshade";
-const char* hillshade::vertexSource = source() + 29340;
-const char* hillshade::fragmentSource = source() + 29511;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of hillshade.vertex.glsl:
 /*
@@ -83,5 +91,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade_prepare.cpp b/src/mbgl/programs/gl/hillshade_prepare.cpp
index 9517e1f489..b445713530 100644
--- a/src/mbgl/shaders/hillshade_prepare.cpp
+++ b/src/mbgl/programs/gl/hillshade_prepare.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/hillshade_prepare.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/hillshade_prepare_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<HillshadePrepareProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<HillshadePrepareProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "hillshade_prepare",
+        programs::gl::shaderSource() + 27925, programs::gl::shaderSource() + 28218);
+}
 
-const char* hillshade_prepare::name = "hillshade_prepare";
-const char* hillshade_prepare::vertexSource = source() + 27925;
-const char* hillshade_prepare::fragmentSource = source() + 28218;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of hillshade_prepare.vertex.glsl:
 /*
@@ -107,5 +115,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line.cpp b/src/mbgl/programs/gl/line.cpp
index a7f2a6d439..c25679ae1f 100644
--- a/src/mbgl/shaders/line.cpp
+++ b/src/mbgl/programs/gl/line.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/line.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/line_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<LineProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<LineProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "line",
+        programs::gl::shaderSource() + 30585, programs::gl::shaderSource() + 33509);
+}
 
-const char* line::name = "line";
-const char* line::vertexSource = source() + 30585;
-const char* line::fragmentSource = source() + 33509;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of line.vertex.glsl:
 /*
@@ -243,5 +251,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_gradient.cpp b/src/mbgl/programs/gl/line_gradient.cpp
index d9ce2af7b1..fae94b4596 100644
--- a/src/mbgl/shaders/line_gradient.cpp
+++ b/src/mbgl/programs/gl/line_gradient.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/line_gradient.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/line_gradient_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<LineGradientProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<LineGradientProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "line_gradient",
+        programs::gl::shaderSource() + 34335, programs::gl::shaderSource() + 37054);
+}
 
-const char* line_gradient::name = "line_gradient";
-const char* line_gradient::vertexSource = source() + 34335;
-const char* line_gradient::fragmentSource = source() + 37054;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of line_gradient.vertex.glsl:
 /*
@@ -225,5 +233,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_pattern.cpp b/src/mbgl/programs/gl/line_pattern.cpp
index 2c05c8c7ec..2e9ebaf5ea 100644
--- a/src/mbgl/shaders/line_pattern.cpp
+++ b/src/mbgl/programs/gl/line_pattern.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/line_pattern.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/line_pattern_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<LinePatternProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<LinePatternProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "line_pattern",
+        programs::gl::shaderSource() + 37841, programs::gl::shaderSource() + 41162);
+}
 
-const char* line_pattern::name = "line_pattern";
-const char* line_pattern::vertexSource = source() + 37841;
-const char* line_pattern::fragmentSource = source() + 41162;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of line_pattern.vertex.glsl:
 /*
@@ -312,5 +320,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_sdf.cpp b/src/mbgl/programs/gl/line_sdf.cpp
index 05695abd1b..0886bfcdf0 100644
--- a/src/mbgl/shaders/line_sdf.cpp
+++ b/src/mbgl/programs/gl/line_sdf.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/line_sdf.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/line_sdf_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<LineSDFProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<LineSDFProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "line_sdf",
+        programs::gl::shaderSource() + 43475, programs::gl::shaderSource() + 47089);
+}
 
-const char* line_sdf::name = "line_sdf";
-const char* line_sdf::vertexSource = source() + 43475;
-const char* line_sdf::fragmentSource = source() + 47089;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of line_sdf.vertex.glsl:
 /*
@@ -305,5 +313,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/programs/gl/preludes.cpp b/src/mbgl/programs/gl/preludes.cpp
new file mode 100644
index 0000000000..6c895c0d36
--- /dev/null
+++ b/src/mbgl/programs/gl/preludes.cpp
@@ -0,0 +1,15 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/gl/preludes.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+
+namespace mbgl {
+namespace programs {
+namespace gl {
+
+const char* vertexShaderPrelude = programs::gl::shaderSource() + 0;
+const char* fragmentShaderPrelude = programs::gl::shaderSource() + 1252;
+
+} // namespace gl
+} // namespace programs
+} // namespace mbgl
diff --git a/src/mbgl/programs/gl/preludes.hpp b/src/mbgl/programs/gl/preludes.hpp
new file mode 100644
index 0000000000..6d86ee45c5
--- /dev/null
+++ b/src/mbgl/programs/gl/preludes.hpp
@@ -0,0 +1,14 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#pragma once
+
+namespace mbgl {
+namespace programs {
+namespace gl {
+
+extern const char* vertexShaderPrelude;
+extern const char* fragmentShaderPrelude;
+
+} // namespace gl
+} // namespace programs
+} // namespace mbgl
diff --git a/src/mbgl/shaders/raster.cpp b/src/mbgl/programs/gl/raster.cpp
index 9fcf995915..512dc81a30 100644
--- a/src/mbgl/shaders/raster.cpp
+++ b/src/mbgl/programs/gl/raster.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/raster.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/raster_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<RasterProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<RasterProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "raster",
+        programs::gl::shaderSource() + 48592, programs::gl::shaderSource() + 48941);
+}
 
-const char* raster::name = "raster";
-const char* raster::vertexSource = source() + 48592;
-const char* raster::fragmentSource = source() + 48941;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of raster.vertex.glsl:
 /*
@@ -93,5 +101,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/programs/gl/shader_source.cpp b/src/mbgl/programs/gl/shader_source.cpp
new file mode 100644
index 0000000000..4a986403f7
--- /dev/null
+++ b/src/mbgl/programs/gl/shader_source.cpp
@@ -0,0 +1,471 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
+
+namespace mbgl {
+namespace programs {
+namespace gl {
+
+constexpr const uint8_t compressedShaderSource[] = {
+    0x78, 0xda, 0xed, 0x3d, 0xfd, 0x6f, 0xe3, 0x36, 0xb2, 0xf7, 0x73, 0xfe, 0x0a, 0x17, 0x05, 0x0e,
+    0x92, 0x2c, 0x5b, 0xb6, 0x93, 0xec, 0x97, 0x4e, 0xaf, 0x08, 0x76, 0xb3, 0x7d, 0x01, 0xda, 0xdd,
+    0x60, 0xd3, 0xf6, 0x15, 0x57, 0x2c, 0x0c, 0xc9, 0x56, 0x6c, 0xdf, 0xd9, 0x96, 0x9f, 0xad, 0x24,
+    0x76, 0x0e, 0xf9, 0xdf, 0x1f, 0x87, 0xdf, 0xa4, 0x48, 0x59, 0x76, 0x12, 0xe7, 0xe3, 0x19, 0x45,
+    0x37, 0x16, 0x39, 0x1c, 0x0e, 0xc9, 0xe1, 0x70, 0x66, 0x48, 0x0e, 0x7f, 0x1c, 0x5d, 0xf6, 0xd3,
+    0xcb, 0xda, 0xcf, 0xbf, 0x74, 0x4f, 0x2f, 0x0e, 0x66, 0xf3, 0xb4, 0x37, 0x5a, 0x8c, 0xb2, 0x69,
+    0x6d, 0x38, 0x1a, 0x0c, 0x67, 0xb5, 0xcb, 0x71, 0x16, 0xe7, 0xe1, 0xc1, 0x8f, 0xe9, 0x78, 0x91,
+    0x1e, 0xfc, 0x38, 0xba, 0xac, 0xfd, 0x80, 0x60, 0x47, 0xd3, 0xb4, 0xef, 0x8c, 0xb3, 0x9b, 0x99,
+    0x7b, 0xf0, 0x23, 0xf9, 0xac, 0xc1, 0x17, 0x82, 0x9a, 0xf6, 0x47, 0x97, 0x2a, 0xd8, 0x24, 0xed,
+    0x8f, 0xae, 0x26, 0x12, 0x24, 0x4d, 0x30, 0x02, 0xe3, 0x3a, 0x05, 0x28, 0xfe, 0xe4, 0x80, 0xe4,
+    0xcf, 0x75, 0xda, 0xeb, 0xd4, 0xae, 0xa6, 0xb3, 0xb8, 0xf7, 0xef, 0x2e, 0x26, 0xce, 0xe9, 0x65,
+    0xd3, 0x45, 0x4e, 0x08, 0xad, 0x41, 0x72, 0xda, 0xff, 0x23, 0x1e, 0x5f, 0xa5, 0x6e, 0xed, 0x3f,
+    0xa3, 0x29, 0x4b, 0x39, 0x9b, 0xe6, 0x38, 0x31, 0x42, 0x49, 0x8e, 0x0c, 0x14, 0x02, 0xcc, 0x75,
+    0x2b, 0x52, 0xc1, 0x82, 0xce, 0xf1, 0x9b, 0x70, 0x9e, 0xe6, 0x57, 0xf3, 0x69, 0x0d, 0x2a, 0x74,
+    0xae, 0x5b, 0xbe, 0x0a, 0xd1, 0xb8, 0x6e, 0x79, 0x08, 0xc8, 0x0d, 0xef, 0x64, 0x82, 0x32, 0xf4,
+    0xef, 0x28, 0x5f, 0x19, 0x48, 0xfa, 0x4a, 0x72, 0x28, 0x51, 0xe8, 0x7f, 0x9a, 0x20, 0x11, 0xc4,
+    0x40, 0x82, 0x8e, 0x52, 0x35, 0x69, 0xa4, 0x28, 0xe1, 0x06, 0xed, 0xce, 0xdb, 0x66, 0xcb, 0x9f,
+    0x64, 0x7d, 0xb5, 0xa0, 0xdf, 0x69, 0xb6, 0x5c, 0x42, 0xd0, 0x51, 0xad, 0x9f, 0xf6, 0xb2, 0x7e,
+    0xda, 0xed, 0x65, 0xe3, 0x6c, 0x4e, 0xc9, 0xc1, 0x84, 0xa6, 0x53, 0x48, 0xef, 0x7f, 0x84, 0x74,
+    0x44, 0x8c, 0xa8, 0xe8, 0xc8, 0x51, 0x3a, 0x55, 0x86, 0xfb, 0xab, 0xf5, 0x1d, 0x11, 0x75, 0x7c,
+    0x8c, 0x2a, 0xb5, 0xc3, 0xb4, 0x19, 0xcc, 0x01, 0x22, 0x81, 0xb4, 0x9c, 0x02, 0x4f, 0x46, 0xcb,
+    0x2e, 0x6e, 0x89, 0x44, 0x86, 0x34, 0x04, 0xbe, 0xdc, 0x59, 0xb9, 0xa0, 0x09, 0x15, 0x93, 0x47,
+    0x0a, 0x11, 0xe1, 0xcb, 0x9f, 0xed, 0xef, 0x7e, 0xce, 0x1a, 0x2b, 0x55, 0xa4, 0x35, 0xf8, 0x88,
+    0xd6, 0x84, 0x69, 0x5c, 0x14, 0xaa, 0xc2, 0x10, 0x93, 0xd1, 0x14, 0x67, 0x47, 0x4a, 0x9f, 0x61,
+    0x8a, 0xe5, 0xc2, 0x82, 0x00, 0xfa, 0x8d, 0x5a, 0xec, 0x86, 0x04, 0x43, 0xbc, 0xac, 0x84, 0xa1,
+    0xa3, 0x61, 0x38, 0x04, 0x0c, 0x52, 0x73, 0x19, 0x25, 0x3e, 0x43, 0xc8, 0x9a, 0xd8, 0xa9, 0x0d,
+    0xd2, 0xbc, 0x3b, 0x8b, 0xf3, 0x3c, 0x9d, 0x4f, 0xbb, 0xb3, 0x6c, 0xa1, 0xf4, 0xe5, 0x68, 0x99,
+    0x8e, 0x51, 0x9d, 0xd9, 0xbc, 0xdf, 0xbd, 0x9a, 0xcd, 0xd2, 0xb9, 0x6f, 0xc9, 0x44, 0x73, 0x54,
+    0xcb, 0xa4, 0x08, 0x17, 0xa3, 0x5b, 0x6d, 0x18, 0x46, 0xe3, 0xb4, 0x7b, 0x35, 0x1d, 0xe5, 0x8b,
+    0x6e, 0x9e, 0x75, 0x31, 0x8e, 0x85, 0x52, 0x30, 0x5b, 0x90, 0xde, 0xeb, 0xd4, 0xb2, 0xcb, 0xcb,
+    0x45, 0x9a, 0x47, 0xc0, 0x8d, 0xec, 0xff, 0x22, 0x41, 0x72, 0x45, 0x2e, 0xcc, 0x9b, 0x66, 0xcb,
+    0x94, 0x56, 0x2f, 0x52, 0xab, 0x40, 0xb1, 0xbe, 0x72, 0x4c, 0xf4, 0x79, 0x88, 0xa8, 0x3a, 0xa1,
+    0xc6, 0x0d, 0xe4, 0x62, 0xe1, 0xdd, 0xc1, 0xdf, 0x7e, 0x34, 0xcb, 0x38, 0x2a, 0x8b, 0x9e, 0x9f,
+    0x94, 0xfb, 0x1b, 0xa2, 0x7f, 0x3e, 0x4a, 0xae, 0xf2, 0x94, 0x74, 0x78, 0x0c, 0x83, 0x1e, 0xa2,
+    0x16, 0x5f, 0x66, 0xf3, 0x09, 0xe2, 0xb7, 0x1c, 0x31, 0x7d, 0x17, 0xfd, 0x99, 0x8f, 0x96, 0xe1,
+    0x75, 0x36, 0xea, 0xa3, 0xa4, 0xd1, 0xd4, 0x41, 0x63, 0x32, 0x18, 0x77, 0xcf, 0xb3, 0xc5, 0x28,
+    0x47, 0xad, 0x8b, 0x18, 0x84, 0x87, 0xa7, 0x37, 0x46, 0xe1, 0xb7, 0xfc, 0xb6, 0x0b, 0x1d, 0xc2,
+    0x50, 0x91, 0xf9, 0x43, 0x38, 0x96, 0xe3, 0xa7, 0xd3, 0x97, 0x89, 0xb3, 0x42, 0x0d, 0x9f, 0xe7,
+    0xf1, 0x80, 0x30, 0x3c, 0x2d, 0xe9, 0x09, 0xd8, 0x03, 0xda, 0xd5, 0x5f, 0xff, 0x38, 0xfd, 0xf6,
+    0xe9, 0xdb, 0xc9, 0xff, 0x74, 0xcf, 0xbe, 0x5c, 0x9c, 0x9f, 0x7e, 0xfc, 0xed, 0xeb, 0xb7, 0x03,
+    0xa5, 0x24, 0xa6, 0xa9, 0x8d, 0x24, 0x56, 0xc8, 0xda, 0x2c, 0x51, 0xa5, 0x36, 0x50, 0xa2, 0x15,
+    0x49, 0xda, 0xae, 0x3c, 0xb6, 0xdd, 0xb8, 0x34, 0x37, 0x29, 0xe4, 0xea, 0xac, 0x59, 0x06, 0x80,
+    0x39, 0xb0, 0xd0, 0x29, 0x8b, 0x5e, 0x3c, 0x96, 0xeb, 0x55, 0xd3, 0x93, 0x42, 0xba, 0x89, 0x57,
+    0x43, 0xe3, 0xf0, 0x5e, 0xc7, 0xf3, 0xd5, 0x68, 0x3a, 0x20, 0x49, 0xd7, 0x90, 0x84, 0xaa, 0x31,
+    0x24, 0x26, 0x5b, 0x0c, 0x39, 0x45, 0x17, 0xe9, 0x72, 0xc4, 0xd0, 0x25, 0xbe, 0xa1, 0x17, 0x7c,
+    0xde, 0x6e, 0x4f, 0x1f, 0x00, 0xdf, 0xdc, 0x44, 0x1f, 0x57, 0xce, 0x2a, 0x4e, 0xee, 0x5d, 0x71,
+    0xa2, 0x57, 0x9c, 0xac, 0xa9, 0x58, 0x65, 0x72, 0x99, 0x35, 0xf2, 0xb1, 0x9d, 0x6d, 0x92, 0xb9,
+    0x3d, 0x0f, 0x95, 0x4b, 0x4a, 0xca, 0x15, 0xf2, 0xf2, 0x74, 0x89, 0xe5, 0x8f, 0xce, 0x11, 0x13,
+    0x89, 0xa7, 0xf5, 0xa9, 0xc6, 0xd2, 0x17, 0xf1, 0x64, 0x36, 0x4e, 0xe7, 0x9d, 0x4f, 0x28, 0x6f,
+    0x34, 0x89, 0x07, 0xe9, 0xb6, 0xdc, 0x81, 0x73, 0x30, 0x06, 0xdc, 0xab, 0x58, 0x50, 0xd3, 0xd2,
+    0x3e, 0x9e, 0x7e, 0x4c, 0xa0, 0x47, 0xb0, 0x02, 0xa9, 0x9d, 0x14, 0xf0, 0x36, 0xf8, 0x6a, 0x0f,
+    0x49, 0x19, 0x02, 0x35, 0x5d, 0x0c, 0xb1, 0x40, 0x68, 0x47, 0x28, 0x1f, 0xc9, 0xea, 0xb4, 0xf3,
+    0xc9, 0xa1, 0x0d, 0xf0, 0x09, 0x3b, 0xa8, 0xe4, 0x20, 0xc6, 0x10, 0x04, 0x25, 0x2a, 0x41, 0x9d,
+    0x22, 0x45, 0x89, 0x8d, 0xa2, 0xc4, 0x48, 0x51, 0x37, 0x91, 0x69, 0xea, 0x98, 0x69, 0xea, 0xb8,
+    0xa1, 0x22, 0x98, 0xa0, 0x52, 0xd2, 0x06, 0x9f, 0x14, 0xf3, 0xf1, 0x88, 0xb9, 0xbb, 0x91, 0x71,
+    0x49, 0x96, 0x8d, 0xb9, 0x30, 0xb9, 0x19, 0xe5, 0x43, 0x04, 0x30, 0xd3, 0x73, 0x67, 0xa3, 0xbc,
+    0x37, 0x2c, 0xe6, 0x52, 0xb6, 0x43, 0x8d, 0x9c, 0x5f, 0x21, 0x2d, 0x04, 0xe3, 0xe0, 0x99, 0x92,
+    0x3a, 0x0f, 0xf2, 0x3e, 0x9e, 0xa4, 0xf3, 0x18, 0x26, 0x4d, 0x2f, 0x9d, 0xa2, 0x4e, 0xec, 0xf6,
+    0x47, 0x8b, 0x3c, 0x9e, 0xf6, 0x52, 0xb3, 0x64, 0x82, 0x06, 0x4f, 0xa1, 0xc5, 0xff, 0x7d, 0x72,
+    0xd1, 0xfd, 0xfd, 0xcb, 0xd9, 0xe7, 0xaf, 0xdf, 0x7e, 0xed, 0x52, 0xd9, 0x7f, 0xc0, 0x6a, 0x80,
+    0xc5, 0x91, 0x56, 0x10, 0x93, 0xac, 0x6e, 0x2e, 0xa1, 0x23, 0x04, 0xe0, 0xe1, 0xa0, 0xd9, 0x9c,
+    0x7b, 0xa5, 0x2c, 0x92, 0x41, 0x57, 0x62, 0x95, 0x76, 0x65, 0xa9, 0x92, 0x16, 0x56, 0x03, 0x61,
+    0xf3, 0x18, 0xad, 0xbe, 0x0b, 0x33, 0x65, 0x24, 0x4f, 0x21, 0x8d, 0xa9, 0x01, 0xb4, 0xc5, 0x04,
+    0x82, 0x53, 0xa7, 0x28, 0x09, 0x35, 0x9a, 0xa9, 0x51, 0xa8, 0xc2, 0x30, 0x02, 0xd6, 0x50, 0x99,
+    0x8c, 0xaf, 0x2c, 0xbd, 0x07, 0x39, 0x0a, 0x85, 0x38, 0x97, 0x92, 0x07, 0x99, 0x9c, 0x38, 0xa9,
+    0x18, 0x4e, 0xd7, 0xe8, 0x92, 0xb2, 0x49, 0x7d, 0x6b, 0x48, 0xa2, 0x1c, 0x6e, 0xa6, 0x8a, 0x66,
+    0x5a, 0x09, 0xe3, 0xea, 0x42, 0x91, 0x36, 0x31, 0x73, 0xec, 0xe4, 0x49, 0x30, 0x25, 0x14, 0x2e,
+    0xf2, 0x79, 0xf6, 0xef, 0xb4, 0x8c, 0xf5, 0x64, 0x08, 0x3b, 0x07, 0xca, 0x50, 0x26, 0x46, 0x54,
+    0xf2, 0xcb, 0xf8, 0x51, 0x07, 0x5c, 0x4f, 0xfb, 0xcd, 0xa8, 0x9f, 0x0f, 0x4b, 0x69, 0xc7, 0x10,
+    0x65, 0x2c, 0x2a, 0xc3, 0x59, 0x18, 0x55, 0x01, 0x59, 0xc3, 0xae, 0x3a, 0xec, 0xfa, 0x36, 0x94,
+    0x32, 0x8a, 0x0a, 0x63, 0xe5, 0x17, 0x15, 0xcc, 0xc4, 0x36, 0x1a, 0x44, 0x19, 0xf7, 0x14, 0x41,
+    0x89, 0xbb, 0x40, 0x2c, 0x90, 0x87, 0x68, 0x81, 0xec, 0xc7, 0x79, 0x2c, 0xad, 0x8f, 0xf0, 0x0b,
+    0xad, 0x91, 0xa5, 0xe2, 0xad, 0x47, 0x14, 0x5d, 0xdd, 0xc4, 0xa4, 0x32, 0xcc, 0xe7, 0xa2, 0xce,
+    0x65, 0xe4, 0xe9, 0xd2, 0x2c, 0xda, 0x48, 0x66, 0x91, 0x3f, 0x91, 0x6e, 0x3b, 0x33, 0xa9, 0xe4,
+    0x0b, 0x01, 0xc6, 0x2b, 0x34, 0x09, 0xa8, 0x68, 0x13, 0x19, 0x04, 0xff, 0x18, 0x6a, 0x84, 0x64,
+    0x9f, 0x09, 0x23, 0x5e, 0x9b, 0x26, 0x71, 0xa2, 0x8d, 0xe4, 0x0a, 0xfd, 0x6b, 0xa8, 0x8c, 0xe6,
+    0xf8, 0x92, 0x98, 0x31, 0x55, 0xc9, 0x11, 0x6c, 0x23, 0x2e, 0xe4, 0x0f, 0xd3, 0x88, 0xca, 0xf9,
+    0xbe, 0x2e, 0x48, 0x4c, 0xe3, 0xab, 0x22, 0xdc, 0x5a, 0x14, 0xc8, 0x1f, 0x86, 0xae, 0x91, 0xb3,
+    0x7d, 0x5d, 0x46, 0x58, 0xb8, 0x40, 0x45, 0x79, 0x8f, 0x09, 0xae, 0x7e, 0xda, 0xa9, 0x13, 0xe3,
+    0xa7, 0xcf, 0x7e, 0xd3, 0x30, 0xea, 0x58, 0xad, 0xd3, 0x17, 0xfb, 0xac, 0x88, 0x42, 0x13, 0xe1,
+    0x0a, 0x41, 0x5d, 0x24, 0x76, 0x0d, 0xb8, 0xbb, 0x3c, 0xf4, 0x4f, 0x43, 0x68, 0x8d, 0xbd, 0xd1,
+    0xbc, 0x87, 0xf4, 0x26, 0xa2, 0xd3, 0x44, 0xa8, 0x2a, 0x3c, 0xac, 0x08, 0xd8, 0x6b, 0x35, 0x8f,
+    0xdd, 0x10, 0x19, 0xe1, 0x8e, 0xae, 0x3d, 0x31, 0x15, 0xb9, 0x97, 0xcd, 0xa7, 0x48, 0x0f, 0x9a,
+    0x31, 0x4b, 0x4a, 0x41, 0x45, 0x4b, 0xaa, 0x5a, 0x19, 0x2a, 0xa9, 0x15, 0xaa, 0x47, 0x94, 0x54,
+    0xcf, 0x21, 0x93, 0xaf, 0x2e, 0xf7, 0x3b, 0x68, 0x90, 0xaa, 0x6e, 0x76, 0x57, 0x83, 0x7e, 0xa1,
+    0x6e, 0xa8, 0xd9, 0x3c, 0xfb, 0x57, 0xda, 0xcb, 0xd3, 0x3e, 0x23, 0x5f, 0xb5, 0xe5, 0x14, 0x7a,
+    0x88, 0x4d, 0x77, 0xbf, 0xda, 0x3d, 0x47, 0xaf, 0xb1, 0x79, 0x13, 0x94, 0x68, 0x86, 0xc8, 0xa2,
+    0xb2, 0x5b, 0x9a, 0x1a, 0x29, 0xd4, 0xcd, 0x40, 0x9b, 0x57, 0x52, 0xac, 0xd8, 0x28, 0x4b, 0x4f,
+    0x4b, 0x38, 0x9a, 0xcb, 0xd5, 0xa6, 0x4d, 0x2d, 0x53, 0x78, 0x0d, 0x54, 0x6e, 0x51, 0x83, 0x5c,
+    0xfa, 0x26, 0xbc, 0xbb, 0x93, 0xd7, 0xc3, 0x69, 0x3e, 0x8a, 0xc7, 0xa3, 0x78, 0x81, 0xc5, 0x25,
+    0x62, 0xd6, 0xe0, 0xd3, 0xe9, 0x1f, 0x67, 0x1f, 0x4f, 0xbb, 0xe7, 0x67, 0x7f, 0x9e, 0xfe, 0xd2,
+    0xfd, 0x76, 0xf2, 0xdb, 0xd9, 0xd7, 0xc0, 0x58, 0x4b, 0x48, 0x16, 0x2c, 0x60, 0xfc, 0x43, 0x87,
+    0xd6, 0xd7, 0x5c, 0xfa, 0xec, 0x17, 0x9a, 0x6c, 0x32, 0x6a, 0x97, 0x3a, 0xba, 0xac, 0x2b, 0xd9,
+    0x63, 0xab, 0xdb, 0xbb, 0x51, 0x98, 0x1f, 0x59, 0xf3, 0xdd, 0x9d, 0xf2, 0xfa, 0x14, 0x4a, 0xe7,
+    0x53, 0xaa, 0x8a, 0x4f, 0xa0, 0xdf, 0x51, 0xdd, 0xce, 0x36, 0x21, 0xaa, 0x68, 0x6a, 0x56, 0x6e,
+    0xaf, 0xac, 0x75, 0x59, 0xf8, 0x78, 0xbd, 0x1e, 0x65, 0x67, 0xd2, 0xaa, 0x0a, 0xd1, 0x1a, 0x0e,
+    0xdc, 0x5c, 0x93, 0x59, 0xc3, 0x5e, 0x5b, 0xe9, 0x20, 0x6b, 0x19, 0xe7, 0xde, 0x7a, 0x03, 0x66,
+    0x0b, 0x24, 0xd4, 0x43, 0x82, 0x84, 0x49, 0xee, 0x71, 0x3a, 0x1d, 0x20, 0xca, 0xc8, 0x1f, 0x26,
+    0x5f, 0xdd, 0xd0, 0x2a, 0xba, 0x29, 0x9e, 0xdb, 0x50, 0xcb, 0x44, 0x0b, 0x28, 0xce, 0x6f, 0x4c,
+    0xe2, 0xa5, 0x43, 0x94, 0x66, 0x55, 0x2e, 0x2b, 0x23, 0xd5, 0xcd, 0xa3, 0xc5, 0x24, 0xcb, 0xf2,
+    0xe1, 0x22, 0x4f, 0x67, 0x4e, 0xab, 0xd9, 0xf2, 0x75, 0x44, 0xbe, 0x4a, 0x20, 0xd1, 0x6f, 0x08,
+    0x0e, 0xaa, 0x8b, 0x46, 0x72, 0x5f, 0xd6, 0xfe, 0x51, 0x43, 0x58, 0xda, 0xb5, 0x9f, 0xe0, 0x4f,
+    0xed, 0x43, 0x4d, 0xc2, 0x5e, 0xc0, 0x0c, 0xd5, 0x69, 0xd8, 0x09, 0xc3, 0x9a, 0x17, 0x20, 0xcd,
+    0x35, 0xc6, 0x5b, 0xe0, 0x71, 0x27, 0x99, 0xc7, 0xf4, 0x3e, 0x99, 0x63, 0x3c, 0x4d, 0x27, 0x94,
+    0x34, 0xe8, 0x7b, 0x38, 0xce, 0x1e, 0x7b, 0x4b, 0xc4, 0xbe, 0xcb, 0x21, 0xc8, 0xb1, 0xae, 0xb0,
+    0x37, 0x29, 0x9a, 0x4b, 0xb9, 0xd9, 0x1c, 0x26, 0x79, 0x66, 0x57, 0x44, 0x87, 0xe7, 0x6b, 0x4e,
+    0x08, 0x52, 0x98, 0x66, 0x19, 0x97, 0x02, 0x26, 0x19, 0x05, 0xcc, 0x63, 0x7b, 0xc4, 0x36, 0x5b,
+    0xc3, 0xcb, 0x1d, 0x9d, 0xac, 0x90, 0xd9, 0x5b, 0x69, 0x73, 0x8b, 0xb3, 0xf4, 0x11, 0xd2, 0xe1,
+    0xa6, 0x0b, 0xc8, 0xa9, 0xb2, 0x93, 0x42, 0xeb, 0x08, 0xc9, 0x0e, 0xa6, 0xdc, 0x7b, 0xff, 0x3c,
+    0xfd, 0xf6, 0x15, 0xab, 0x64, 0x78, 0xeb, 0x3a, 0x68, 0xbf, 0x69, 0xb6, 0x42, 0xbe, 0x31, 0xf7,
+    0xf3, 0xc9, 0xef, 0x17, 0x17, 0xdd, 0x8f, 0x5f, 0x4f, 0x3f, 0xa3, 0x99, 0x75, 0xf8, 0xfe, 0xdd,
+    0xfb, 0xa3, 0x4e, 0xe7, 0x5d, 0xeb, 0xa8, 0xd5, 0x3e, 0x3a, 0xec, 0xbc, 0x3d, 0xa8, 0xea, 0x45,
+    0xa0, 0x9c, 0x41, 0xfe, 0x18, 0xec, 0x27, 0x92, 0xe1, 0x0b, 0x36, 0xd1, 0x0c, 0x4d, 0x99, 0x11,
+    0xa2, 0xcd, 0x46, 0xdb, 0xbc, 0x44, 0x3d, 0xb8, 0x67, 0x81, 0x9e, 0x80, 0xc0, 0x23, 0xd8, 0xef,
+    0x56, 0xb2, 0xd6, 0x08, 0xc2, 0x8b, 0x68, 0xf1, 0xbf, 0xf3, 0xdc, 0x69, 0xa0, 0x64, 0x6f, 0x9c,
+    0x0d, 0x1c, 0x18, 0x8d, 0x80, 0x34, 0x30, 0x90, 0xc6, 0x38, 0x10, 0x03, 0xe1, 0xba, 0xc1, 0x21,
+    0x1a, 0x22, 0x3e, 0xa4, 0xd1, 0x85, 0xa7, 0x57, 0x1c, 0x6a, 0xb2, 0x9f, 0xe9, 0xf1, 0x84, 0xe8,
+    0x82, 0x0d, 0x46, 0x6c, 0xaf, 0x6c, 0x41, 0x26, 0xb9, 0x6e, 0x32, 0xd6, 0x29, 0x30, 0x11, 0x12,
+    0x46, 0x49, 0x02, 0xfc, 0xb6, 0x4e, 0x2c, 0x3c, 0xd0, 0xd4, 0x36, 0x03, 0x89, 0xb9, 0x60, 0x61,
+    0xfb, 0x8d, 0x19, 0xda, 0xaa, 0x36, 0xd1, 0xe6, 0x54, 0x61, 0x4c, 0x92, 0xdb, 0x8f, 0x1a, 0xa8,
+    0x1b, 0x3d, 0x34, 0x66, 0xf8, 0xff, 0x7e, 0x96, 0x3b, 0x9c, 0x2e, 0x9f, 0xff, 0x62, 0xfc, 0x70,
+    0x1d, 0x8f, 0x23, 0x82, 0xc6, 0x93, 0x9a, 0xe5, 0x09, 0xb2, 0xbd, 0x74, 0x39, 0x73, 0xfa, 0xda,
+    0xaa, 0x84, 0x07, 0x0e, 0x15, 0x85, 0xdd, 0x23, 0xf6, 0xbf, 0xbb, 0x83, 0x7d, 0xe8, 0x9b, 0x6c,
+    0x3e, 0xee, 0x57, 0xdd, 0xc9, 0xdd, 0x68, 0x49, 0xf2, 0x28, 0x72, 0x69, 0xeb, 0xb6, 0xb9, 0x8c,
+    0x62, 0xf2, 0x97, 0x7e, 0xaf, 0x40, 0x6c, 0x35, 0x48, 0xda, 0x4a, 0xde, 0xec, 0x2c, 0xee, 0x1c,
+    0x9a, 0x72, 0xc8, 0x92, 0x3c, 0x47, 0x29, 0xf6, 0x5d, 0xff, 0x35, 0x8d, 0xa0, 0x47, 0x45, 0x0c,
+    0xbb, 0x6a, 0x18, 0xd8, 0x6d, 0xce, 0xa5, 0xcd, 0x37, 0x05, 0x4a, 0x54, 0xee, 0x63, 0x29, 0x91,
+    0xfb, 0x30, 0xd7, 0xb4, 0x61, 0xbd, 0xd7, 0xc1, 0x82, 0x56, 0x15, 0xdd, 0xa1, 0x90, 0x18, 0x4f,
+    0x7b, 0xc3, 0x6c, 0x6e, 0xce, 0x63, 0x93, 0xa9, 0x88, 0x69, 0x1c, 0xf7, 0x52, 0x03, 0x1f, 0x2c,
+    0x86, 0xa3, 0xcb, 0x3c, 0xac, 0xc4, 0x49, 0xe5, 0x6b, 0xa0, 0xdd, 0x75, 0xc1, 0x46, 0x88, 0xce,
+    0x1e, 0x46, 0x8a, 0x9e, 0x3c, 0xcd, 0xf2, 0xdf, 0x17, 0x90, 0xae, 0xed, 0x0b, 0x4b, 0x3e, 0xa7,
+    0xf3, 0x0c, 0x4d, 0xb7, 0x02, 0x2b, 0x8a, 0xfe, 0x20, 0x9c, 0x28, 0xcf, 0x7b, 0x41, 0x15, 0x85,
+    0x62, 0x54, 0x45, 0x2a, 0xd2, 0xe6, 0x8d, 0x5a, 0x2c, 0x1b, 0x8f, 0xf1, 0xd9, 0x9b, 0xee, 0x2c,
+    0x9d, 0x2f, 0x66, 0x08, 0x6e, 0x74, 0x9d, 0x22, 0x56, 0x40, 0x53, 0x21, 0xea, 0x8d, 0x11, 0x47,
+    0xa0, 0xa1, 0x3b, 0xae, 0x83, 0xcc, 0x70, 0x4a, 0x5a, 0x1e, 0x58, 0x6b, 0x77, 0xb1, 0x8a, 0x7b,
+    0x04, 0xc3, 0xbf, 0x56, 0xef, 0x63, 0xa2, 0x42, 0xf7, 0xfc, 0x38, 0x7c, 0xb4, 0xeb, 0x74, 0x18,
+    0xd7, 0xf8, 0x7b, 0xbc, 0x92, 0x56, 0x85, 0x6c, 0x58, 0x22, 0xc6, 0x2a, 0x78, 0x0a, 0xd3, 0x31,
+    0x11, 0x89, 0x78, 0x0e, 0xdf, 0x67, 0x40, 0xa9, 0x36, 0x37, 0x9e, 0x0d, 0xe3, 0x08, 0xf5, 0x5f,
+    0x68, 0x94, 0x72, 0xb8, 0xd1, 0xac, 0xe1, 0x1e, 0x06, 0xc6, 0x1e, 0x37, 0x56, 0x55, 0xed, 0xbf,
+    0x6a, 0x30, 0x15, 0x4d, 0xfa, 0xaf, 0x54, 0x12, 0x4f, 0x57, 0x5a, 0xfa, 0x8e, 0x14, 0xa7, 0x24,
+    0x19, 0xcb, 0x7b, 0x51, 0xb3, 0x1d, 0xde, 0xed, 0x64, 0x16, 0x3e, 0xab, 0xe9, 0xa6, 0xa5, 0x6b,
+    0xdb, 0xca, 0xda, 0x22, 0x6d, 0x4e, 0x66, 0x4a, 0xca, 0x7e, 0xe6, 0x1a, 0x67, 0xae, 0x4c, 0xdf,
+    0x2c, 0xee, 0xf7, 0x51, 0x07, 0x76, 0x2f, 0xe3, 0x5e, 0x9e, 0x81, 0x9f, 0xb5, 0x53, 0x98, 0xd8,
+    0x9c, 0x7f, 0x0a, 0xd3, 0x59, 0x2d, 0xfc, 0x18, 0xb3, 0x9b, 0x8d, 0x7f, 0x14, 0x27, 0x0b, 0x21,
+    0x60, 0x9a, 0x2b, 0x57, 0x52, 0x66, 0x05, 0x7d, 0x2a, 0x3d, 0xa1, 0xc6, 0x0f, 0xd1, 0x06, 0xfe,
+    0xed, 0x52, 0xea, 0x25, 0xb5, 0x81, 0xaf, 0xfe, 0xd7, 0x08, 0x0a, 0x7b, 0xdf, 0x59, 0xdd, 0xcf,
+    0x83, 0xeb, 0x75, 0xf1, 0x26, 0xa9, 0x16, 0x1b, 0x0b, 0xb7, 0xde, 0xb6, 0x52, 0xad, 0x47, 0xc5,
+    0x59, 0x87, 0x1d, 0x71, 0x56, 0x08, 0xd6, 0x1c, 0x4a, 0x5a, 0x73, 0xdc, 0x52, 0xef, 0x93, 0xd0,
+    0x85, 0x3d, 0x13, 0xce, 0xd0, 0xe0, 0x51, 0x6b, 0x23, 0x8b, 0xd5, 0x08, 0x1c, 0x18, 0x46, 0x51,
+    0xb1, 0xe0, 0xd8, 0xa8, 0x94, 0x55, 0xc5, 0xf8, 0x07, 0x58, 0x2a, 0xed, 0x0f, 0x52, 0xcc, 0xb7,
+    0x46, 0xd7, 0x51, 0xa9, 0x7f, 0xab, 0xa1, 0x6c, 0x5e, 0x42, 0x4f, 0x37, 0x74, 0xcc, 0x56, 0x27,
+    0x13, 0xf1, 0x3e, 0xde, 0xed, 0xee, 0x30, 0xac, 0x61, 0xe3, 0x63, 0xed, 0xd1, 0xd7, 0x0d, 0xe9,
+    0x7b, 0x69, 0x27, 0xa9, 0x9e, 0xd3, 0x81, 0xa0, 0x82, 0x81, 0xfa, 0xe4, 0x67, 0x36, 0x76, 0x70,
+    0xac, 0xa1, 0x2a, 0x0f, 0x3f, 0xc9, 0xc6, 0xdf, 0x03, 0x6f, 0x9a, 0x3d, 0xf2, 0xc6, 0xcd, 0x46,
+    0xbb, 0x27, 0x06, 0x5b, 0xf4, 0x41, 0x8e, 0x7f, 0x6e, 0x20, 0x2b, 0x8c, 0xfe, 0x06, 0x83, 0x55,
+    0x6e, 0x1b, 0x9c, 0xab, 0x7c, 0x3c, 0x9a, 0x96, 0x1e, 0x95, 0x53, 0x40, 0xec, 0x32, 0x46, 0x01,
+    0x33, 0xc9, 0x1a, 0x15, 0xa0, 0x8c, 0xab, 0x0a, 0x90, 0xaf, 0x48, 0xf6, 0xa8, 0x1d, 0xae, 0x7c,
+    0x99, 0x64, 0x91, 0x02, 0xe0, 0x17, 0x06, 0xc3, 0x24, 0x9b, 0x34, 0x9c, 0x5b, 0xf5, 0xe6, 0x53,
+    0xcb, 0x2a, 0xcc, 0xb3, 0x91, 0xa3, 0xea, 0xe6, 0x81, 0xa2, 0x71, 0xd7, 0x61, 0xd2, 0x04, 0xe0,
+    0x15, 0x66, 0x5c, 0x6f, 0x15, 0x70, 0x6a, 0x9f, 0xef, 0x9c, 0x35, 0x1f, 0x8a, 0xbb, 0xd6, 0xb8,
+    0xda, 0x2c, 0xf2, 0x4c, 0x69, 0xfb, 0x36, 0x6c, 0x72, 0x4f, 0x19, 0x29, 0x34, 0x45, 0xa1, 0xc6,
+    0x22, 0xda, 0x1b, 0x5c, 0x0a, 0x66, 0x73, 0x64, 0x0f, 0xad, 0x98, 0x82, 0x48, 0x94, 0x77, 0x70,
+    0x5b, 0x6a, 0x1b, 0xa0, 0xa0, 0x7c, 0x03, 0x16, 0x5d, 0x13, 0x94, 0xc9, 0xf6, 0x1c, 0x5c, 0x9c,
+    0x09, 0xe1, 0xdd, 0x39, 0x78, 0x1f, 0xee, 0x06, 0x11, 0x3b, 0xbb, 0x81, 0x8d, 0x9b, 0xfb, 0xde,
+    0x00, 0xaa, 0xbe, 0x0c, 0x3c, 0xfb, 0x23, 0xdd, 0xec, 0x1e, 0xc7, 0xe5, 0x3c, 0x9b, 0x98, 0xc9,
+    0x94, 0x21, 0x8c, 0xb4, 0x1e, 0x69, 0x40, 0x2a, 0xc1, 0xf4, 0x22, 0xa8, 0x94, 0x6d, 0x22, 0x9a,
+    0x0e, 0x8f, 0x0e, 0x57, 0x81, 0xf0, 0x3c, 0x2b, 0x27, 0x1b, 0x19, 0x3a, 0xeb, 0x88, 0xce, 0xb3,
+    0x12, 0x92, 0x51, 0x66, 0x05, 0x82, 0x09, 0x54, 0xf5, 0xd5, 0xea, 0xa9, 0x8e, 0xe4, 0x2a, 0xc3,
+    0x2d, 0x7f, 0x44, 0x71, 0xd7, 0x34, 0x48, 0xd2, 0x5e, 0xb4, 0x3a, 0x8a, 0xd1, 0xb6, 0x83, 0x25,
+    0x7e, 0x46, 0x71, 0xb7, 0xd8, 0xc9, 0xc6, 0x0a, 0x11, 0xac, 0xb9, 0xab, 0xe5, 0x8b, 0xb4, 0x70,
+    0x69, 0x2a, 0x92, 0x69, 0x82, 0x43, 0x27, 0x0a, 0x04, 0xdc, 0x9e, 0x52, 0x21, 0x6e, 0x6f, 0x42,
+    0x1d, 0x47, 0x12, 0x89, 0x8a, 0x4c, 0x18, 0x94, 0x7c, 0x54, 0x9e, 0x3a, 0xc0, 0x40, 0xf0, 0x7c,
+    0xc3, 0xfe, 0x38, 0x2a, 0x64, 0x9a, 0xcb, 0x50, 0xdc, 0xe7, 0x55, 0x73, 0xd8, 0x59, 0x18, 0x20,
+    0xe1, 0x82, 0xfa, 0x94, 0x48, 0x0e, 0x3b, 0xde, 0x92, 0x67, 0x6a, 0xfa, 0x4d, 0x58, 0x6d, 0x79,
+    0x07, 0x5a, 0x91, 0x30, 0x9f, 0x8d, 0xe3, 0x15, 0xbd, 0x21, 0x48, 0xb6, 0x82, 0x1d, 0xb9, 0x0b,
+    0x9a, 0xcb, 0x86, 0xdc, 0x67, 0xcd, 0xa5, 0x1b, 0x08, 0xf2, 0x7d, 0x15, 0x74, 0xa5, 0x82, 0xae,
+    0x64, 0x50, 0x53, 0x7d, 0x49, 0xb1, 0xbe, 0x44, 0xad, 0x2f, 0x29, 0xa9, 0x2f, 0x51, 0xeb, 0x4b,
+    0x0a, 0xf5, 0xdd, 0xf3, 0x22, 0x25, 0xef, 0x70, 0x4f, 0xed, 0x24, 0x9f, 0x8f, 0xd1, 0x43, 0xdd,
+    0x9c, 0xa4, 0x03, 0xa8, 0xd6, 0x93, 0x58, 0xea, 0xd9, 0x42, 0x21, 0x5b, 0x73, 0xdb, 0xd1, 0xbe,
+    0x0f, 0xc9, 0x56, 0x87, 0xcb, 0xb8, 0x9f, 0x3e, 0xea, 0x92, 0xb7, 0xbb, 0x55, 0x6b, 0xd7, 0xcb,
+    0xcd, 0x63, 0xae, 0x15, 0x8f, 0x71, 0xec, 0x50, 0xe9, 0xac, 0x6d, 0x04, 0x7a, 0x69, 0x6f, 0xbc,
+    0x38, 0x81, 0xbd, 0xd9, 0xa5, 0x5c, 0xcb, 0x95, 0xdc, 0x27, 0xba, 0x90, 0x6b, 0xb9, 0x8e, 0xfb,
+    0x60, 0x97, 0x71, 0x1f, 0xd9, 0xa8, 0x30, 0x5d, 0xef, 0x05, 0x41, 0x44, 0x3d, 0xff, 0xde, 0x0e,
+    0xe3, 0x18, 0x3c, 0x0f, 0x4b, 0x62, 0x6f, 0x36, 0xec, 0xcd, 0x86, 0xbd, 0xd9, 0xb0, 0x37, 0x1b,
+    0x2c, 0x66, 0xc3, 0x3f, 0xb3, 0x6c, 0x72, 0x7f, 0xd3, 0xe1, 0xb5, 0x5b, 0x05, 0x3b, 0x89, 0xc1,
+    0x52, 0x6a, 0x3a, 0xf0, 0x71, 0xda, 0x81, 0xf9, 0x50, 0xa8, 0x6b, 0xbd, 0x35, 0xa0, 0xe8, 0xfc,
+    0x0f, 0x11, 0xe4, 0x64, 0xaf, 0xfa, 0xef, 0x55, 0xff, 0xbd, 0xea, 0xff, 0xba, 0x54, 0xff, 0x8a,
+    0x8a, 0xfa, 0x6e, 0x54, 0xf4, 0x43, 0x94, 0x3a, 0x86, 0xb3, 0xe8, 0x6a, 0x6c, 0x34, 0x36, 0xa5,
+    0x78, 0xb6, 0xbc, 0x7f, 0xab, 0xc8, 0x12, 0x9c, 0x2b, 0x0e, 0xe7, 0xeb, 0x92, 0xf0, 0x3a, 0x9d,
+    0xe7, 0x23, 0x24, 0x61, 0xbb, 0x03, 0x38, 0x46, 0x93, 0x4e, 0xf3, 0x70, 0xfd, 0xf1, 0x48, 0x50,
+    0xfd, 0xa6, 0x08, 0x09, 0x2a, 0x95, 0x2a, 0x5b, 0xc1, 0x47, 0x48, 0x2e, 0xb2, 0xdd, 0x1d, 0xf3,
+    0xd5, 0xd9, 0xd8, 0x2c, 0xf2, 0x62, 0x9c, 0x63, 0xbf, 0x9b, 0x04, 0xb9, 0xe5, 0x77, 0x14, 0x18,
+    0x44, 0x89, 0xf4, 0x1a, 0x96, 0x5c, 0x8e, 0x1a, 0xae, 0xb9, 0x1c, 0x35, 0xac, 0x70, 0x4d, 0x62,
+    0x58, 0xe5, 0x4e, 0xcc, 0x7d, 0x8f, 0xd8, 0x54, 0x3f, 0x2b, 0x51, 0x45, 0x8d, 0xc6, 0xe3, 0x21,
+    0xb7, 0x02, 0x12, 0x4c, 0x31, 0x38, 0x50, 0xb2, 0xcf, 0x06, 0xc9, 0x78, 0x33, 0x88, 0x14, 0xdc,
+    0x60, 0x18, 0xe4, 0xc2, 0x43, 0xdb, 0xad, 0xa4, 0x21, 0xbb, 0x95, 0x34, 0x2c, 0xbb, 0x95, 0xc4,
+    0x8a, 0x6f, 0x32, 0x02, 0xc5, 0xb3, 0x1b, 0x0f, 0x78, 0x4c, 0x07, 0x4f, 0x4c, 0x32, 0x43, 0x22,
+    0x69, 0xaa, 0x20, 0xc1, 0x7c, 0x1b, 0xe2, 0x8e, 0x82, 0x2b, 0x9a, 0xe0, 0x1d, 0x80, 0x0f, 0x37,
+    0xa4, 0xf4, 0xb3, 0x44, 0xf2, 0xc9, 0x3c, 0x0b, 0x24, 0xa8, 0x25, 0xc1, 0xd1, 0x5c, 0xe2, 0x0b,
+    0x4c, 0x6b, 0xf5, 0xbc, 0x1c, 0x1f, 0x15, 0x6c, 0xd5, 0x7e, 0xa2, 0x5d, 0x53, 0xfb, 0x80, 0xc7,
+    0x07, 0xb4, 0x3f, 0xe9, 0x02, 0xe7, 0x35, 0x0e, 0x45, 0x8b, 0x7f, 0x36, 0xe7, 0x5e, 0xab, 0xd9,
+    0x69, 0x77, 0xde, 0xd4, 0xc9, 0xe7, 0x00, 0x7d, 0xbe, 0x6d, 0x1f, 0x77, 0xe8, 0x67, 0x82, 0x3e,
+    0x5b, 0x6f, 0x3b, 0x9d, 0x90, 0x4e, 0x6f, 0xf5, 0xd0, 0x22, 0x3f, 0x07, 0x4b, 0x18, 0x75, 0x92,
+    0x80, 0x18, 0xc1, 0x62, 0x87, 0xc3, 0x1d, 0xfa, 0xe2, 0x1f, 0x0c, 0x8a, 0xd1, 0xd4, 0x23, 0x19,
+    0x98, 0xbb, 0x5c, 0xe6, 0x70, 0x38, 0x34, 0x9b, 0xa2, 0xbe, 0x23, 0x07, 0x7a, 0xe1, 0xba, 0x0e,
+    0x69, 0x7f, 0xd0, 0x7e, 0x73, 0xf8, 0xee, 0x08, 0x02, 0xc0, 0x72, 0xa1, 0xe7, 0x8a, 0xea, 0xe5,
+    0x92, 0x20, 0xb6, 0x41, 0xd8, 0x36, 0x74, 0x01, 0xe8, 0x42, 0x54, 0x53, 0x92, 0x25, 0x3a, 0xa1,
+    0x5e, 0x84, 0x02, 0x8c, 0xbe, 0x84, 0x91, 0x84, 0x84, 0xa0, 0xc3, 0xb0, 0xaa, 0xfd, 0x10, 0xc1,
+    0xdd, 0x8e, 0xda, 0x7f, 0x24, 0x08, 0x2f, 0x62, 0x35, 0x16, 0x64, 0xaa, 0x5b, 0x77, 0x0c, 0xa9,
+    0x1e, 0x69, 0x9e, 0x93, 0xd7, 0x31, 0x1b, 0x78, 0xb3, 0xec, 0xc6, 0x21, 0xe3, 0x15, 0xb4, 0x8f,
+    0x5b, 0xf4, 0x24, 0xa8, 0x0f, 0x2d, 0x41, 0x83, 0x81, 0x3e, 0xde, 0xbf, 0xf3, 0xcd, 0x2d, 0x02,
+    0x5a, 0x71, 0xc8, 0xdd, 0x2e, 0x1d, 0xcc, 0x3a, 0xed, 0x39, 0x36, 0xb6, 0x32, 0x95, 0xf2, 0x72,
+    0xd2, 0x9c, 0x53, 0xf4, 0x50, 0xd7, 0xa1, 0x8c, 0x9d, 0x66, 0xbb, 0x74, 0x60, 0x29, 0xe2, 0x81,
+    0x8a, 0x78, 0x60, 0x47, 0x3c, 0x28, 0x47, 0x3c, 0xd0, 0x10, 0x27, 0x2a, 0xe2, 0xc4, 0x8e, 0x38,
+    0x29, 0x47, 0x9c, 0x50, 0xc4, 0xd2, 0x2d, 0x06, 0x65, 0x5d, 0x2a, 0xb9, 0x5d, 0x2b, 0xad, 0x5c,
+    0xcf, 0xd6, 0xe3, 0xa6, 0x2e, 0x35, 0xec, 0x54, 0xad, 0xd1, 0x1f, 0xb7, 0x7e, 0xa1, 0x7f, 0x44,
+    0x2d, 0xe3, 0x1e, 0x3a, 0x44, 0xf5, 0xed, 0x17, 0x18, 0x55, 0x5a, 0xef, 0xe0, 0x01, 0x14, 0x0e,
+    0x25, 0xb8, 0x1d, 0x2c, 0x63, 0xa6, 0x10, 0x1f, 0x06, 0x3d, 0x44, 0x0d, 0xf1, 0xf1, 0xe0, 0x6a,
+    0x88, 0x4c, 0xd6, 0x50, 0xbd, 0xa2, 0x2d, 0x15, 0x35, 0xeb, 0x27, 0x0a, 0x69, 0x95, 0x16, 0xc7,
+    0xbd, 0x37, 0xf3, 0x29, 0xbc, 0x99, 0x98, 0x4b, 0x37, 0x52, 0xbd, 0x34, 0x9e, 0xdc, 0x4c, 0xf3,
+    0xda, 0x5c, 0xdb, 0x2a, 0x70, 0x5a, 0xb4, 0x0d, 0x3f, 0xed, 0xdd, 0xa5, 0x2f, 0xe7, 0x94, 0x45,
+    0x99, 0x0a, 0x4b, 0x6f, 0x90, 0xf4, 0x07, 0x29, 0xbf, 0xb3, 0x25, 0x83, 0xbc, 0x7e, 0x3f, 0xeb,
+    0x43, 0xe8, 0xf0, 0x24, 0xe7, 0x36, 0xb2, 0xe8, 0xea, 0x6b, 0x75, 0xfc, 0x5b, 0x7e, 0xcc, 0x05,
+    0xbc, 0x34, 0x0c, 0x77, 0x04, 0x7b, 0x90, 0xb5, 0xbf, 0xff, 0xbd, 0xc6, 0x34, 0xd5, 0x08, 0x14,
+    0x55, 0x29, 0xe1, 0x16, 0x41, 0x10, 0x25, 0xfa, 0xe0, 0x27, 0xb2, 0x2e, 0x1f, 0x7c, 0x20, 0x2f,
+    0x3c, 0xc8, 0xe3, 0xe9, 0xdf, 0x7a, 0x9a, 0x92, 0xb1, 0x93, 0x23, 0x27, 0xbb, 0x39, 0x70, 0x42,
+    0x6b, 0x61, 0xaa, 0x83, 0xc5, 0x98, 0xa9, 0x68, 0x8d, 0x1c, 0x3e, 0x84, 0x35, 0x02, 0x57, 0x16,
+    0x5f, 0x8b, 0x09, 0xc2, 0xba, 0xb5, 0x39, 0x1f, 0x70, 0xad, 0xde, 0xa6, 0xcd, 0x63, 0xcc, 0x38,
+    0xac, 0x1c, 0x34, 0xc5, 0xa7, 0xbf, 0x0e, 0xdd, 0x82, 0x5e, 0x4f, 0xf3, 0xda, 0xe4, 0x69, 0x91,
+    0xdd, 0xbb, 0xf9, 0xb7, 0xd1, 0x3a, 0x1f, 0x57, 0x7d, 0xdc, 0x95, 0x0e, 0xf8, 0xba, 0xf7, 0x15,
+    0xf0, 0x40, 0xad, 0xd7, 0xa5, 0xac, 0xa3, 0x50, 0x4d, 0x2f, 0xda, 0xef, 0x46, 0xec, 0x77, 0x23,
+    0xb6, 0xde, 0x8d, 0xa0, 0x8f, 0x03, 0x2d, 0xe9, 0x73, 0x3d, 0xf6, 0x0d, 0x89, 0xc2, 0xbe, 0x05,
+    0x2d, 0xe1, 0x69, 0xf2, 0x6a, 0x1f, 0x8e, 0xc6, 0x78, 0x0c, 0xb4, 0x6a, 0xbc, 0x19, 0xa5, 0x9f,
+    0x6c, 0x41, 0x67, 0x1e, 0x2a, 0x60, 0x4c, 0xa5, 0x2e, 0xef, 0x8f, 0x26, 0xb0, 0x0c, 0x67, 0xd3,
+    0xb0, 0x5a, 0x64, 0x0b, 0x4a, 0xf4, 0x43, 0x8c, 0x89, 0x1c, 0xd6, 0x81, 0x04, 0xbc, 0x9a, 0x2d,
+    0x46, 0x63, 0x04, 0x0b, 0xc1, 0xcc, 0x64, 0xca, 0xe8, 0xc5, 0x71, 0x6c, 0x64, 0x38, 0x52, 0x06,
+    0xd2, 0xc9, 0x41, 0x1b, 0x0e, 0x94, 0x24, 0x76, 0x16, 0x58, 0x21, 0x35, 0x78, 0xd7, 0x7e, 0x8f,
+    0xa3, 0x77, 0x61, 0x24, 0x75, 0x5a, 0x51, 0xc9, 0xab, 0x4a, 0xda, 0xcb, 0x71, 0x4a, 0xe8, 0xaa,
+    0x2a, 0xba, 0x80, 0xbd, 0x9b, 0x75, 0xd6, 0xb9, 0xcd, 0x90, 0x70, 0x2e, 0x3c, 0xaf, 0x12, 0x2f,
+    0x71, 0x3a, 0xf9, 0x46, 0xca, 0xec, 0xe9, 0x38, 0xbd, 0x06, 0xfd, 0x73, 0xea, 0xd0, 0x48, 0xcf,
+    0x48, 0x08, 0xf8, 0x74, 0xd9, 0x19, 0xc5, 0x0b, 0x16, 0x52, 0x03, 0x87, 0xda, 0x2d, 0xf2, 0x15,
+    0x91, 0x60, 0x1e, 0x0e, 0x10, 0xc7, 0x1f, 0xa0, 0xc2, 0x81, 0x20, 0xe7, 0x75, 0xfc, 0x67, 0x40,
+    0x1f, 0xaf, 0xc2, 0x1f, 0x09, 0xf9, 0x20, 0xff, 0xba, 0x01, 0xd2, 0xf6, 0x91, 0x6a, 0x56, 0x78,
+    0x8f, 0xa5, 0x7c, 0xb0, 0xb0, 0xa6, 0x2f, 0x11, 0x0d, 0x7d, 0x52, 0xc7, 0x96, 0x42, 0x83, 0x16,
+    0x44, 0xa6, 0x0c, 0xff, 0xb9, 0xc2, 0xaa, 0x2f, 0x53, 0x9b, 0x13, 0x6b, 0xd9, 0x96, 0xad, 0x48,
+    0xcf, 0x5a, 0x64, 0x6d, 0x6d, 0xfd, 0x2a, 0x94, 0xb6, 0x94, 0x22, 0xa9, 0xa1, 0x88, 0x9c, 0x7f,
+    0x59, 0x81, 0x1a, 0x15, 0xe3, 0xa0, 0x0a, 0x11, 0x66, 0xfa, 0x87, 0x25, 0xbd, 0x65, 0x2e, 0x31,
+    0xaa, 0x40, 0x9e, 0xb9, 0x64, 0xba, 0x8c, 0x07, 0x83, 0x14, 0xc7, 0xdd, 0x80, 0x19, 0x0d, 0x2c,
+    0x5a, 0xfb, 0x47, 0xad, 0x83, 0x0d, 0xd0, 0x56, 0xf3, 0x08, 0x59, 0x9f, 0x3c, 0xf1, 0xa8, 0x79,
+    0x8c, 0x13, 0x0f, 0x8f, 0x51, 0x2a, 0xfa, 0x43, 0xcd, 0xec, 0x74, 0x3e, 0xba, 0xa6, 0xd6, 0x75,
+    0xaf, 0x7e, 0x89, 0xfe, 0x1b, 0xb9, 0x0d, 0x27, 0xae, 0xf7, 0xd1, 0x7f, 0x03, 0xd7, 0x77, 0x06,
+    0xf5, 0x21, 0xfa, 0x8f, 0xa4, 0x25, 0xe8, 0xbf, 0x9e, 0xeb, 0x06, 0x35, 0xb0, 0x2b, 0x50, 0x1d,
+    0xbe, 0x43, 0x90, 0x37, 0xf8, 0xf4, 0x80, 0x38, 0x13, 0x82, 0xa0, 0x7a, 0xfb, 0x7d, 0x13, 0xb1,
+    0x6c, 0xa7, 0x41, 0xc0, 0xf4, 0x50, 0x5c, 0xd8, 0x96, 0xc0, 0xc2, 0x07, 0x13, 0xd1, 0x5c, 0xc2,
+    0x5d, 0x00, 0x88, 0xf5, 0xe2, 0x93, 0xef, 0x15, 0xff, 0x66, 0xf1, 0xd7, 0x84, 0x39, 0xf6, 0x08,
+    0x2b, 0xdf, 0x13, 0x49, 0x5b, 0x22, 0x1c, 0x4d, 0xb2, 0xb1, 0x7c, 0xc1, 0x5b, 0x2f, 0xe1, 0xc6,
+    0xa8, 0xc2, 0x78, 0x2a, 0xad, 0x8d, 0x2c, 0x1d, 0x2b, 0xb4, 0xfa, 0x2e, 0xc3, 0x30, 0xee, 0x67,
+    0x37, 0x7a, 0x2a, 0x08, 0x5d, 0x23, 0x78, 0xdc, 0x83, 0x88, 0x30, 0x22, 0x08, 0xe0, 0xf9, 0x59,
+    0xed, 0xb0, 0xd9, 0x3e, 0x6a, 0x1f, 0xbf, 0xef, 0xbc, 0x39, 0x3e, 0x3c, 0x7e, 0xf7, 0xfe, 0xed,
+    0xfb, 0xc3, 0x03, 0x43, 0x80, 0x21, 0x30, 0xef, 0xad, 0xcb, 0xac, 0xcc, 0x91, 0x0e, 0x79, 0xf0,
+    0x0f, 0x99, 0x9d, 0x10, 0xdf, 0xd1, 0x95, 0x03, 0x3c, 0xe2, 0x15, 0xe3, 0x33, 0x09, 0xc8, 0xd3,
+    0xcb, 0x16, 0x38, 0xc6, 0x6c, 0x3c, 0x5d, 0x38, 0x8e, 0x68, 0xf2, 0x5f, 0xad, 0xef, 0x0d, 0xe9,
+    0xab, 0xfd, 0xdd, 0xf5, 0xb0, 0x25, 0x4d, 0xd5, 0x0a, 0xb7, 0xae, 0x66, 0x72, 0xcc, 0xe3, 0x6c,
+    0x96, 0x46, 0x48, 0xe2, 0x4e, 0x11, 0x74, 0xe7, 0xd8, 0xa3, 0x47, 0xc5, 0x31, 0x45, 0x6e, 0x20,
+    0xd5, 0xcb, 0xcf, 0x89, 0xe3, 0xd0, 0x37, 0x11, 0xe5, 0x5f, 0x62, 0xc3, 0xa3, 0x49, 0x86, 0x31,
+    0x50, 0x26, 0xf6, 0x1b, 0x34, 0xd7, 0x45, 0xd3, 0xee, 0xfc, 0x0c, 0xdf, 0x77, 0x61, 0x79, 0xdc,
+    0x57, 0x04, 0x5e, 0x9e, 0x0f, 0x72, 0x1b, 0xb9, 0x2d, 0x1e, 0xd1, 0xf1, 0xe2, 0xfe, 0xc0, 0xf8,
+    0x76, 0x34, 0xb9, 0xc2, 0xa1, 0x8f, 0x49, 0xfa, 0xaa, 0x7e, 0x7e, 0x16, 0x4a, 0xe6, 0x4e, 0xbb,
+    0xf9, 0xee, 0xed, 0x71, 0x43, 0xc4, 0x39, 0x6c, 0x37, 0xdf, 0x1e, 0xd3, 0x7c, 0x34, 0x49, 0xc9,
+    0x7b, 0xa5, 0x10, 0x4f, 0x89, 0x97, 0x22, 0x81, 0x2e, 0x2f, 0x70, 0xd3, 0x79, 0x31, 0xdc, 0x14,
+    0x90, 0x17, 0x68, 0x1c, 0xd0, 0x64, 0xc7, 0x5e, 0x6b, 0xdc, 0x3b, 0x64, 0x24, 0x02, 0x91, 0xca,
+    0x90, 0x92, 0x0c, 0xd7, 0x63, 0xdf, 0x10, 0x33, 0x18, 0x0a, 0x30, 0xb2, 0x31, 0xc3, 0xe0, 0xf1,
+    0x92, 0x2a, 0x64, 0x9b, 0xcc, 0x38, 0x93, 0x6e, 0x46, 0xe3, 0x81, 0x22, 0x29, 0xa0, 0x78, 0x91,
+    0x5f, 0xd4, 0xb3, 0x21, 0x9a, 0xd5, 0x29, 0x3a, 0x77, 0x80, 0x85, 0x49, 0x44, 0x19, 0xd0, 0xf1,
+    0x1d, 0x32, 0x36, 0x75, 0xda, 0x5f, 0x6e, 0x70, 0x7e, 0x86, 0x65, 0x89, 0xe0, 0x26, 0x12, 0xa2,
+    0x1a, 0x0a, 0xd1, 0x9a, 0xc9, 0xcb, 0x60, 0x64, 0x26, 0xf8, 0x12, 0xf3, 0xfb, 0x18, 0x08, 0xa9,
+    0x2a, 0x88, 0x93, 0x65, 0xe2, 0xcb, 0x89, 0x52, 0xe4, 0x90, 0xdc, 0x42, 0xc2, 0x8a, 0x52, 0xc5,
+    0xcd, 0xd8, 0xad, 0x4b, 0x9f, 0xf7, 0x13, 0x6e, 0x7c, 0x4a, 0x9e, 0x7c, 0xf9, 0xed, 0xec, 0xe4,
+    0x97, 0xb3, 0x93, 0x8b, 0xb3, 0x2f, 0x3f, 0xd7, 0x2c, 0x0f, 0x04, 0x20, 0x82, 0x39, 0x3c, 0x6e,
+    0x19, 0x0e, 0xfa, 0x7c, 0xfc, 0xee, 0xed, 0x61, 0xab, 0xfd, 0xe6, 0xa0, 0xb0, 0xc3, 0x07, 0x56,
+    0x13, 0x71, 0x58, 0x15, 0x77, 0xff, 0x70, 0x90, 0xf4, 0x72, 0x05, 0xb7, 0x18, 0xda, 0x17, 0xc2,
+    0x45, 0x69, 0xd2, 0x09, 0xb5, 0x50, 0x7f, 0xd7, 0x50, 0x13, 0x75, 0x94, 0x02, 0x2d, 0x15, 0xc7,
+    0x02, 0xea, 0x14, 0x22, 0x45, 0x0d, 0xe2, 0xc9, 0x24, 0x66, 0xa1, 0x9f, 0x0c, 0x01, 0x53, 0xc1,
+    0x9a, 0x9a, 0xa6, 0x8b, 0xec, 0x32, 0x9e, 0xbf, 0xb8, 0x30, 0x3a, 0xfb, 0xa7, 0xbe, 0xb6, 0x38,
+    0x66, 0x3b, 0x88, 0x67, 0x25, 0x4f, 0x65, 0xb1, 0xdc, 0xb2, 0xb8, 0xd5, 0x0c, 0x66, 0x5d, 0xe4,
+    0x6a, 0x19, 0xae, 0xac, 0xcb, 0xf0, 0xeb, 0xb2, 0x96, 0x1e, 0xc3, 0x79, 0xf6, 0x0e, 0xc3, 0xd9,
+    0xe5, 0x9d, 0xc2, 0x41, 0x4a, 0x48, 0x28, 0xe9, 0x90, 0xb5, 0xbd, 0x51, 0xa9, 0x2b, 0xd4, 0x7e,
+    0x78, 0x7e, 0x21, 0x97, 0x5e, 0xfb, 0x83, 0x55, 0x9c, 0xe9, 0xd5, 0x81, 0x61, 0xc9, 0x06, 0x42,
+    0x58, 0x96, 0x2f, 0xcf, 0x09, 0x4b, 0x08, 0x6f, 0x81, 0x66, 0x43, 0x9e, 0x97, 0x5b, 0x44, 0x5e,
+    0x7c, 0x36, 0xf4, 0x08, 0xce, 0xf0, 0xc5, 0x5c, 0x30, 0xf6, 0x07, 0x2d, 0xbd, 0x09, 0xbb, 0xab,
+    0x6d, 0xb0, 0xf5, 0x03, 0xeb, 0x84, 0xf2, 0x1e, 0x60, 0xcd, 0xd7, 0xf8, 0x5c, 0x09, 0x2f, 0x1a,
+    0xc5, 0xec, 0xc5, 0x88, 0x46, 0xbb, 0xf3, 0x0e, 0xa9, 0xf7, 0x6c, 0x8a, 0xf1, 0xed, 0x94, 0x88,
+    0x04, 0x36, 0x27, 0xef, 0x41, 0xe0, 0xa0, 0x95, 0xa0, 0xa8, 0x84, 0xd2, 0x12, 0x15, 0xf1, 0x58,
+    0xe2, 0x04, 0x08, 0x5c, 0x01, 0x6e, 0x9d, 0x7e, 0xdd, 0x78, 0x6f, 0x8e, 0x68, 0x3c, 0x74, 0xe1,
+    0x61, 0x95, 0x17, 0x6d, 0xf0, 0xdd, 0x2a, 0xb3, 0x97, 0x6f, 0x08, 0x4b, 0x30, 0xe0, 0xbf, 0xa5,
+    0xbf, 0xe9, 0x36, 0x64, 0xc8, 0xc7, 0x97, 0xfd, 0x00, 0xbd, 0x81, 0x19, 0xbb, 0xf1, 0xf8, 0x92,
+    0x64, 0x8a, 0x1c, 0x3a, 0x1a, 0x40, 0xbc, 0x47, 0x07, 0x84, 0x69, 0xb5, 0x90, 0xce, 0xb0, 0xd4,
+    0x1d, 0xf6, 0x8b, 0xeb, 0xc1, 0x8a, 0xce, 0x02, 0x56, 0x2a, 0x57, 0xee, 0xb2, 0xab, 0x5c, 0x29,
+    0xcb, 0xeb, 0xf5, 0x8a, 0x58, 0x3a, 0xf8, 0xc5, 0x0a, 0x50, 0x8c, 0xea, 0x8e, 0xa0, 0x8f, 0xea,
+    0xe6, 0xe4, 0x39, 0x0b, 0xb9, 0x22, 0x57, 0xed, 0x14, 0x7c, 0x49, 0x94, 0x54, 0xe7, 0x89, 0xd8,
+    0x99, 0x44, 0x83, 0xd0, 0xe4, 0x1a, 0x56, 0xa4, 0xa5, 0x01, 0xd4, 0xf2, 0x73, 0xe2, 0xbe, 0x44,
+    0x0a, 0xe9, 0x95, 0x56, 0x07, 0xe9, 0x95, 0x4e, 0x44, 0xfe, 0xea, 0xd5, 0x78, 0x6c, 0x53, 0x10,
+    0x29, 0xd3, 0x39, 0x04, 0xb2, 0x6e, 0x5c, 0xf9, 0x57, 0xf0, 0x6a, 0xbb, 0xf6, 0xa4, 0x17, 0x63,
+    0x2c, 0xd5, 0xb6, 0x04, 0xfa, 0x03, 0xaa, 0x5c, 0xb1, 0x3d, 0xd0, 0xb2, 0x33, 0xa6, 0xe2, 0x85,
+    0xf3, 0x8e, 0x52, 0x0c, 0xf7, 0x5f, 0xa1, 0x32, 0x63, 0xbc, 0x49, 0xfc, 0xa6, 0x16, 0xea, 0x32,
+    0x39, 0x18, 0x28, 0xbb, 0x67, 0x4b, 0x6e, 0xcb, 0x5a, 0x4b, 0x99, 0x8a, 0x14, 0x2a, 0x2d, 0x84,
+    0x0e, 0xf0, 0x4c, 0x7a, 0x22, 0xd8, 0xd2, 0x92, 0xba, 0x17, 0xad, 0xa7, 0x31, 0x58, 0x43, 0x50,
+    0xc8, 0xd4, 0x4a, 0xe2, 0x20, 0x21, 0x4c, 0xe1, 0x63, 0x2e, 0x7e, 0xba, 0xf0, 0x78, 0x2f, 0xe8,
+    0xbd, 0xaa, 0x72, 0x15, 0xdd, 0xac, 0xce, 0x1b, 0x15, 0xf7, 0xc7, 0x0d, 0xe1, 0xb7, 0x9b, 0x97,
+    0x93, 0x4c, 0x57, 0xd0, 0x49, 0xdb, 0x5d, 0x8f, 0xf5, 0x4d, 0x73, 0x11, 0x0a, 0x12, 0x3a, 0x11,
+    0x7e, 0xf7, 0xa7, 0x6e, 0xb6, 0xdd, 0xa0, 0x90, 0xdc, 0x47, 0xf2, 0xc5, 0x75, 0x62, 0x97, 0x4e,
+    0x50, 0x7f, 0x41, 0x75, 0x0d, 0x87, 0xa3, 0xcf, 0x1b, 0x18, 0xb1, 0xeb, 0x8b, 0x0a, 0x71, 0xe4,
+    0x54, 0x37, 0xc0, 0xe9, 0x16, 0xe3, 0xf5, 0x11, 0x42, 0x65, 0x71, 0xab, 0xf3, 0xd7, 0x93, 0x3f,
+    0xbb, 0xbf, 0x9c, 0x7d, 0x39, 0xed, 0x7e, 0x3a, 0xbb, 0xf8, 0xed, 0xe4, 0xcb, 0xc7, 0xd3, 0xda,
+    0x61, 0xe7, 0xed, 0x9b, 0xb7, 0x92, 0x5d, 0xba, 0xb7, 0x63, 0xab, 0xdb, 0xb1, 0x48, 0x72, 0x0e,
+    0xe6, 0xe9, 0xc2, 0x1a, 0xc3, 0x64, 0x6f, 0x31, 0xee, 0x2d, 0xc6, 0xd7, 0x6a, 0x31, 0xee, 0x6d,
+    0xb8, 0xbd, 0x0d, 0xf7, 0xcc, 0x6d, 0x38, 0x26, 0x9e, 0xab, 0x9a, 0x71, 0x41, 0x61, 0x75, 0xdc,
+    0x1b, 0x76, 0x7b, 0xc3, 0x6e, 0x6f, 0xd8, 0x3d, 0x91, 0x61, 0xf7, 0x82, 0x2c, 0xaf, 0xca, 0xfb,
+    0xc6, 0xdb, 0xdb, 0x64, 0xeb, 0x95, 0xd0, 0x2a, 0x27, 0x36, 0xf7, 0xa6, 0x97, 0x6e, 0x7a, 0x59,
+    0x9e, 0x37, 0xa3, 0x1b, 0xe5, 0xc0, 0xae, 0x6a, 0x37, 0xdb, 0x9f, 0x39, 0x7b, 0x1c, 0x8b, 0xad,
+    0x68, 0x5f, 0xb1, 0x1c, 0x65, 0xa5, 0xea, 0x5e, 0x7c, 0x3c, 0xf9, 0xe5, 0xb4, 0xd6, 0xd9, 0xc2,
+    0x92, 0x7b, 0x68, 0x7b, 0xcd, 0x6e, 0x91, 0x95, 0x5b, 0x74, 0xf7, 0xb1, 0xd7, 0xc4, 0xae, 0x62,
+    0xd9, 0x24, 0xda, 0x9b, 0x69, 0x0f, 0x67, 0xa6, 0x3d, 0x03, 0xab, 0xe8, 0xd9, 0x59, 0x8a, 0x3b,
+    0x36, 0xd3, 0xf6, 0x97, 0x50, 0x9f, 0xd1, 0x25, 0xd4, 0x57, 0x6e, 0x0e, 0x3f, 0xad, 0xf9, 0xf9,
+    0xdc, 0x8c, 0xf1, 0x5d, 0x99, 0xc3, 0xff, 0x6f, 0xae, 0x05, 0xdf, 0xdf, 0xe4, 0x67, 0x70, 0x9b,
+    0x6d, 0xde, 0x1a, 0x74, 0xa8, 0xbd, 0xcd, 0xbf, 0xb7, 0xf9, 0xf7, 0x36, 0xff, 0x43, 0xd8, 0xfc,
+    0x62, 0x2a, 0xc6, 0xb2, 0x82, 0x5e, 0xee, 0x0b, 0xd8, 0xe6, 0x72, 0xaa, 0x22, 0x6f, 0xf4, 0x10,
+    0x2e, 0x6b, 0x6d, 0xf2, 0xdd, 0x19, 0x1a, 0xaf, 0xe5, 0x6e, 0xe8, 0xcb, 0xdf, 0x29, 0x5f, 0xef,
+    0x2a, 0x79, 0x46, 0x97, 0x4c, 0x9f, 0xd0, 0x95, 0xb3, 0x0f, 0x71, 0xfc, 0xba, 0x1e, 0x3e, 0x91,
+    0xbb, 0x5a, 0x6e, 0x9f, 0xda, 0xe6, 0xe6, 0xd2, 0xe3, 0xbd, 0x16, 0xa8, 0xc1, 0x82, 0x35, 0xc0,
+    0x95, 0x09, 0x67, 0x62, 0xc0, 0x89, 0xa8, 0xf6, 0x68, 0x7f, 0x97, 0x61, 0x04, 0x8a, 0xc3, 0x17,
+    0xe5, 0x3f, 0x24, 0xd8, 0x96, 0xa8, 0x23, 0xc9, 0x55, 0x67, 0xbe, 0x40, 0x04, 0x6a, 0x3f, 0x37,
+    0x97, 0x2a, 0x7c, 0x52, 0x0e, 0x9f, 0xa8, 0xf0, 0xab, 0x2e, 0x7e, 0x31, 0xb9, 0xce, 0x7b, 0x02,
+    0x29, 0x38, 0xf4, 0x46, 0x17, 0xa7, 0x0f, 0xd3, 0xe4, 0x68, 0xb5, 0xae, 0xea, 0x1d, 0xfa, 0xec,
+    0x8b, 0xab, 0x13, 0xb4, 0x12, 0xc8, 0x93, 0x6d, 0x90, 0x27, 0x76, 0xe4, 0x89, 0x60, 0x0c, 0x1c,
+    0xf5, 0x64, 0xf3, 0x8b, 0xe7, 0x98, 0x83, 0x50, 0xaf, 0xfa, 0xa8, 0xe5, 0xae, 0x84, 0x2b, 0xd9,
+    0xe2, 0xda, 0x38, 0xc5, 0x95, 0x20, 0x5c, 0x89, 0xab, 0x78, 0x7c, 0x01, 0x97, 0xf1, 0xea, 0x38,
+    0xaa, 0xd4, 0x37, 0x67, 0x24, 0xae, 0xf9, 0xca, 0x38, 0xf1, 0x01, 0x3f, 0xe0, 0xfb, 0x13, 0x2f,
+    0xd8, 0x03, 0x5c, 0xe9, 0xc4, 0x0e, 0x1d, 0x2c, 0xf2, 0x6c, 0x75, 0x5c, 0x50, 0xf0, 0x50, 0xef,
+    0x77, 0x57, 0x52, 0xba, 0xa9, 0x54, 0x62, 0x29, 0x95, 0x3c, 0xd2, 0xe9, 0x20, 0x9a, 0x0a, 0x95,
+    0xc4, 0xa6, 0xc4, 0x64, 0x1b, 0xa5, 0x70, 0x7f, 0xdf, 0x65, 0x7f, 0x7a, 0x69, 0x7f, 0x7a, 0xa9,
+    0xdc, 0x2d, 0xce, 0x86, 0xcc, 0xe0, 0x33, 0x7b, 0x08, 0x97, 0x39, 0x76, 0x14, 0x95, 0x50, 0x29,
+    0xf2, 0xad, 0x7d, 0x25, 0x40, 0x4c, 0xfc, 0x25, 0xe5, 0x96, 0xf5, 0xa6, 0x0a, 0xb6, 0xbf, 0xbc,
+    0xb3, 0x3f, 0xf8, 0xf5, 0x4c, 0x0e, 0x7e, 0xed, 0xce, 0xb7, 0x2d, 0x4d, 0x45, 0xf1, 0xd3, 0x50,
+    0xb3, 0xc8, 0xf4, 0xd5, 0xf9, 0x69, 0x6a, 0xb2, 0x8c, 0xc9, 0x38, 0xc9, 0xf6, 0x2e, 0xe8, 0xbd,
+    0x0b, 0x7a, 0xef, 0x82, 0x7e, 0x85, 0x2e, 0x68, 0xac, 0xaa, 0x47, 0x54, 0x66, 0xf0, 0x79, 0xe9,
+    0xe9, 0xd6, 0x47, 0x73, 0x19, 0x48, 0x02, 0x85, 0x8f, 0x5f, 0x01, 0x6c, 0x55, 0xe7, 0x86, 0x89,
+    0x4b, 0xb1, 0x27, 0x6b, 0xb1, 0x27, 0xd5, 0xb0, 0x27, 0x12, 0x76, 0x88, 0x6e, 0x56, 0xcd, 0x4d,
+    0xbe, 0x3e, 0x34, 0xd7, 0xa2, 0x7f, 0x89, 0xbb, 0xb5, 0x18, 0x63, 0x09, 0x59, 0x6c, 0xcf, 0xcc,
+    0x0a, 0xda, 0xdf, 0xe2, 0x2a, 0x5f, 0x87, 0x77, 0xa7, 0x07, 0x3f, 0xae, 0x12, 0xfb, 0x12, 0x2f,
+    0x94, 0x19, 0x31, 0x94, 0x1c, 0x04, 0x28, 0xf6, 0x78, 0x69, 0x87, 0x6f, 0xa0, 0xae, 0xbc, 0x40,
+    0xff, 0x28, 0x12, 0x42, 0x90, 0xdb, 0x8d, 0x8d, 0xd1, 0x88, 0xb0, 0x28, 0x71, 0x9b, 0xb1, 0x06,
+    0x9c, 0x58, 0x81, 0x93, 0x02, 0x30, 0x76, 0xe5, 0xf1, 0x5a, 0x7c, 0x8e, 0xc2, 0xc7, 0x72, 0xce,
+    0x0d, 0x89, 0x63, 0x2e, 0x52, 0xde, 0x97, 0x3d, 0x6e, 0x08, 0xe9, 0x28, 0x4b, 0x68, 0x12, 0x50,
+    0xd8, 0x94, 0x43, 0xd1, 0x3e, 0xfe, 0xf1, 0xcf, 0x4a, 0x27, 0x2c, 0xf3, 0x31, 0x5a, 0x41, 0xe6,
+    0xf2, 0x63, 0x14, 0x5c, 0xe6, 0xe3, 0x15, 0xc5, 0x92, 0x99, 0x5c, 0x5d, 0x5e, 0xa6, 0xf3, 0xb2,
+    0x87, 0x67, 0x37, 0x0c, 0xc3, 0xd5, 0x32, 0xa4, 0xb5, 0xb7, 0x8d, 0xcd, 0xd5, 0x8a, 0x1c, 0xc7,
+    0x1c, 0xbb, 0xb0, 0x01, 0x27, 0x6f, 0x03, 0x95, 0xfe, 0x9a, 0x0b, 0x51, 0x86, 0x48, 0xc9, 0x76,
+    0x44, 0x42, 0xb9, 0xc1, 0x03, 0xe7, 0x72, 0x07, 0x40, 0xf8, 0x29, 0xd1, 0x55, 0x52, 0xe7, 0xca,
+    0x7b, 0xc9, 0xdd, 0xdc, 0x1a, 0xd3, 0xd2, 0xba, 0xd4, 0xb6, 0xec, 0x59, 0xed, 0xca, 0xdd, 0x54,
+    0x18, 0x9d, 0x39, 0xc4, 0x40, 0x42, 0xaa, 0xc4, 0x02, 0x22, 0x72, 0x97, 0x65, 0x83, 0xb0, 0x2c,
+    0x8e, 0x7c, 0x8c, 0xba, 0x0d, 0x87, 0x83, 0xd3, 0xdf, 0x37, 0x61, 0x10, 0xbd, 0x6c, 0x9a, 0xcf,
+    0xe3, 0x85, 0xe9, 0xfd, 0x13, 0x78, 0xa9, 0x64, 0x31, 0x1b, 0x4d, 0xbb, 0x37, 0x38, 0x0a, 0xaf,
+    0x76, 0xa4, 0x5c, 0x88, 0xe5, 0x56, 0x71, 0x62, 0xb6, 0x48, 0x50, 0xb1, 0xd6, 0x9a, 0x30, 0xb1,
+    0x6d, 0x02, 0xd6, 0x26, 0xd1, 0xb8, 0x09, 0xb2, 0x66, 0x4c, 0x54, 0x7f, 0x54, 0x05, 0x4d, 0x98,
+    0x0f, 0x92, 0x48, 0xfc, 0x0c, 0x18, 0x58, 0x78, 0xc7, 0x0b, 0xb5, 0xf5, 0x42, 0x6d, 0x51, 0xa8,
+    0x2d, 0x0a, 0xb5, 0xa1, 0x90, 0xe6, 0xef, 0x27, 0xd8, 0x7c, 0x1a, 0x05, 0x96, 0x8d, 0x3e, 0x7d,
+    0x54, 0xa9, 0x89, 0x64, 0x84, 0x14, 0xcd, 0x14, 0xba, 0x84, 0xe3, 0x05, 0xb4, 0x21, 0x7c, 0xe1,
+    0x68, 0xda, 0x10, 0xc9, 0x1c, 0x7d, 0xf8, 0x6a, 0x8f, 0x41, 0x84, 0x7f, 0xd7, 0xb7, 0xe4, 0xdd,
+    0x2e, 0x57, 0xd6, 0xbc, 0xd5, 0xed, 0x92, 0xc7, 0x45, 0x8b, 0xaf, 0x53, 0x24, 0x1d, 0xd2, 0x88,
+    0xbd, 0x40, 0xc4, 0x9e, 0x95, 0x62, 0xef, 0x49, 0xb9, 0xc1, 0x21, 0x84, 0xb1, 0x84, 0x08, 0xe1,
+    0x0e, 0x85, 0x6d, 0xa0, 0x2f, 0x08, 0xdf, 0x55, 0x1c, 0x7e, 0x20, 0x18, 0x2a, 0xc4, 0xb3, 0xc7,
+    0x2b, 0x0c, 0x3f, 0x99, 0x3e, 0x64, 0xe8, 0x81, 0xa1, 0xc0, 0xbe, 0x26, 0x0d, 0xd4, 0x59, 0xd1,
+    0x5f, 0x9b, 0xe0, 0x32, 0x44, 0xe8, 0xb7, 0x05, 0x0f, 0x54, 0xe1, 0x57, 0x48, 0xd1, 0x24, 0x2c,
+    0x96, 0x14, 0x24, 0x5e, 0x18, 0x23, 0xd2, 0xe7, 0xd5, 0xf8, 0xb8, 0xed, 0x74, 0xf8, 0x7c, 0x16,
+    0xe2, 0xeb, 0x7e, 0xf2, 0x17, 0xf5, 0xd2, 0x22, 0xa7, 0x53, 0xe6, 0xfc, 0x2c, 0x2a, 0x04, 0xdb,
+    0x0b, 0x8d, 0x5b, 0x26, 0xd4, 0x5a, 0x36, 0x6f, 0x99, 0x28, 0xa9, 0x87, 0x50, 0x82, 0xdb, 0x49,
+    0xaa, 0xcc, 0xe5, 0x5e, 0x47, 0x60, 0x4c, 0x5d, 0x08, 0x25, 0x59, 0x36, 0x06, 0x21, 0xb3, 0x20,
+    0x1b, 0x6d, 0x10, 0xe8, 0xb1, 0x8b, 0x89, 0x8d, 0x25, 0x49, 0xaf, 0x01, 0x5d, 0xa6, 0x31, 0x96,
+    0xa5, 0x05, 0x38, 0xf5, 0x05, 0x3e, 0x0c, 0x5b, 0x96, 0x69, 0xc9, 0xea, 0xc5, 0x13, 0xc4, 0x83,
+    0x60, 0xc8, 0x41, 0xd0, 0x35, 0x24, 0x99, 0xd9, 0x3b, 0x08, 0x16, 0xf8, 0xd9, 0x28, 0xef, 0x0d,
+    0x75, 0x5a, 0xe7, 0x59, 0x1e, 0xe7, 0x69, 0x77, 0xb1, 0x9a, 0x24, 0xd9, 0xd8, 0x52, 0x90, 0x84,
+    0x98, 0xd3, 0x76, 0x93, 0x14, 0x21, 0xde, 0x1b, 0xe2, 0x08, 0x8c, 0x2f, 0x60, 0xf7, 0x60, 0xcd,
+    0x06, 0x1a, 0x49, 0x1d, 0xc7, 0x49, 0x8a, 0x16, 0xae, 0x71, 0x3c, 0x4d, 0x2d, 0x10, 0x03, 0xf6,
+    0x7a, 0x83, 0x96, 0x2d, 0x38, 0x00, 0x44, 0xb0, 0x9e, 0x8c, 0x47, 0x80, 0x98, 0xcb, 0x93, 0x78,
+    0x16, 0x5a, 0x8e, 0x5c, 0x15, 0x4d, 0xbb, 0x82, 0x61, 0xa7, 0xb0, 0xe8, 0x33, 0x79, 0x79, 0x5c,
+    0xe8, 0x31, 0x91, 0x3c, 0x2b, 0xf9, 0x49, 0x13, 0xe6, 0x1d, 0x55, 0x73, 0xd9, 0x39, 0x15, 0xac,
+    0x79, 0x08, 0x0f, 0x20, 0x4b, 0x84, 0x0e, 0x61, 0xa9, 0x08, 0x54, 0xe6, 0xcb, 0x45, 0x3a, 0x98,
+    0x40, 0xb0, 0x41, 0xc4, 0x79, 0xe3, 0x34, 0x6a, 0x68, 0xf3, 0xfa, 0xaf, 0xce, 0x77, 0xa6, 0xa8,
+    0x42, 0x9f, 0xc2, 0x02, 0xf6, 0x83, 0x65, 0xfa, 0xc2, 0x3b, 0x23, 0x3f, 0xd8, 0x67, 0x2d, 0xea,
+    0x54, 0x4c, 0x05, 0x88, 0x41, 0x42, 0xd0, 0x5f, 0xad, 0xef, 0x3e, 0xfd, 0xd5, 0xfe, 0xee, 0xb3,
+    0x09, 0xec, 0x06, 0x38, 0x6e, 0x71, 0x78, 0x57, 0x83, 0x3e, 0xab, 0x41, 0x8d, 0xf7, 0xab, 0x90,
+    0x57, 0x56, 0x44, 0x5c, 0xd6, 0x94, 0xf5, 0x88, 0xa9, 0x54, 0xa1, 0xf8, 0xd4, 0x34, 0xd5, 0x57,
+    0x76, 0x9e, 0x8d, 0xa6, 0xf9, 0xba, 0x10, 0xda, 0x34, 0x12, 0x32, 0x97, 0x46, 0x48, 0x04, 0x0d,
+    0x33, 0x21, 0x8d, 0x22, 0x15, 0x5b, 0x53, 0x1d, 0x45, 0x06, 0x45, 0xa4, 0x4b, 0xa4, 0xcf, 0x91,
+    0xda, 0x4f, 0x07, 0x56, 0xc4, 0x41, 0x89, 0x08, 0xac, 0x7d, 0x38, 0x28, 0xc9, 0x0d, 0xac, 0x38,
+    0x15, 0xda, 0x24, 0x97, 0x16, 0x25, 0x8f, 0x98, 0x65, 0x60, 0xa7, 0x80, 0x0b, 0x53, 0xa5, 0x1d,
+    0x9b, 0x5e, 0xe0, 0x59, 0x0e, 0xa1, 0x27, 0xbd, 0xa8, 0x50, 0x9a, 0x9d, 0x8b, 0x42, 0x8a, 0x00,
+    0x3b, 0xff, 0x44, 0xe5, 0x44, 0xed, 0x27, 0xcc, 0xa5, 0x41, 0xe7, 0x08, 0x7b, 0x59, 0xf1, 0x48,
+    0x28, 0xac, 0x8e, 0xa5, 0x33, 0x91, 0xd5, 0xa0, 0xc9, 0xa3, 0x9a, 0x42, 0xc2, 0x5f, 0x8a, 0xf8,
+    0x66, 0xba, 0x22, 0x99, 0x5a, 0xe7, 0x6b, 0x07, 0x91, 0xc4, 0x5e, 0x6e, 0xe3, 0x90, 0xd0, 0xfc,
+    0x5d, 0x9e, 0x58, 0x1f, 0xaf, 0xe5, 0x2a, 0x28, 0x8c, 0x20, 0x86, 0x4c, 0x22, 0x53, 0x45, 0x00,
+    0x6f, 0x4c, 0xbf, 0x09, 0xf5, 0x66, 0xe0, 0xf8, 0xb1, 0x0e, 0x9c, 0x9d, 0xc2, 0x07, 0xb4, 0xd4,
+    0x85, 0xc6, 0x87, 0xe3, 0x57, 0x70, 0xc6, 0x2b, 0xbc, 0x93, 0xbb, 0x02, 0xcf, 0x76, 0xc4, 0xab,
+    0xd3, 0x08, 0x87, 0x29, 0x95, 0x65, 0x40, 0x5d, 0xc3, 0xaf, 0xf2, 0x27, 0x29, 0xd8, 0x43, 0xd2,
+    0x09, 0x07, 0x67, 0x2d, 0x2f, 0x08, 0x0e, 0xe4, 0x1a, 0xfb, 0xa4, 0x1d, 0x17, 0x61, 0xaf, 0x32,
+    0x47, 0xe3, 0x63, 0x3f, 0x3d, 0x27, 0xc7, 0xd7, 0x7f, 0xf5, 0x68, 0xa4, 0x5f, 0xd9, 0xf3, 0x0c,
+    0xb2, 0xd1, 0xb4, 0xba, 0xf0, 0x31, 0x91, 0x21, 0x51, 0x47, 0x2a, 0x81, 0x6a, 0x24, 0x3b, 0x4e,
+    0x5b, 0x7d, 0xa8, 0x43, 0x5a, 0x2b, 0x1c, 0xa8, 0x09, 0x37, 0x75, 0xad, 0x3d, 0x1e, 0xdf, 0xb8,
+    0x0a, 0x0e, 0x21, 0x5a, 0x2f, 0xe7, 0x4b, 0x29, 0xfe, 0xf4, 0x35, 0x95, 0xca, 0xe8, 0xdf, 0x40,
+    0x5a, 0xa0, 0x60, 0xf4, 0xe5, 0x25, 0x88, 0x2d, 0x27, 0xf4, 0xd3, 0x51, 0x75, 0x28, 0x1e, 0x9d,
+    0x5c, 0x68, 0x0a, 0x91, 0x9c, 0x8f, 0x84, 0x28, 0xb6, 0x29, 0x20, 0x0e, 0xaf, 0xa2, 0x4f, 0xd4,
+    0x3e, 0x34, 0x54, 0xfd, 0x42, 0x5d, 0xf8, 0xf8, 0xb3, 0x55, 0xe0, 0x26, 0x81, 0xd8, 0xd9, 0x0a,
+    0xd2, 0xd6, 0xf7, 0xba, 0x54, 0xd4, 0xb5, 0x3a, 0x6f, 0xa9, 0xa9, 0x14, 0x3e, 0x49, 0xa8, 0xa8,
+    0xcd, 0xd7, 0xf6, 0x7b, 0x3a, 0xd3, 0x64, 0xd5, 0x0b, 0x3b, 0x9a, 0x28, 0x80, 0xa7, 0xd5, 0x6b,
+    0x7d, 0x2f, 0x82, 0xfe, 0x26, 0xfe, 0x20, 0x97, 0x9c, 0xbb, 0xda, 0xab, 0xfc, 0x0f, 0xaf, 0xf2,
+    0xdb, 0x3c, 0xc5, 0xa3, 0xf1, 0xb8, 0xec, 0xe4, 0x92, 0xc8, 0xb7, 0x1f, 0x5f, 0x12, 0x30, 0xa6,
+    0x33, 0x4c, 0x52, 0x6e, 0x99, 0xf3, 0x5f, 0x05, 0x2b, 0x7b, 0xf9, 0x29, 0x1e, 0x67, 0x65, 0x14,
+    0x8b, 0x7c, 0x3b, 0xc5, 0x02, 0xc6, 0x44, 0xb1, 0x94, 0x5b, 0x46, 0xb1, 0x0a, 0xf6, 0xa2, 0x0f,
+    0x3b, 0xe1, 0xa6, 0x94, 0x9c, 0x9b, 0x11, 0xf9, 0xf6, 0x47, 0x59, 0x39, 0x88, 0xf1, 0x61, 0x56,
+    0x91, 0x5b, 0xfa, 0x30, 0x97, 0x02, 0xb6, 0x8e, 0x60, 0xfb, 0xb9, 0x36, 0x9e, 0x5d, 0x4e, 0xae,
+    0xed, 0x84, 0x9b, 0xc8, 0x5c, 0x4b, 0xac, 0xb2, 0x37, 0xf1, 0x1c, 0x6d, 0xc1, 0xc7, 0x34, 0xd9,
+    0x37, 0x75, 0x1f, 0x98, 0x4c, 0xfc, 0x6a, 0x36, 0x2b, 0x48, 0x61, 0xc5, 0xed, 0x7a, 0x48, 0x13,
+    0xdb, 0x95, 0xac, 0x55, 0x49, 0xca, 0x89, 0x9f, 0xa6, 0x23, 0x56, 0x22, 0xd7, 0x57, 0x65, 0x9f,
+    0xe9, 0xb0, 0x95, 0x8c, 0x6a, 0x2b, 0xf9, 0x25, 0x7e, 0x9a, 0x68, 0x11, 0xb9, 0xbe, 0x2a, 0xd5,
+    0x4c, 0xb4, 0xc8, 0xa8, 0x36, 0x97, 0x4c, 0x3b, 0x3f, 0x9b, 0x25, 0x09, 0x1c, 0xf1, 0xd3, 0xf4,
+    0x16, 0x2f, 0xcf, 0xf4, 0x55, 0x29, 0x64, 0x7c, 0x93, 0x57, 0xc2, 0xb4, 0x8d, 0x28, 0xe1, 0xbf,
+    0x6c, 0x84, 0xd0, 0x53, 0x71, 0x92, 0x74, 0xb1, 0x92, 0x41, 0xb7, 0x2e, 0x8b, 0x32, 0x62, 0xef,
+    0xd5, 0xd8, 0x7b, 0x35, 0xf6, 0x5e, 0x8d, 0xbd, 0x57, 0x63, 0xef, 0xd5, 0x78, 0x3d, 0x5e, 0x0d,
+    0x76, 0x22, 0x58, 0x9c, 0x79, 0x53, 0x4e, 0xc9, 0x11, 0x3e, 0x78, 0x56, 0x8e, 0x0f, 0xf1, 0x5a,
+    0xd2, 0x7c, 0x96, 0x8d, 0x63, 0x68, 0xfd, 0x3d, 0x3c, 0x21, 0x54, 0x3f, 0x23, 0x27, 0xdc, 0x50,
+    0xdb, 0x9a, 0x4b, 0xb8, 0x73, 0x85, 0xaf, 0x8e, 0x11, 0x25, 0x8d, 0x6c, 0x20, 0x4a, 0x1d, 0xe4,
+    0x93, 0x67, 0x40, 0x6d, 0xf5, 0x93, 0x60, 0x72, 0xf4, 0xf2, 0xd3, 0xc5, 0xa7, 0xcf, 0xdd, 0xf3,
+    0x3f, 0x6b, 0xef, 0xa4, 0xfb, 0x50, 0xa7, 0x9f, 0x7e, 0x3e, 0xed, 0xfe, 0x7c, 0xf2, 0xeb, 0xaf,
+    0x27, 0xa8, 0xb5, 0xed, 0xd6, 0xb1, 0xe1, 0x30, 0xcc, 0x41, 0x51, 0x6b, 0x86, 0xc5, 0xb8, 0x82,
+    0x1d, 0xbc, 0x5b, 0x1b, 0x76, 0x87, 0xf6, 0xe7, 0xae, 0x4c, 0xc8, 0x9d, 0xda, 0x7f, 0x8f, 0x60,
+    0xbe, 0x99, 0xbc, 0x79, 0x66, 0x93, 0x47, 0x3e, 0x6d, 0x65, 0xb1, 0xd2, 0xee, 0x61, 0xc8, 0x94,
+    0x72, 0xe9, 0x66, 0x76, 0x48, 0xb9, 0x19, 0xb2, 0x91, 0x19, 0xf1, 0x18, 0xa7, 0xef, 0x24, 0xe6,
+    0xd9, 0x4c, 0x9f, 0x2f, 0xe3, 0x8c, 0xcd, 0x54, 0x72, 0x10, 0xcf, 0x74, 0x78, 0x40, 0xb1, 0x2e,
+    0x8a, 0x74, 0x3a, 0x4c, 0xfc, 0xb2, 0x3a, 0xd6, 0x07, 0x59, 0xe2, 0x4a, 0x96, 0xcc, 0xac, 0xf1,
+    0x34, 0x53, 0xe8, 0xd8, 0x15, 0x75, 0x1a, 0x11, 0xb4, 0x81, 0x8c, 0x84, 0x34, 0xa4, 0x32, 0xfb,
+    0x61, 0xe2, 0x22, 0x21, 0x0a, 0x03, 0x87, 0xe3, 0xf7, 0x14, 0xd6, 0x74, 0x43, 0xf9, 0x4c, 0xe5,
+    0xd5, 0xe5, 0x65, 0xe4, 0x60, 0x55, 0xb9, 0x81, 0xef, 0x2d, 0x50, 0xb5, 0x99, 0x2b, 0xe2, 0xd0,
+    0x3f, 0xec, 0x30, 0x4e, 0x24, 0xb1, 0x00, 0xa9, 0xce, 0xe1, 0xdd, 0xe7, 0xb5, 0x9b, 0xed, 0xf7,
+    0x01, 0x11, 0xce, 0x75, 0x41, 0x85, 0x5b, 0x42, 0x06, 0xa9, 0x1b, 0x6a, 0x16, 0xa3, 0x19, 0x88,
+    0x05, 0x95, 0x22, 0x0b, 0xef, 0x24, 0x72, 0xf1, 0x91, 0x40, 0x93, 0xbf, 0x18, 0xbc, 0xc5, 0xcd,
+    0xb8, 0xd8, 0x21, 0xa4, 0xae, 0x7e, 0x84, 0x3f, 0x3c, 0x79, 0x82, 0x2a, 0x6a, 0x0e, 0xf6, 0x55,
+    0x4b, 0x87, 0x08, 0x81, 0xb4, 0x86, 0x8c, 0xc0, 0x87, 0x94, 0xba, 0x92, 0x52, 0xf1, 0xc4, 0xa0,
+    0xa7, 0xae, 0x64, 0xf7, 0xf2, 0x65, 0xff, 0x1f, 0x03, 0x90, 0xfe, 0x1c
+};
+
+const char* shaderSource() {
+    static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressedShaderSource), sizeof(compressedShaderSource)));
+    return decompressed.c_str();
+};
+
+} // namespace gl
+} // namespace programs
+} // namespace mbgl
diff --git a/src/mbgl/shaders/source.hpp b/src/mbgl/programs/gl/shader_source.hpp
index 38a5ea6ece..f6de8a56cc 100644
--- a/src/mbgl/shaders/source.hpp
+++ b/src/mbgl/programs/gl/shader_source.hpp
@@ -3,9 +3,11 @@
 #pragma once
 
 namespace mbgl {
-namespace shaders {
+namespace programs {
+namespace gl {
 
-const char* source();
+const char* shaderSource();
 
-} // namespace shaders
+} // namespace gl
+} // namespace programs
 } // namespace mbgl
diff --git a/src/mbgl/shaders/shaders.cpp b/src/mbgl/programs/gl/shaders.cpp
index 578c2db624..3cc33992de 100644
--- a/src/mbgl/shaders/shaders.cpp
+++ b/src/mbgl/programs/gl/shaders.cpp
@@ -1,19 +1,20 @@
-#include <mbgl/shaders/shaders.hpp>
-#include <mbgl/shaders/preludes.hpp>
+#include <mbgl/programs/gl/shaders.hpp>
+#include <mbgl/programs/gl/preludes.hpp>
 #include <mbgl/programs/program_parameters.hpp>
 #include <mbgl/util/string.hpp>
 
 #include <cassert>
 
 namespace mbgl {
-namespace shaders {
+namespace programs {
+namespace gl {
 
 std::string fragmentSource(const ProgramParameters& parameters, const char* fragmentSource) {
-    return parameters.getDefines() + fragmentPrelude + fragmentSource;
+    return parameters.getDefines() + fragmentShaderPrelude + fragmentSource;
 }
 
 std::string vertexSource(const ProgramParameters& parameters, const char* vertexSource) {
-    return parameters.getDefines() + vertexPrelude + vertexSource;
+    return parameters.getDefines() + vertexShaderPrelude + vertexSource;
 }
 
 std::string programIdentifier(const std::string& vertexSource, const std::string& fragmentSource) {
@@ -25,5 +26,6 @@ std::string programIdentifier(const std::string& vertexSource, const std::string
     return result;
 }
 
-} // namespace shaders
+} // namespace gl
+} // namespace programs
 } // namespace mbgl
diff --git a/src/mbgl/shaders/shaders.hpp b/src/mbgl/programs/gl/shaders.hpp
index 513d37fa6f..5278ea54da 100644
--- a/src/mbgl/shaders/shaders.hpp
+++ b/src/mbgl/programs/gl/shaders.hpp
@@ -6,11 +6,13 @@ namespace mbgl {
 
 class ProgramParameters;
 
-namespace shaders {
+namespace programs {
+namespace gl {
 
 std::string fragmentSource(const ProgramParameters&, const char* fragmentSource);
 std::string vertexSource(const ProgramParameters&, const char* vertexSource);
 std::string programIdentifier(const std::string& vertexSource, const std::string& fragmentSource);
 
-} // namespace shaders
+} // namespace gl
+} // namespace programs
 } // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_icon.cpp b/src/mbgl/programs/gl/symbol_icon.cpp
index 7e10f23aa2..733d3b7ebd 100644
--- a/src/mbgl/shaders/symbol_icon.cpp
+++ b/src/mbgl/programs/gl/symbol_icon.cpp
@@ -1,14 +1,22 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/symbol_icon.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/symbol_icon_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<SymbolIconProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<SymbolIconProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_icon",
+        programs::gl::shaderSource() + 50000, programs::gl::shaderSource() + 52654);
+}
 
-const char* symbol_icon::name = "symbol_icon";
-const char* symbol_icon::vertexSource = source() + 50000;
-const char* symbol_icon::fragmentSource = source() + 52654;
+} // namespace gfx
+} // namespace mbgl
 
 // Uncompressed source of symbol_icon.vertex.glsl:
 /*
@@ -152,5 +160,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_sdf.cpp b/src/mbgl/programs/gl/symbol_sdf_icon.cpp
index 1ffc4c338c..ef3ecd138c 100644
--- a/src/mbgl/shaders/symbol_sdf.cpp
+++ b/src/mbgl/programs/gl/symbol_sdf_icon.cpp
@@ -1,16 +1,24 @@
 // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
 
-#include <mbgl/shaders/symbol_sdf.hpp>
-#include <mbgl/shaders/source.hpp>
+#include <mbgl/programs/symbol_sdf_icon_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
 
 namespace mbgl {
-namespace shaders {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<SymbolSDFIconProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<SymbolSDFIconProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_sdf_icon",
+        programs::gl::shaderSource() + 53059, programs::gl::shaderSource() + 57099);
+}
 
-const char* symbol_sdf::name = "symbol_sdf";
-const char* symbol_sdf::vertexSource = source() + 53059;
-const char* symbol_sdf::fragmentSource = source() + 57099;
+} // namespace gfx
+} // namespace mbgl
 
-// Uncompressed source of symbol_sdf.vertex.glsl:
+// Uncompressed source of symbol_sdf_icon.vertex.glsl:
 /*
 const float PI = 3.141592653589793;
 
@@ -202,7 +210,7 @@ void main() {
 
 */
 
-// Uncompressed source of symbol_sdf.fragment.glsl:
+// Uncompressed source of symbol_sdf_icon.fragment.glsl:
 /*
 #define SDF_PX 8.0
 #define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO
@@ -307,5 +315,3 @@ void main() {
 
 */
 
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/programs/gl/symbol_sdf_text.cpp b/src/mbgl/programs/gl/symbol_sdf_text.cpp
new file mode 100644
index 0000000000..a0d810d1ce
--- /dev/null
+++ b/src/mbgl/programs/gl/symbol_sdf_text.cpp
@@ -0,0 +1,317 @@
+// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
+
+#include <mbgl/programs/symbol_sdf_text_program.hpp>
+#include <mbgl/programs/gl/shader_source.hpp>
+#include <mbgl/gl/program.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+template <>
+std::unique_ptr<Program<SymbolSDFTextProgram>>
+Context::createProgram<gl::Context>(const ProgramParameters& programParameters) {
+    return gl::Program<SymbolSDFTextProgram>::createProgram(
+        reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_sdf_text",
+        programs::gl::shaderSource() + 53059, programs::gl::shaderSource() + 57099);
+}
+
+} // namespace gfx
+} // namespace mbgl
+
+// Uncompressed source of symbol_sdf_text.vertex.glsl:
+/*
+const float PI = 3.141592653589793;
+
+attribute vec4 a_pos_offset;
+attribute vec4 a_data;
+attribute vec3 a_projected_pos;
+attribute float a_fade_opacity;
+
+// contents of a_size vary based on the type of property value
+// used for {text,icon}-size.
+// For constants, a_size is disabled.
+// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature.
+// For composite functions:
+// [ text-size(lowerZoomStop, feature),
+//   text-size(upperZoomStop, feature) ]
+uniform bool u_is_size_zoom_constant;
+uniform bool u_is_size_feature_constant;
+uniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function
+uniform highp float u_size; // used when size is both zoom and feature constant
+
+
+#ifndef HAS_UNIFORM_u_fill_color
+uniform lowp float a_fill_color_t;
+attribute highp vec4 a_fill_color;
+varying highp vec4 fill_color;
+#else
+uniform highp vec4 u_fill_color;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_color
+uniform lowp float a_halo_color_t;
+attribute highp vec4 a_halo_color;
+varying highp vec4 halo_color;
+#else
+uniform highp vec4 u_halo_color;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_opacity
+uniform lowp float a_opacity_t;
+attribute lowp vec2 a_opacity;
+varying lowp float opacity;
+#else
+uniform lowp float u_opacity;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_width
+uniform lowp float a_halo_width_t;
+attribute lowp vec2 a_halo_width;
+varying lowp float halo_width;
+#else
+uniform lowp float u_halo_width;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_blur
+uniform lowp float a_halo_blur_t;
+attribute lowp vec2 a_halo_blur;
+varying lowp float halo_blur;
+#else
+uniform lowp float u_halo_blur;
+#endif
+
+
+uniform mat4 u_matrix;
+uniform mat4 u_label_plane_matrix;
+uniform mat4 u_gl_coord_matrix;
+
+uniform bool u_is_text;
+uniform bool u_pitch_with_map;
+uniform highp float u_pitch;
+uniform bool u_rotate_symbol;
+uniform highp float u_aspect_ratio;
+uniform highp float u_camera_to_center_distance;
+uniform float u_fade_change;
+
+uniform vec2 u_texsize;
+
+varying vec2 v_data0;
+varying vec3 v_data1;
+
+void main() {
+    
+#ifndef HAS_UNIFORM_u_fill_color
+    fill_color = unpack_mix_color(a_fill_color, a_fill_color_t);
+#else
+    highp vec4 fill_color = u_fill_color;
+#endif
+
+    
+#ifndef HAS_UNIFORM_u_halo_color
+    halo_color = unpack_mix_color(a_halo_color, a_halo_color_t);
+#else
+    highp vec4 halo_color = u_halo_color;
+#endif
+
+    
+#ifndef HAS_UNIFORM_u_opacity
+    opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
+#else
+    lowp float opacity = u_opacity;
+#endif
+
+    
+#ifndef HAS_UNIFORM_u_halo_width
+    halo_width = unpack_mix_vec2(a_halo_width, a_halo_width_t);
+#else
+    lowp float halo_width = u_halo_width;
+#endif
+
+    
+#ifndef HAS_UNIFORM_u_halo_blur
+    halo_blur = unpack_mix_vec2(a_halo_blur, a_halo_blur_t);
+#else
+    lowp float halo_blur = u_halo_blur;
+#endif
+
+
+    vec2 a_pos = a_pos_offset.xy;
+    vec2 a_offset = a_pos_offset.zw;
+
+    vec2 a_tex = a_data.xy;
+    vec2 a_size = a_data.zw;
+
+    highp float segment_angle = -a_projected_pos[2];
+    float size;
+
+    if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = mix(a_size[0], a_size[1], u_size_t) / 256.0;
+    } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = a_size[0] / 256.0;
+    } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {
+        size = u_size;
+    } else {
+        size = u_size;
+    }
+
+    vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);
+    highp float camera_to_anchor_distance = projectedPoint.w;
+    // If the label is pitched with the map, layout is done in pitched space,
+    // which makes labels in the distance smaller relative to viewport space.
+    // We counteract part of that effect by multiplying by the perspective ratio.
+    // If the label isn't pitched with the map, we do layout in viewport space,
+    // which makes labels in the distance larger relative to the features around
+    // them. We counteract part of that effect by dividing by the perspective ratio.
+    highp float distance_ratio = u_pitch_with_map ?
+        camera_to_anchor_distance / u_camera_to_center_distance :
+        u_camera_to_center_distance / camera_to_anchor_distance;
+    highp float perspective_ratio = clamp(
+        0.5 + 0.5 * distance_ratio,
+        0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles
+        4.0);
+
+    size *= perspective_ratio;
+
+    float fontScale = u_is_text ? size / 24.0 : size;
+
+    highp float symbol_rotation = 0.0;
+    if (u_rotate_symbol) {
+        // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units
+        // To figure out that angle in projected space, we draw a short horizontal line in tile
+        // space, project it, and measure its angle in projected space.
+        vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);
+
+        vec2 a = projectedPoint.xy / projectedPoint.w;
+        vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;
+
+        symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);
+    }
+
+    highp float angle_sin = sin(segment_angle + symbol_rotation);
+    highp float angle_cos = cos(segment_angle + symbol_rotation);
+    mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
+
+    vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
+    gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0);
+    float gamma_scale = gl_Position.w;
+
+    vec2 tex = a_tex / u_texsize;
+    vec2 fade_opacity = unpack_opacity(a_fade_opacity);
+    float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;
+    float interpolated_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));
+
+    v_data0 = vec2(tex.x, tex.y);
+    v_data1 = vec3(gamma_scale, size, interpolated_fade_opacity);
+}
+
+*/
+
+// Uncompressed source of symbol_sdf_text.fragment.glsl:
+/*
+#define SDF_PX 8.0
+#define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO
+
+uniform bool u_is_halo;
+
+#ifndef HAS_UNIFORM_u_fill_color
+varying highp vec4 fill_color;
+#else
+uniform highp vec4 u_fill_color;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_color
+varying highp vec4 halo_color;
+#else
+uniform highp vec4 u_halo_color;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_opacity
+varying lowp float opacity;
+#else
+uniform lowp float u_opacity;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_width
+varying lowp float halo_width;
+#else
+uniform lowp float u_halo_width;
+#endif
+
+
+#ifndef HAS_UNIFORM_u_halo_blur
+varying lowp float halo_blur;
+#else
+uniform lowp float u_halo_blur;
+#endif
+
+
+uniform sampler2D u_texture;
+uniform highp float u_gamma_scale;
+uniform bool u_is_text;
+
+varying vec2 v_data0;
+varying vec3 v_data1;
+
+void main() {
+    
+#ifdef HAS_UNIFORM_u_fill_color
+    highp vec4 fill_color = u_fill_color;
+#endif
+
+    
+#ifdef HAS_UNIFORM_u_halo_color
+    highp vec4 halo_color = u_halo_color;
+#endif
+
+    
+#ifdef HAS_UNIFORM_u_opacity
+    lowp float opacity = u_opacity;
+#endif
+
+    
+#ifdef HAS_UNIFORM_u_halo_width
+    lowp float halo_width = u_halo_width;
+#endif
+
+    
+#ifdef HAS_UNIFORM_u_halo_blur
+    lowp float halo_blur = u_halo_blur;
+#endif
+
+
+    vec2 tex = v_data0.xy;
+    float gamma_scale = v_data1.x;
+    float size = v_data1.y;
+    float fade_opacity = v_data1[2];
+
+    float fontScale = u_is_text ? size / 24.0 : size;
+
+    lowp vec4 color = fill_color;
+    highp float gamma = EDGE_GAMMA / (fontScale * u_gamma_scale);
+    lowp float buff = (256.0 - 64.0) / 256.0;
+    if (u_is_halo) {
+        color = halo_color;
+        gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (fontScale * u_gamma_scale);
+        buff = (6.0 - halo_width / fontScale) / SDF_PX;
+    }
+
+    lowp float dist = texture2D(u_texture, tex).a;
+    highp float gamma_scaled = gamma * gamma_scale;
+    highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist);
+
+    gl_FragColor = color * (alpha * opacity * fade_opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}
+
+*/
+
diff --git a/src/mbgl/programs/heatmap_program.cpp b/src/mbgl/programs/heatmap_program.cpp
index 67f84fbd52..32c30ea313 100644
--- a/src/mbgl/programs/heatmap_program.cpp
+++ b/src/mbgl/programs/heatmap_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/heatmap_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<HeatmapProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(HeatmapLayoutVertex) == 4, "expected HeatmapLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/heatmap_program.hpp b/src/mbgl/programs/heatmap_program.hpp
index a90e9d4053..9563dd8d1b 100644
--- a/src/mbgl/programs/heatmap_program.hpp
+++ b/src/mbgl/programs/heatmap_program.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/heatmap_texture_program.hpp>
 #include <mbgl/programs/uniforms.hpp>
-#include <mbgl/shaders/heatmap.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/style/layers/heatmap_layer_properties.hpp>
 
@@ -15,8 +14,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(float, u_intensity);
 } // namespace uniforms
 
 class HeatmapProgram : public Program<
-    shaders::heatmap,
-    gfx::Triangle,
+    HeatmapProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<
         attributes::a_pos>,
     TypeList<
@@ -46,11 +45,11 @@ public:
 };
 
 using HeatmapLayoutVertex = HeatmapProgram::LayoutVertex;
-using HeatmapAttributes = HeatmapProgram::Attributes;
+using HeatmapAttributes = HeatmapProgram::AttributeList;
 
 class HeatmapLayerPrograms final : public LayerTypePrograms  {
 public:
-    HeatmapLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) 
+    HeatmapLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) 
         : heatmap(context, programParameters),
           heatmapTexture(context, programParameters) {}
     ProgramMap<HeatmapProgram> heatmap;
diff --git a/src/mbgl/programs/heatmap_texture_program.cpp b/src/mbgl/programs/heatmap_texture_program.cpp
index 3b0e24eab8..04c5ff56a7 100644
--- a/src/mbgl/programs/heatmap_texture_program.cpp
+++ b/src/mbgl/programs/heatmap_texture_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/heatmap_texture_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<HeatmapTextureProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(HeatmapTextureLayoutVertex) == 4, "expected HeatmapTextureLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/heatmap_texture_program.hpp b/src/mbgl/programs/heatmap_texture_program.hpp
index a1d3835821..954e03f9b6 100644
--- a/src/mbgl/programs/heatmap_texture_program.hpp
+++ b/src/mbgl/programs/heatmap_texture_program.hpp
@@ -4,15 +4,14 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/heatmap_texture.hpp>
 #include <mbgl/style/properties.hpp>
 #include <mbgl/util/geometry.hpp>
 
 namespace mbgl {
 
 class HeatmapTextureProgram : public Program<
-    shaders::heatmap_texture,
-    gfx::Triangle,
+    HeatmapTextureProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<attributes::a_pos>,
     TypeList<
         uniforms::u_matrix,
@@ -36,6 +35,6 @@ public:
 };
 
 using HeatmapTextureLayoutVertex = HeatmapTextureProgram::LayoutVertex;
-using HeatmapTextureAttributes = HeatmapTextureProgram::Attributes;
+using HeatmapTextureAttributes = HeatmapTextureProgram::AttributeList;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/hillshade_prepare_program.cpp b/src/mbgl/programs/hillshade_prepare_program.cpp
index 0c0446d3f5..5bbac9eaec 100644
--- a/src/mbgl/programs/hillshade_prepare_program.cpp
+++ b/src/mbgl/programs/hillshade_prepare_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/hillshade_prepare_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<HillshadePrepareProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(HillshadePrepareLayoutVertex) == 8, "expected HillshadeLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/hillshade_prepare_program.hpp b/src/mbgl/programs/hillshade_prepare_program.hpp
index b58525bbfd..0243cc1879 100644
--- a/src/mbgl/programs/hillshade_prepare_program.hpp
+++ b/src/mbgl/programs/hillshade_prepare_program.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/hillshade_prepare.hpp>
 #include <mbgl/util/geometry.hpp>
 
 namespace mbgl {
@@ -15,8 +14,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(float, u_maxzoom);
 } // namespace uniforms
 
 class HillshadePrepareProgram : public Program<
-    shaders::hillshade_prepare,
-    gfx::Triangle,
+    HillshadePrepareProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<
         attributes::a_pos,
         attributes::a_texture_pos>,
@@ -46,6 +45,6 @@ public:
 };
 
 using HillshadePrepareLayoutVertex = HillshadePrepareProgram::LayoutVertex;
-using HillshadePrepareAttributes = HillshadePrepareProgram::Attributes;
+using HillshadePrepareAttributes = HillshadePrepareProgram::AttributeList;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/hillshade_program.cpp b/src/mbgl/programs/hillshade_program.cpp
index f054ad4b74..31673afcd4 100644
--- a/src/mbgl/programs/hillshade_program.cpp
+++ b/src/mbgl/programs/hillshade_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/hillshade_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<HillshadeProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(HillshadeLayoutVertex) == 8, "expected HillshadeLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/hillshade_program.hpp b/src/mbgl/programs/hillshade_program.hpp
index 2a67338c7c..68d67917df 100644
--- a/src/mbgl/programs/hillshade_program.hpp
+++ b/src/mbgl/programs/hillshade_program.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/programs/hillshade_prepare_program.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/hillshade.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/style/layers/hillshade_layer_properties.hpp>
 
@@ -20,8 +19,8 @@ MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_latrange);
 } // namespace uniforms
 
 class HillshadeProgram : public Program<
-    shaders::hillshade,
-    gfx::Triangle,
+    HillshadeProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<
         attributes::a_pos,
         attributes::a_texture_pos>,
@@ -53,11 +52,11 @@ public:
 };
 
 using HillshadeLayoutVertex = HillshadeProgram::LayoutVertex;
-using HillshadeAttributes = HillshadeProgram::Attributes;
+using HillshadeAttributes = HillshadeProgram::AttributeList;
 
 class HillshadeLayerPrograms final : public LayerTypePrograms  {
 public:
-    HillshadeLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    HillshadeLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : hillshade(context, programParameters),
           hillshadePrepare(context, programParameters) {}
     HillshadeProgram hillshade;
diff --git a/src/mbgl/programs/line_gradient_program.hpp b/src/mbgl/programs/line_gradient_program.hpp
new file mode 100644
index 0000000000..c98cd37e98
--- /dev/null
+++ b/src/mbgl/programs/line_gradient_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/line_program.hpp>
diff --git a/src/mbgl/programs/line_pattern_program.hpp b/src/mbgl/programs/line_pattern_program.hpp
new file mode 100644
index 0000000000..c98cd37e98
--- /dev/null
+++ b/src/mbgl/programs/line_pattern_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/line_program.hpp>
diff --git a/src/mbgl/programs/line_program.cpp b/src/mbgl/programs/line_program.cpp
index e5b4cc2ad5..74a1ba3162 100644
--- a/src/mbgl/programs/line_program.cpp
+++ b/src/mbgl/programs/line_program.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/programs/line_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 #include <mbgl/style/layers/line_layer_properties.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/image_atlas.hpp>
@@ -8,6 +9,11 @@
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<LineProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<LinePatternProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<LineGradientProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<LineSDFProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 using namespace style;
 
 static_assert(sizeof(LineLayoutVertex) == 12, "expected LineLayoutVertex size");
@@ -31,12 +37,12 @@ Values makeValues(const RenderLinePaintProperties::PossiblyEvaluated& properties
     };
 }
 
-LineProgram::UniformValues
-LineProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
-                           const RenderTile& tile,
-                           const TransformState& state,
-                           const std::array<float, 2>& pixelsToGLUnits) {
-    return makeValues<LineProgram::UniformValues>(
+LineProgram::LayoutUniformValues
+LineProgram::layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
+                                 const RenderTile& tile,
+                                 const TransformState& state,
+                                 const std::array<float, 2>& pixelsToGLUnits) {
+    return makeValues<LineProgram::LayoutUniformValues>(
         properties,
         tile,
         state,
@@ -44,16 +50,16 @@ LineProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& p
     );
 }
 
-LineSDFProgram::UniformValues
-LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
-                              float pixelRatio,
-                              const RenderTile& tile,
-                              const TransformState& state,
-                              const std::array<float, 2>& pixelsToGLUnits,
-                              const LinePatternPos& posA,
-                              const LinePatternPos& posB,
-                              const CrossfadeParameters& crossfade,
-                              float atlasWidth) {
+LineSDFProgram::LayoutUniformValues
+LineSDFProgram::layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
+                                    float pixelRatio,
+                                    const RenderTile& tile,
+                                    const TransformState& state,
+                                    const std::array<float, 2>& pixelsToGLUnits,
+                                    const LinePatternPos& posA,
+                                    const LinePatternPos& posB,
+                                    const CrossfadeParameters& crossfade,
+                                    float atlasWidth) {
     const float widthA = posA.width * crossfade.fromScale;
     const float widthB = posB.width * crossfade.toScale;
 
@@ -67,7 +73,7 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated
         -posB.height / 2.0f
     }};
 
-    return makeValues<LineSDFProgram::UniformValues>(
+    return makeValues<LineSDFProgram::LayoutUniformValues>(
         properties,
         tile,
         state,
@@ -81,18 +87,18 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated
     );
 }
 
-LinePatternProgram::UniformValues
-LinePatternProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
-                                  const RenderTile& tile,
-                                  const TransformState& state,
-                                  const std::array<float, 2>& pixelsToGLUnits,
-                                  const Size atlasSize,
-                                  const CrossfadeParameters& crossfade,
-                                  const float pixelRatio) {
-    
+LinePatternProgram::LayoutUniformValues LinePatternProgram::layoutUniformValues(
+    const RenderLinePaintProperties::PossiblyEvaluated& properties,
+    const RenderTile& tile,
+    const TransformState& state,
+    const std::array<float, 2>& pixelsToGLUnits,
+    const Size atlasSize,
+    const CrossfadeParameters& crossfade,
+    const float pixelRatio) {
+
     const auto tileRatio = 1 / tile.id.pixelsToTileUnits(1, state.getIntegerZoom());
 
-    return makeValues<LinePatternProgram::UniformValues>(
+    return makeValues<LinePatternProgram::LayoutUniformValues>(
         properties,
         tile,
         state,
@@ -103,12 +109,12 @@ LinePatternProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvalu
     );
 }
 
-LineGradientProgram::UniformValues
-LineGradientProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties,
-                           const RenderTile& tile,
-                           const TransformState& state,
-                           const std::array<float, 2>& pixelsToGLUnits) {
-    return makeValues<LineGradientProgram::UniformValues>(
+LineGradientProgram::LayoutUniformValues LineGradientProgram::layoutUniformValues(
+    const RenderLinePaintProperties::PossiblyEvaluated& properties,
+    const RenderTile& tile,
+    const TransformState& state,
+    const std::array<float, 2>& pixelsToGLUnits) {
+    return makeValues<LineGradientProgram::LayoutUniformValues>(
         properties,
         tile,
         state,
diff --git a/src/mbgl/programs/line_program.hpp b/src/mbgl/programs/line_program.hpp
index 0e4055bded..05546e3cbe 100644
--- a/src/mbgl/programs/line_program.hpp
+++ b/src/mbgl/programs/line_program.hpp
@@ -4,10 +4,6 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/line.hpp>
-#include <mbgl/shaders/line_gradient.hpp>
-#include <mbgl/shaders/line_pattern.hpp>
-#include <mbgl/shaders/line_sdf.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/renderer/layers/render_line_layer.hpp>
 #include <mbgl/renderer/cross_faded_property_evaluator.hpp>
@@ -35,8 +31,8 @@ using LineLayoutAttributes = TypeList<
     attributes::a_data<uint8_t, 4>>;
 
 class LineProgram : public Program<
-    shaders::line,
-    gfx::Triangle,
+    LineProgram,
+    gfx::PrimitiveType::Triangle,
     LineLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -93,15 +89,16 @@ public:
      */
     static const int8_t extrudeScale = 63;
 
-    static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const std::array<float, 2>& pixelsToGLUnits);
+    static LayoutUniformValues
+    layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
+                        const RenderTile&,
+                        const TransformState&,
+                        const std::array<float, 2>& pixelsToGLUnits);
 };
 
 class LinePatternProgram : public Program<
-    shaders::line_pattern,
-    gfx::Triangle,
+    LinePatternProgram,
+    gfx::PrimitiveType::Triangle,
     LineLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -117,18 +114,19 @@ class LinePatternProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const std::array<float, 2>& pixelsToGLUnits,
-                                       Size atlasSize,
-                                       const CrossfadeParameters& crossfade,
-                                       const float pixelRatio);
+    static LayoutUniformValues
+    layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
+                        const RenderTile&,
+                        const TransformState&,
+                        const std::array<float, 2>& pixelsToGLUnits,
+                        Size atlasSize,
+                        const CrossfadeParameters& crossfade,
+                        const float pixelRatio);
 };
 
 class LineSDFProgram : public Program<
-    shaders::line_sdf,
-    gfx::Triangle,
+    LineSDFProgram,
+    gfx::PrimitiveType::Triangle,
     LineLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -147,20 +145,21 @@ class LineSDFProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
-                                       float pixelRatio,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const std::array<float, 2>& pixelsToGLUnits,
-                                       const LinePatternPos& posA,
-                                       const LinePatternPos& posB,
-                                       const CrossfadeParameters& crossfade,
-                                       float atlasWidth);
+    static LayoutUniformValues
+    layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
+                        float pixelRatio,
+                        const RenderTile&,
+                        const TransformState&,
+                        const std::array<float, 2>& pixelsToGLUnits,
+                        const LinePatternPos& posA,
+                        const LinePatternPos& posB,
+                        const CrossfadeParameters& crossfade,
+                        float atlasWidth);
 };
 
 class LineGradientProgram : public Program<
-    shaders::line_gradient,
-    gfx::Triangle,
+    LineGradientProgram,
+    gfx::PrimitiveType::Triangle,
     LineLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -173,18 +172,19 @@ class LineGradientProgram : public Program<
 public:
     using Program::Program;
 
-    static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const std::array<float, 2>& pixelsToGLUnits);
+    static LayoutUniformValues
+    layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&,
+                        const RenderTile&,
+                        const TransformState&,
+                        const std::array<float, 2>& pixelsToGLUnits);
 };
 
 using LineLayoutVertex = LineProgram::LayoutVertex;
-using LineAttributes = LineProgram::Attributes;
+using LineAttributes = LineProgram::AttributeList;
 
 class LineLayerPrograms final : public LayerTypePrograms {
 public:
-    LineLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    LineLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : line(context, programParameters),
           lineGradient(context, programParameters),
           lineSDF(context, programParameters),
diff --git a/src/mbgl/programs/line_sdf_program.hpp b/src/mbgl/programs/line_sdf_program.hpp
new file mode 100644
index 0000000000..c98cd37e98
--- /dev/null
+++ b/src/mbgl/programs/line_sdf_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/line_program.hpp>
diff --git a/src/mbgl/programs/program.hpp b/src/mbgl/programs/program.hpp
index 379cc6b842..240da22b4f 100644
--- a/src/mbgl/programs/program.hpp
+++ b/src/mbgl/programs/program.hpp
@@ -1,106 +1,106 @@
 #pragma once
 
-#include <mbgl/gl/program.hpp>
-#include <mbgl/gl/features.hpp>
+#include <mbgl/gfx/attribute.hpp>
+#include <mbgl/gfx/uniform.hpp>
 #include <mbgl/programs/segment.hpp>
-#include <mbgl/programs/binary_program.hpp>
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/program_parameters.hpp>
 #include <mbgl/style/paint_property.hpp>
 #include <mbgl/renderer/paint_property_binder.hpp>
-#include <mbgl/shaders/shaders.hpp>
 #include <mbgl/util/io.hpp>
 
 #include <unordered_map>
 
 namespace mbgl {
 
-template <class Shaders,
-          class Primitive,
+template <class Name,
+          gfx::PrimitiveType Primitive,
           class LayoutAttributeList,
-          class UniformList,
-          class TextureList,
+          class LayoutUniformList,
+          class Textures,
           class PaintProps>
 class Program {
 public:
-    using LayoutAttributes = gl::Attributes<LayoutAttributeList>;
     using LayoutVertex = gfx::Vertex<LayoutAttributeList>;
 
     using PaintProperties = PaintProps;
     using Binders = PaintPropertyBinders<typename PaintProperties::DataDrivenProperties>;
+
     using PaintAttributeList = typename Binders::AttributeList;
-    using Attributes = gl::Attributes<TypeListConcat<LayoutAttributeList, PaintAttributeList>>;
+    using AttributeList = TypeListConcat<LayoutAttributeList, PaintAttributeList>;
+    using AttributeBindings = gfx::AttributeBindings<AttributeList>;
 
-    using UniformValues = gfx::UniformValues<UniformList>;
     using PaintUniformList = typename Binders::UniformList;
-    using AllUniforms = gl::Uniforms<TypeListConcat<UniformList, PaintUniformList>>;
+    using UniformList = TypeListConcat<LayoutUniformList, PaintUniformList>;
+    using LayoutUniformValues = gfx::UniformValues<LayoutUniformList>;
+    using UniformValues = gfx::UniformValues<UniformList>;
 
+    using TextureList = Textures;
     using TextureBindings = gfx::TextureBindings<TextureList>;
 
-    using ProgramType = gl::Program<Primitive, Attributes, AllUniforms, TextureList>;
-
-    ProgramType program;
+    std::unique_ptr<gfx::Program<Name>> program;
 
-    Program(gl::Context& context, const ProgramParameters& programParameters)
-        : program(ProgramType::createProgram(
-            context,
-            programParameters,
-            Shaders::name,
-            Shaders::vertexSource,
-            Shaders::fragmentSource)) {
+    Program(gfx::Context& context, const ProgramParameters& programParameters)
+        : program(context.createProgram<Name>(programParameters)) {
     }
 
-    static typename AllUniforms::Values computeAllUniformValues(
-        const UniformValues& uniformValues,
+    static UniformValues computeAllUniformValues(
+        const LayoutUniformValues& layoutUniformValues,
         const Binders& paintPropertyBinders,
         const typename PaintProperties::PossiblyEvaluated& currentProperties,
         float currentZoom) {
-        return uniformValues
+        return layoutUniformValues
             .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
     }
 
-    static typename Attributes::Bindings computeAllAttributeBindings(
+    static AttributeBindings computeAllAttributeBindings(
         const gfx::VertexBuffer<LayoutVertex>& layoutVertexBuffer,
         const Binders& paintPropertyBinders,
         const typename PaintProperties::PossiblyEvaluated& currentProperties) {
-        return LayoutAttributes::bindings(layoutVertexBuffer)
+        return gfx::AttributeBindings<LayoutAttributeList>(layoutVertexBuffer)
             .concat(paintPropertyBinders.attributeBindings(currentProperties));
     }
 
-    static uint32_t activeBindingCount(const typename Attributes::Bindings& allAttributeBindings) {
-        return Attributes::activeBindingCount(allAttributeBindings);
+    static uint32_t activeBindingCount(const AttributeBindings& allAttributeBindings) {
+        return allAttributeBindings.activeCount();
     }
 
     template <class DrawMode>
-    void draw(gl::Context& context,
-              DrawMode drawMode,
-              gfx::DepthMode depthMode,
-              gfx::StencilMode stencilMode,
-              gfx::ColorMode colorMode,
-              gfx::CullFaceMode cullFaceMode,
+    void draw(gfx::Context& context,
+              const DrawMode& drawMode,
+              const gfx::DepthMode& depthMode,
+              const gfx::StencilMode& stencilMode,
+              const gfx::ColorMode& colorMode,
+              const gfx::CullFaceMode& cullFaceMode,
               const gfx::IndexBuffer& indexBuffer,
-              const SegmentVector<Attributes>& segments,
-              const typename AllUniforms::Values& allUniformValues,
-              const typename Attributes::Bindings& allAttributeBindings,
+              const SegmentVector<AttributeList>& segments,
+              const UniformValues& uniformValues,
+              const AttributeBindings& allAttributeBindings,
               const TextureBindings& textureBindings,
               const std::string& layerID) {
+        static_assert(Primitive == gfx::PrimitiveTypeOf<DrawMode>::value, "incompatible draw mode");
+
+        if (!program) {
+            return;
+        }
+
         for (auto& segment : segments) {
-            auto vertexArrayIt = segment.vertexArrays.find(layerID);
+            auto drawScopeIt = segment.drawScopes.find(layerID);
 
-            if (vertexArrayIt == segment.vertexArrays.end()) {
-                vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
+            if (drawScopeIt == segment.drawScopes.end()) {
+                drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first;
             }
 
-            program.draw(
+            program->draw(
                 context,
-                std::move(drawMode),
-                std::move(depthMode),
-                std::move(stencilMode),
-                std::move(colorMode),
-                std::move(cullFaceMode),
-                allUniformValues,
-                vertexArrayIt->second,
-                Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
+                drawMode,
+                depthMode,
+                stencilMode,
+                colorMode,
+                cullFaceMode,
+                uniformValues,
+                drawScopeIt->second,
+                allAttributeBindings.offset(segment.vertexOffset),
                 textureBindings,
                 indexBuffer,
                 segment.indexOffset,
@@ -116,7 +116,7 @@ public:
     using Binders = typename Program::Binders;
     using Bitset = typename Binders::Bitset;
 
-    ProgramMap(gl::Context& context_, ProgramParameters parameters_)
+    ProgramMap(gfx::Context& context_, ProgramParameters parameters_)
         : context(context_),
           parameters(std::move(parameters_)) {
     }
@@ -134,7 +134,7 @@ public:
     }
 
 private:
-    gl::Context& context;
+    gfx::Context& context;
     ProgramParameters parameters;
     std::unordered_map<Bitset, Program> programs;
 };
diff --git a/src/mbgl/programs/programs.cpp b/src/mbgl/programs/programs.cpp
index f3b3af8ac9..f82e46c9a2 100644
--- a/src/mbgl/programs/programs.cpp
+++ b/src/mbgl/programs/programs.cpp
@@ -12,7 +12,7 @@
 
 namespace mbgl {
 
-Programs::Programs(gl::Context& context_, const ProgramParameters& programParameters_)
+Programs::Programs(gfx::Context& context_, const ProgramParameters& programParameters_)
     : debug(context_, programParameters_),
       clippingMask(context_, programParameters_),
       context(context_),
diff --git a/src/mbgl/programs/programs.hpp b/src/mbgl/programs/programs.hpp
index a12a0e8fa6..ca9359b267 100644
--- a/src/mbgl/programs/programs.hpp
+++ b/src/mbgl/programs/programs.hpp
@@ -20,7 +20,7 @@ class SymbolLayerPrograms;
 
 class Programs {
 public:
-    Programs(gl::Context&, const ProgramParameters&);
+    Programs(gfx::Context&, const ProgramParameters&);
     ~Programs();
 
     BackgroundLayerPrograms& getBackgroundLayerPrograms() noexcept;
@@ -47,7 +47,7 @@ private:
     std::unique_ptr<LayerTypePrograms> linePrograms;
     std::unique_ptr<LayerTypePrograms> symbolPrograms;
 
-    gl::Context& context;
+    gfx::Context& context;
     ProgramParameters programParameters;
 };
 
diff --git a/src/mbgl/programs/raster_program.cpp b/src/mbgl/programs/raster_program.cpp
index 6906903e6b..f3b1052284 100644
--- a/src/mbgl/programs/raster_program.cpp
+++ b/src/mbgl/programs/raster_program.cpp
@@ -1,7 +1,10 @@
 #include <mbgl/programs/raster_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<RasterProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 static_assert(sizeof(RasterLayoutVertex) == 8, "expected RasterLayoutVertex size");
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/raster_program.hpp b/src/mbgl/programs/raster_program.hpp
index a5b4ee36ba..55f1fb0a2e 100644
--- a/src/mbgl/programs/raster_program.hpp
+++ b/src/mbgl/programs/raster_program.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/programs/attributes.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
-#include <mbgl/shaders/raster.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/style/layers/raster_layer_properties.hpp>
 
@@ -23,8 +22,8 @@ MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_tl_parent);
 } // namespace uniforms
 
 class RasterProgram : public Program<
-    shaders::raster,
-    gfx::Triangle,
+    RasterProgram,
+    gfx::PrimitiveType::Triangle,
     TypeList<
         attributes::a_pos,
         attributes::a_texture_pos>,
@@ -63,11 +62,11 @@ public:
 };
 
 using RasterLayoutVertex = RasterProgram::LayoutVertex;
-using RasterAttributes = RasterProgram::Attributes;
+using RasterAttributes = RasterProgram::AttributeList;
 
 class RasterLayerPrograms final : public LayerTypePrograms {
 public:
-    RasterLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    RasterLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : raster(context, programParameters) {}
     RasterProgram raster;
 };
diff --git a/src/mbgl/programs/segment.hpp b/src/mbgl/programs/segment.hpp
index 5158ce7dbf..5976550d2c 100644
--- a/src/mbgl/programs/segment.hpp
+++ b/src/mbgl/programs/segment.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mbgl/gl/vertex_array.hpp>
+#include <mbgl/gfx/draw_scope.hpp>
 
 #include <cstddef>
 #include <vector>
@@ -8,7 +8,7 @@
 
 namespace mbgl {
 
-template <class Attributes>
+template <class AttributeList>
 class Segment {
 public:
     Segment(std::size_t vertexOffset_,
@@ -28,17 +28,17 @@ public:
     std::size_t vertexLength;
     std::size_t indexLength;
 
-    // One VertexArray per layer ID. This minimizes rebinding in cases where
+    // One DrawScope per layer ID. This minimizes rebinding in cases where
     // several layers share buckets but have different sets of active attributes.
     // This can happen:
     //   * when two layers have the same layout properties, but differing
     //     data-driven paint properties
     //   * when two fill layers have the same layout properties, but one
     //     uses fill-color and the other uses fill-pattern
-    mutable std::map<std::string, gl::VertexArray> vertexArrays;
+    mutable std::map<std::string, gfx::DrawScope> drawScopes;
 };
 
-template <class Attributes>
-using SegmentVector = std::vector<Segment<Attributes>>;
+template <class AttributeList>
+using SegmentVector = std::vector<Segment<AttributeList>>;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/symbol_icon_program.hpp b/src/mbgl/programs/symbol_icon_program.hpp
new file mode 100644
index 0000000000..57f27518d1
--- /dev/null
+++ b/src/mbgl/programs/symbol_icon_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/symbol_program.hpp>
diff --git a/src/mbgl/programs/symbol_program.cpp b/src/mbgl/programs/symbol_program.cpp
index 03643d6422..2300dedff3 100644
--- a/src/mbgl/programs/symbol_program.cpp
+++ b/src/mbgl/programs/symbol_program.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/programs/symbol_program.hpp>
+#include <mbgl/gfx/context_impl.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
@@ -9,6 +10,10 @@
 
 namespace mbgl {
 
+template std::unique_ptr<gfx::Program<SymbolIconProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<SymbolSDFTextProgram>> gfx::Context::createProgram(const ProgramParameters&);
+template std::unique_ptr<gfx::Program<SymbolSDFIconProgram>> gfx::Context::createProgram(const ProgramParameters&);
+
 using namespace style;
 
 static_assert(sizeof(SymbolLayoutVertex) == 16, "expected SymbolLayoutVertex size");
@@ -99,17 +104,16 @@ Values makeValues(const bool isText,
     };
 }
 
-SymbolIconProgram::UniformValues
-SymbolIconProgram::uniformValues(const bool isText,
-                                 const style::SymbolPropertyValues& values,
-                                 const Size& texsize,
-                                 const std::array<float, 2>& pixelsToGLUnits,
-                                 const bool alongLine,
-                                 const RenderTile& tile,
-                                 const TransformState& state,
-                                 const float symbolFadeChange)
-{
-    return makeValues<SymbolIconProgram::UniformValues>(
+SymbolIconProgram::LayoutUniformValues
+SymbolIconProgram::layoutUniformValues(const bool isText,
+                                       const style::SymbolPropertyValues& values,
+                                       const Size& texsize,
+                                       const std::array<float, 2>& pixelsToGLUnits,
+                                       const bool alongLine,
+                                       const RenderTile& tile,
+                                       const TransformState& state,
+                                       const float symbolFadeChange) {
+    return makeValues<SymbolIconProgram::LayoutUniformValues>(
         isText,
         values,
         texsize,
@@ -121,23 +125,22 @@ SymbolIconProgram::uniformValues(const bool isText,
     );
 }
 
-template <class PaintProperties>
-typename SymbolSDFProgram<PaintProperties>::UniformValues SymbolSDFProgram<PaintProperties>::uniformValues(
-      const bool isText,
-      const style::SymbolPropertyValues& values,
-      const Size& texsize,
-      const std::array<float, 2>& pixelsToGLUnits,
-      const bool alongLine,
-      const RenderTile& tile,
-      const TransformState& state,
-      const float symbolFadeChange,
-      const SymbolSDFPart part)
-{
+template <class Name, class PaintProperties>
+typename SymbolSDFProgram<Name, PaintProperties>::LayoutUniformValues
+SymbolSDFProgram<Name, PaintProperties>::layoutUniformValues(const bool isText,
+                                                       const style::SymbolPropertyValues& values,
+                                                       const Size& texsize,
+                                                       const std::array<float, 2>& pixelsToGLUnits,
+                                                       const bool alongLine,
+                                                       const RenderTile& tile,
+                                                       const TransformState& state,
+                                                       const float symbolFadeChange,
+                                                       const SymbolSDFPart part) {
     const float gammaScale = (values.pitchAlignment == AlignmentType::Map
                               ? std::cos(state.getPitch()) * state.getCameraToCenterDistance()
                               : 1.0);
 
-    return makeValues<SymbolSDFProgram<PaintProperties>::UniformValues>(
+    return makeValues<SymbolSDFProgram<Name, PaintProperties>::LayoutUniformValues>(
         isText,
         values,
         texsize,
@@ -151,7 +154,7 @@ typename SymbolSDFProgram<PaintProperties>::UniformValues SymbolSDFProgram<Paint
     );
 }
 
-template class SymbolSDFProgram<style::IconPaintProperties>;
-template class SymbolSDFProgram<style::TextPaintProperties>;
+template class SymbolSDFProgram<SymbolSDFIconProgram, style::IconPaintProperties>;
+template class SymbolSDFProgram<SymbolSDFTextProgram, style::TextPaintProperties>;
 
 } // namespace mbgl
diff --git a/src/mbgl/programs/symbol_program.hpp b/src/mbgl/programs/symbol_program.hpp
index 7b8a2c1330..383f5162d8 100644
--- a/src/mbgl/programs/symbol_program.hpp
+++ b/src/mbgl/programs/symbol_program.hpp
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <mbgl/gl/context.hpp>
 #include <mbgl/gl/program.hpp>
 #include <mbgl/math/clamp.hpp>
 #include <mbgl/util/interpolate.hpp>
@@ -10,8 +9,6 @@
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/programs/textures.hpp>
 #include <mbgl/programs/segment.hpp>
-#include <mbgl/shaders/symbol_icon.hpp>
-#include <mbgl/shaders/symbol_sdf.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/util/size.hpp>
 #include <mbgl/style/layers/symbol_layer_properties.hpp>
@@ -240,55 +237,51 @@ public:
     }
 };
 
-template <class Shaders,
-          class Primitive,
+template <class Name,
+          gfx::PrimitiveType Primitive,
           class LayoutAttributeList,
-          class UniformList,
-          class TextureList,
+          class LayoutUniformList,
+          class Textures,
           class PaintProps>
 class SymbolProgram : public SymbolProgramBase {
 public:
-    using LayoutAttributes = gl::Attributes<LayoutAttributeList>;
     using LayoutVertex = gfx::Vertex<LayoutAttributeList>;
 
     using LayoutAndSizeAttributeList = TypeListConcat<LayoutAttributeList, SymbolDynamicLayoutAttributes, SymbolOpacityAttributes>;
 
     using PaintProperties = PaintProps;
     using Binders = PaintPropertyBinders<typename PaintProperties::DataDrivenProperties>;
+
     using PaintAttributeList = typename Binders::AttributeList;
-    using Attributes = gl::Attributes<TypeListConcat<LayoutAndSizeAttributeList, PaintAttributeList>>;
+    using AttributeList = TypeListConcat<LayoutAndSizeAttributeList, PaintAttributeList>;
+    using AttributeBindings = gfx::AttributeBindings<AttributeList>;
 
-    using UniformValues = gfx::UniformValues<UniformList>;
+    using LayoutUniformValues = gfx::UniformValues<LayoutUniformList>;
     using SizeUniformList = typename SymbolSizeBinder::UniformList;
     using PaintUniformList = typename Binders::UniformList;
-    using AllUniforms = gl::Uniforms<TypeListConcat<UniformList, SizeUniformList, PaintUniformList>>;
+    using UniformList = TypeListConcat<LayoutUniformList, SizeUniformList, PaintUniformList>;
+    using UniformValues = gfx::UniformValues<UniformList>;
 
+    using TextureList = Textures;
     using TextureBindings = gfx::TextureBindings<TextureList>;
 
-    using ProgramType = gl::Program<Primitive, Attributes, AllUniforms, TextureList>;
+    std::unique_ptr<gfx::Program<Name>> program;
 
-    ProgramType program;
-
-    SymbolProgram(gl::Context& context, const ProgramParameters& programParameters)
-        : program(ProgramType::createProgram(
-            context,
-            programParameters,
-            Shaders::name,
-            Shaders::vertexSource,
-            Shaders::fragmentSource)) {
+    SymbolProgram(gfx::Context& context, const ProgramParameters& programParameters)
+        : program(context.createProgram<Name>(programParameters)) {
     }
 
-    static typename AllUniforms::Values computeAllUniformValues(
-        const UniformValues& uniformValues,
+    static UniformValues computeAllUniformValues(
+        const LayoutUniformValues& layoutUniformValues,
         const SymbolSizeBinder& symbolSizeBinder,
         const Binders& paintPropertyBinders,
         const typename PaintProperties::PossiblyEvaluated& currentProperties,
         float currentZoom) {
-        return uniformValues.concat(symbolSizeBinder.uniformValues(currentZoom))
+        return layoutUniformValues.concat(symbolSizeBinder.uniformValues(currentZoom))
             .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties));
     }
 
-    static typename Attributes::Bindings computeAllAttributeBindings(
+    static AttributeBindings computeAllAttributeBindings(
         const gfx::VertexBuffer<LayoutVertex>& layoutVertexBuffer,
         const gfx::VertexBuffer<gfx::Vertex<SymbolDynamicLayoutAttributes>>& dynamicLayoutVertexBuffer,
         const gfx::VertexBuffer<gfx::Vertex<SymbolOpacityAttributes>>& opacityVertexBuffer,
@@ -296,46 +289,52 @@ public:
         const typename PaintProperties::PossiblyEvaluated& currentProperties) {
         assert(layoutVertexBuffer.elements == dynamicLayoutVertexBuffer.elements &&
                layoutVertexBuffer.elements == opacityVertexBuffer.elements);
-        return gl::Attributes<LayoutAttributeList>::bindings(layoutVertexBuffer)
-            .concat(gl::Attributes<SymbolDynamicLayoutAttributes>::bindings(dynamicLayoutVertexBuffer))
-            .concat(gl::Attributes<SymbolOpacityAttributes>::bindings(opacityVertexBuffer))
+        return gfx::AttributeBindings<LayoutAttributeList>(layoutVertexBuffer)
+            .concat(gfx::AttributeBindings<SymbolDynamicLayoutAttributes>(dynamicLayoutVertexBuffer))
+            .concat(gfx::AttributeBindings<SymbolOpacityAttributes>(opacityVertexBuffer))
             .concat(paintPropertyBinders.attributeBindings(currentProperties));
     }
 
-    static uint32_t activeBindingCount(const typename Attributes::Bindings& allAttributeBindings) {
-        return Attributes::activeBindingCount(allAttributeBindings);
+    static uint32_t activeBindingCount(const AttributeBindings& allAttributeBindings) {
+        return allAttributeBindings.activeCount();
     }
 
     template <class DrawMode>
-    void draw(gl::Context& context,
-              DrawMode drawMode,
-              gfx::DepthMode depthMode,
-              gfx::StencilMode stencilMode,
-              gfx::ColorMode colorMode,
-              gfx::CullFaceMode cullFaceMode,
+    void draw(gfx::Context& context,
+              const DrawMode& drawMode,
+              const gfx::DepthMode& depthMode,
+              const gfx::StencilMode& stencilMode,
+              const gfx::ColorMode& colorMode,
+              const gfx::CullFaceMode& cullFaceMode,
               const gfx::IndexBuffer& indexBuffer,
-              const SegmentVector<Attributes>& segments,
-              const typename AllUniforms::Values& allUniformValues,
-              const typename Attributes::Bindings& allAttributeBindings,
+              const SegmentVector<AttributeList>& segments,
+              const UniformValues& uniformValues,
+              const AttributeBindings& allAttributeBindings,
               const TextureBindings& textureBindings,
               const std::string& layerID) {
+        static_assert(Primitive == gfx::PrimitiveTypeOf<DrawMode>::value, "incompatible draw mode");
+
+        if (!program) {
+            return;
+        }
+
         for (auto& segment : segments) {
-            auto vertexArrayIt = segment.vertexArrays.find(layerID);
+            auto drawScopeIt = segment.drawScopes.find(layerID);
 
-            if (vertexArrayIt == segment.vertexArrays.end()) {
-                vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first;
+            if (drawScopeIt == segment.drawScopes.end()) {
+                drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first;
             }
 
-            program.draw(
+            program->draw(
                 context,
-                std::move(drawMode),
-                std::move(depthMode),
-                std::move(stencilMode),
-                std::move(colorMode),
-                std::move(cullFaceMode),
-                allUniformValues,
-                vertexArrayIt->second,
-                Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset),
+                drawMode,
+                depthMode,
+                stencilMode,
+                colorMode,
+                cullFaceMode,
+                uniformValues,
+                drawScopeIt->second,
+                allAttributeBindings.offset(segment.vertexOffset),
                 textureBindings,
                 indexBuffer,
                 segment.indexOffset,
@@ -345,8 +344,8 @@ public:
 };
 
 class SymbolIconProgram : public SymbolProgram<
-    shaders::symbol_icon,
-    gfx::Triangle,
+    SymbolIconProgram,
+    gfx::PrimitiveType::Triangle,
     SymbolLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -368,14 +367,14 @@ class SymbolIconProgram : public SymbolProgram<
 public:
     using SymbolProgram::SymbolProgram;
 
-    static UniformValues uniformValues(const bool isText,
-                                       const style::SymbolPropertyValues&,
-                                       const Size& texsize,
-                                       const std::array<float, 2>& pixelsToGLUnits,
-                                       const bool alongLine,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const float symbolFadeChange);
+    static LayoutUniformValues layoutUniformValues(const bool isText,
+                                                   const style::SymbolPropertyValues&,
+                                                   const Size& texsize,
+                                                   const std::array<float, 2>& pixelsToGLUnits,
+                                                   const bool alongLine,
+                                                   const RenderTile&,
+                                                   const TransformState&,
+                                                   const float symbolFadeChange);
 };
 
 enum class SymbolSDFPart {
@@ -383,10 +382,10 @@ enum class SymbolSDFPart {
     Halo = 0
 };
 
-template <class PaintProperties>
+template <class Name, class PaintProperties>
 class SymbolSDFProgram : public SymbolProgram<
-    shaders::symbol_sdf,
-    gfx::Triangle,
+    Name,
+    gfx::PrimitiveType::Triangle,
     SymbolLayoutAttributes,
     TypeList<
         uniforms::u_matrix,
@@ -408,8 +407,9 @@ class SymbolSDFProgram : public SymbolProgram<
     PaintProperties>
 {
 public:
-    using BaseProgram = SymbolProgram<shaders::symbol_sdf,
-        gfx::Triangle,
+    using BaseProgram = SymbolProgram<
+        Name,
+        gfx::PrimitiveType::Triangle,
         SymbolLayoutAttributes,
         TypeList<
             uniforms::u_matrix,
@@ -430,33 +430,40 @@ public:
             textures::u_texture>,
         PaintProperties>;
 
-    using UniformValues = typename BaseProgram::UniformValues;
+    using LayoutUniformValues = typename BaseProgram::LayoutUniformValues;
 
 
 
     using BaseProgram::BaseProgram;
 
-    static UniformValues uniformValues(const bool isText,
-                                       const style::SymbolPropertyValues&,
-                                       const Size& texsize,
-                                       const std::array<float, 2>& pixelsToGLUnits,
-                                       const bool alongLine,
-                                       const RenderTile&,
-                                       const TransformState&,
-                                       const float SymbolFadeChange,
-                                       const SymbolSDFPart);
+    static LayoutUniformValues layoutUniformValues(const bool isText,
+                                                   const style::SymbolPropertyValues&,
+                                                   const Size& texsize,
+                                                   const std::array<float, 2>& pixelsToGLUnits,
+                                                   const bool alongLine,
+                                                   const RenderTile&,
+                                                   const TransformState&,
+                                                   const float SymbolFadeChange,
+                                                   const SymbolSDFPart);
+};
+
+class SymbolSDFIconProgram : public SymbolSDFProgram<SymbolSDFIconProgram, style::IconPaintProperties> {
+public:
+    using SymbolSDFProgram::SymbolSDFProgram;
 };
 
-using SymbolSDFIconProgram = SymbolSDFProgram<style::IconPaintProperties>;
-using SymbolSDFTextProgram = SymbolSDFProgram<style::TextPaintProperties>;
+class SymbolSDFTextProgram : public SymbolSDFProgram<SymbolSDFTextProgram, style::TextPaintProperties> {
+public:
+    using SymbolSDFProgram::SymbolSDFProgram;
+};
 
 using SymbolLayoutVertex = gfx::Vertex<SymbolLayoutAttributes>;
-using SymbolIconAttributes = SymbolIconProgram::Attributes;
-using SymbolTextAttributes = SymbolSDFTextProgram::Attributes;
+using SymbolIconAttributes = SymbolIconProgram::AttributeList;
+using SymbolTextAttributes = SymbolSDFTextProgram::AttributeList;
 
 class SymbolLayerPrograms final : public LayerTypePrograms {
 public:
-    SymbolLayerPrograms(gl::Context& context, const ProgramParameters& programParameters)
+    SymbolLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters)
         : symbolIcon(context, programParameters),
           symbolIconSDF(context, programParameters),
           symbolGlyph(context, programParameters),
diff --git a/src/mbgl/programs/symbol_sdf_icon_program.hpp b/src/mbgl/programs/symbol_sdf_icon_program.hpp
new file mode 100644
index 0000000000..57f27518d1
--- /dev/null
+++ b/src/mbgl/programs/symbol_sdf_icon_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/symbol_program.hpp>
diff --git a/src/mbgl/programs/symbol_sdf_text_program.hpp b/src/mbgl/programs/symbol_sdf_text_program.hpp
new file mode 100644
index 0000000000..57f27518d1
--- /dev/null
+++ b/src/mbgl/programs/symbol_sdf_text_program.hpp
@@ -0,0 +1,4 @@
+#pragma once
+
+// Alias
+#include <mbgl/programs/symbol_program.hpp>
diff --git a/src/mbgl/renderer/buckets/hillshade_bucket.cpp b/src/mbgl/renderer/buckets/hillshade_bucket.cpp
index 588e4e50b1..3c14845dd8 100644
--- a/src/mbgl/renderer/buckets/hillshade_bucket.cpp
+++ b/src/mbgl/renderer/buckets/hillshade_bucket.cpp
@@ -2,7 +2,7 @@
 #include <mbgl/renderer/layers/render_hillshade_layer.hpp>
 #include <mbgl/programs/hillshade_program.hpp>
 #include <mbgl/programs/hillshade_prepare_program.hpp>
-#include <mbgl/gl/context.hpp>
+#include <mbgl/gfx/context.hpp>
 
 namespace mbgl {
 
diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp
index bf6dffbf17..a8cb47d52c 100644
--- a/src/mbgl/renderer/buckets/raster_bucket.cpp
+++ b/src/mbgl/renderer/buckets/raster_bucket.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/renderer/buckets/raster_bucket.hpp>
 #include <mbgl/renderer/layers/render_raster_layer.hpp>
 #include <mbgl/programs/raster_program.hpp>
-#include <mbgl/gl/context.hpp>
+#include <mbgl/gfx/context.hpp>
 
 namespace mbgl {
 
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index 9764d870da..fafa2592fe 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -114,7 +114,7 @@ public:
     struct CollisionBuffer {
         gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>> vertices;
         gfx::VertexVector<gfx::Vertex<CollisionBoxDynamicAttributes>> dynamicVertices;
-        SegmentVector<CollisionBoxProgram::Attributes> segments;
+        SegmentVector<CollisionBoxProgram::AttributeList> segments;
 
         optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>> vertexBuffer;
         optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>> dynamicVertexBuffer;
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index ae89a08cac..32e05a38ab 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -8,6 +8,7 @@
 #include <mbgl/programs/background_program.hpp>
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/map/transform_state.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
 #include <mbgl/gl/context.hpp>
 
 namespace mbgl {
@@ -91,7 +92,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
         for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
             draw(
                 parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
-                BackgroundPatternProgram::uniformValues(
+                BackgroundPatternProgram::layoutUniformValues(
                     parameters.matrixForTile(tileID),
                     evaluated.get<BackgroundOpacity>(),
                     parameters.imageManager.getPixelSize(),
@@ -110,7 +111,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
         for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
             draw(
                 parameters.programs.getBackgroundLayerPrograms().background,
-                BackgroundProgram::UniformValues {
+                BackgroundProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( parameters.matrixForTile(tileID) ),
                     uniforms::u_color::Value( evaluated.get<BackgroundColor>() ),
                     uniforms::u_opacity::Value( evaluated.get<BackgroundOpacity>() ),
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index 32ee24551c..60a3bf8e01 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -7,6 +7,8 @@
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/circle_layer_impl.hpp>
 #include <mbgl/geometry/feature_index.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 
@@ -67,7 +69,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
         auto& programInstance = parameters.programs.getCircleLayerPrograms().circle.get(evaluated);
    
         const auto allUniformValues = programInstance.computeAllUniformValues(
-            CircleProgram::UniformValues {
+            CircleProgram::LayoutUniformValues {
                 uniforms::u_matrix::Value(
                     tile.translatedMatrix(evaluated.get<CircleTranslate>(),
                                           evaluated.get<CircleTranslateAnchor>(),
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 08f35f1c76..5af4732aa3 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -13,6 +13,7 @@
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
 #include <mbgl/gl/context.hpp>
 
 namespace mbgl {
@@ -117,7 +118,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 draw(
                     parameters.programs.getFillExtrusionLayerPrograms().fillExtrusion.get(evaluated),
                     bucket,
-                    FillExtrusionProgram::uniformValues(
+                    FillExtrusionProgram::layoutUniformValues(
                         tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
                                                   evaluated.get<FillExtrusionTranslateAnchor>(),
                                                   parameters.state),
@@ -144,7 +145,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 draw(
                     parameters.programs.getFillExtrusionLayerPrograms().fillExtrusionPattern.get(evaluated),
                     bucket,
-                    FillExtrusionPatternProgram::uniformValues(
+                    FillExtrusionPatternProgram::layoutUniformValues(
                         tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
                                                   evaluated.get<FillExtrusionTranslateAnchor>(),
                                                   parameters.state),
@@ -177,7 +178,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
         auto& programInstance = parameters.programs.getFillExtrusionLayerPrograms().extrusionTexture;
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
-            ExtrusionTextureProgram::UniformValues{
+            ExtrusionTextureProgram::LayoutUniformValues{
                 uniforms::u_matrix::Value( viewportMat ),
                 uniforms::u_world::Value( size ),
                 uniforms::u_opacity::Value( evaluated.get<FillExtrusionOpacity>() )
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 83989fa012..64f3448c69 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -8,6 +8,8 @@
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/fill_layer_impl.hpp>
 #include <mbgl/geometry/feature_index.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
@@ -80,7 +82,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                 const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
                 const auto allUniformValues = programInstance.computeAllUniformValues(
-                    FillProgram::UniformValues {
+                    FillProgram::LayoutUniformValues {
                         uniforms::u_matrix::Value(
                             tile.translatedMatrix(evaluated.get<FillTranslate>(),
                                                   evaluated.get<FillTranslateAnchor>(),
@@ -169,7 +171,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                 paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
 
                 const auto allUniformValues = programInstance.computeAllUniformValues(
-                    FillPatternProgram::uniformValues(
+                    FillPatternProgram::layoutUniformValues(
                         tile.translatedMatrix(evaluated.get<FillTranslate>(),
                                               evaluated.get<FillTranslateAnchor>(),
                                               parameters.state),
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 74b976658e..efc16fb28a 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -9,6 +9,8 @@
 #include <mbgl/style/layers/heatmap_layer.hpp>
 #include <mbgl/style/layers/heatmap_layer_impl.hpp>
 #include <mbgl/geometry/feature_index.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 
@@ -100,7 +102,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
             auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap.get(evaluated);
        
             const auto allUniformValues = programInstance.computeAllUniformValues(
-                HeatmapProgram::UniformValues {
+                HeatmapProgram::LayoutUniformValues {
                     uniforms::u_intensity::Value( evaluated.get<style::HeatmapIntensity>() ),
                     uniforms::u_matrix::Value( tile.matrix ),
                     uniforms::heatmap::u_extrude_scale::Value( extrudeScale )
@@ -145,8 +147,9 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
         auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmapTexture;
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
-            HeatmapTextureProgram::UniformValues{
-                uniforms::u_matrix::Value( viewportMat ), uniforms::u_world::Value( size ),
+            HeatmapTextureProgram::LayoutUniformValues{
+                uniforms::u_matrix::Value( viewportMat ),
+                uniforms::u_world::Value( size ),
                 uniforms::u_opacity::Value( evaluated.get<HeatmapOpacity>() )
             },
             paintAttributeData,
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index b428e357e7..00ecad444c 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -9,6 +9,8 @@
 #include <mbgl/programs/hillshade_prepare_program.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/hillshade_layer_impl.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/offscreen_texture.hpp>
 
@@ -74,7 +76,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
         const HillshadeProgram::Binders paintAttributeData{ evaluated, 0 };
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
-            HillshadeProgram::UniformValues {
+            HillshadeProgram::LayoutUniformValues {
                 uniforms::u_matrix::Value( matrix ),
                 uniforms::u_highlight::Value( evaluated.get<HillshadeHighlightColor>() ),
                 uniforms::u_shadow::Value( evaluated.get<HillshadeShadowColor>() ),
@@ -138,7 +140,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
             auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshadePrepare;
 
             const auto allUniformValues = programInstance.computeAllUniformValues(
-                HillshadePrepareProgram::UniformValues {
+                HillshadePrepareProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( mat ),
                     uniforms::u_dimension::Value( {{stride, stride}} ),
                     uniforms::u_zoom::Value( float(tile.id.canonical.z) ),
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 096afadf7d..eee151ccaa 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -8,6 +8,8 @@
 #include <mbgl/geometry/line_atlas.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
@@ -110,7 +112,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
             LinePatternPos posB = parameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().to, cap);
 
             draw(parameters.programs.getLineLayerPrograms().lineSDF,
-                 LineSDFProgram::uniformValues(
+                 LineSDFProgram::layoutUniformValues(
                      evaluated,
                      parameters.pixelRatio,
                      tile,
@@ -135,7 +137,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
             optional<ImagePosition> posB = geometryTile.getPattern(linePatternValue.to);
 
             draw(parameters.programs.getLineLayerPrograms().linePattern,
-                 LinePatternProgram::uniformValues(
+                 LinePatternProgram::layoutUniformValues(
                      evaluated,
                      tile,
                      parameters.state,
@@ -154,7 +156,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
             }
 
             draw(parameters.programs.getLineLayerPrograms().lineGradient,
-                 LineGradientProgram::uniformValues(
+                 LineGradientProgram::layoutUniformValues(
                     evaluated,
                     tile,
                     parameters.state,
@@ -166,7 +168,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                     });
         } else {
             draw(parameters.programs.getLineLayerPrograms().line,
-                 LineProgram::uniformValues(
+                 LineProgram::layoutUniformValues(
                      evaluated,
                      tile,
                      parameters.state,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index f68acd4061..c8f00eb1fd 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -7,6 +7,8 @@
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/programs/raster_program.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 
 namespace mbgl {
@@ -82,7 +84,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
         auto& programInstance = parameters.programs.getRasterLayerPrograms().raster;
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
-            RasterProgram::UniformValues {
+            RasterProgram::LayoutUniformValues {
                 uniforms::u_matrix::Value( matrix ),
                 uniforms::u_opacity::Value( evaluated.get<RasterOpacity>() ),
                 uniforms::u_fade_t::Value( 1 ),
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 43e3068ff0..31d92dd414 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -12,6 +12,8 @@
 #include <mbgl/tile/geometry_tile.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
+#include <mbgl/gfx/cull_face_mode.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/layout/symbol_projection.hpp>
 #include <mbgl/util/math.hpp>
 
@@ -170,7 +172,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
             if (bucket.sdfIcons) {
                 if (values.hasHalo) {
                     draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF,
-                         SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
+                         SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                          bucket.icon,
                          bucket.iconSizeBinder,
                          values,
@@ -183,7 +185,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
                 if (values.hasFill) {
                     draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF,
-                         SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
+                         SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                          bucket.icon,
                          bucket.iconSizeBinder,
                          values,
@@ -195,7 +197,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 }
             } else {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolIcon,
-                     SymbolIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange),
+                     SymbolIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange),
                      bucket.icon,
                      bucket.iconSizeBinder,
                      values,
@@ -233,7 +235,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             if (values.hasHalo) {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph,
-                     SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
+                     SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                      bucket.text,
                      bucket.textSizeBinder,
                      values,
@@ -246,7 +248,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             if (values.hasFill) {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph,
-                     SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
+                     SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                      bucket.text,
                      bucket.textSizeBinder,
                      values,
@@ -277,7 +279,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 gfx::StencilMode::disabled(),
                 parameters.colorModeForRenderPass(),
                 gfx::CullFaceMode::disabled(),
-                CollisionBoxProgram::UniformValues {
+                CollisionBoxProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( tile.matrix ),
                     uniforms::u_extrude_scale::Value( extrudeScale ),
                     uniforms::u_camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
@@ -313,7 +315,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 gfx::StencilMode::disabled(),
                 parameters.colorModeForRenderPass(),
                 gfx::CullFaceMode::disabled(),
-                CollisionCircleProgram::UniformValues {
+                CollisionCircleProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( tile.matrix ),
                     uniforms::u_extrude_scale::Value( extrudeScale ),
                     uniforms::u_overscale_factor::Value( float(tile.tile.id.overscaleFactor()) ),
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index dc5ab6ae22..a014b36ece 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -2,9 +2,8 @@
 
 #include <mbgl/gfx/context.hpp>
 #include <mbgl/gfx/uniform.hpp>
+#include <mbgl/gfx/attribute.hpp>
 #include <mbgl/programs/attributes.hpp>
-#include <mbgl/gl/attribute.hpp>
-#include <mbgl/gl/uniform.hpp>
 #include <mbgl/util/type_list.hpp>
 #include <mbgl/renderer/possibly_evaluated_property_value.hpp>
 #include <mbgl/renderer/paint_property_statistics.hpp>
@@ -101,7 +100,7 @@ public:
                                       const style::expression::Value&) = 0;
     virtual void upload(gfx::Context& context) = 0;
     virtual void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) = 0;
-    virtual std::tuple<ExpandToType<As, optional<gl::AttributeBinding>>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0;
+    virtual std::tuple<ExpandToType<As, optional<gfx::AttributeBinding>>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0;
     virtual std::tuple<ExpandToType<As, float>...> interpolationFactor(float currentZoom) const = 0;
     virtual std::tuple<ExpandToType<As, UniformValueType>...> uniformValue(const PossiblyEvaluatedType& currentValue) const = 0;
 
@@ -121,8 +120,8 @@ public:
     void upload(gfx::Context&) override {}
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) override {};
 
-    std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>&) const override {
-        return std::tuple<optional<gl::AttributeBinding>> {};
+    std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>&) const override {
+        return {};
     }
 
     std::tuple<float> interpolationFactor(float) const override {
@@ -155,9 +154,9 @@ public:
         }
     }
 
-    std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>>
+    std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>>
     attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>&) const override {
-        return std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>> {};
+        return {};
     }
 
     std::tuple<float, float> interpolationFactor(float) const override {
@@ -177,7 +176,7 @@ template <class T, class A>
 class SourceFunctionPaintPropertyBinder final : public PaintPropertyBinder<T, T, PossiblyEvaluatedPropertyValue<T>, A> {
 public:
     using BaseAttributeType = A;
-    using BaseVertex = gfx::Vertex<BaseAttributeType>;
+    using BaseVertex = gfx::VertexType<BaseAttributeType>;
 
     using AttributeType = ZoomInterpolatedAttributeType<A>;
 
@@ -200,12 +199,12 @@ public:
         vertexBuffer = context.createVertexBuffer(std::move(vertexVector));
     }
 
-    std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override {
+    std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override {
         if (currentValue.isConstant()) {
             return {};
         } else {
-            return std::tuple<optional<gl::AttributeBinding>>{
-                gl::attributeBinding<0>(*vertexBuffer)
+            return std::tuple<optional<gfx::AttributeBinding>>{
+                gfx::attributeBinding(*vertexBuffer)
             };
         }
     }
@@ -236,7 +235,7 @@ public:
 
     using AttributeType = ZoomInterpolatedAttributeType<A>;
     using AttributeValue = typename AttributeType::Value;
-    using Vertex = gfx::Vertex<AttributeType>;
+    using Vertex = gfx::VertexType<AttributeType>;
 
     CompositeFunctionPaintPropertyBinder(style::PropertyExpression<T> expression_, float zoom, T defaultValue_)
         : expression(std::move(expression_)),
@@ -264,12 +263,12 @@ public:
         vertexBuffer = context.createVertexBuffer(std::move(vertexVector));
     }
 
-    std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override {
+    std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override {
         if (currentValue.isConstant()) {
             return {};
         } else {
-            return std::tuple<optional<gl::AttributeBinding>>{
-                gl::attributeBinding<0>(*vertexBuffer)
+            return std::tuple<optional<gfx::AttributeBinding>>{
+                gfx::attributeBinding(*vertexBuffer)
             };
         }
     }
@@ -308,8 +307,8 @@ public:
     using BaseAttributeType = A1;
     using BaseAttributeType2 = A2;
 
-    using Vertex = gfx::Vertex<BaseAttributeType>;
-    using Vertex2 = gfx::Vertex<BaseAttributeType2>;
+    using Vertex = gfx::VertexType<BaseAttributeType>;
+    using Vertex2 = gfx::VertexType<BaseAttributeType2>;
 
     CompositeCrossFadedPaintPropertyBinder(style::PropertyExpression<T> expression_, float zoom, T defaultValue_)
         : expression(std::move(expression_)),
@@ -358,13 +357,13 @@ public:
         zoomOutVertexBuffer = context.createVertexBuffer(std::move(zoomOutVertexVector));
     }
 
-    std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>& currentValue) const override {
+    std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>& currentValue) const override {
         if (currentValue.isConstant()) {
             return {};
         } else {
-            return std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>>{
-                gl::attributeBinding<0>(*patternToVertexBuffer),
-                gl::attributeBinding<0>(crossfade.fromScale == 2 ? *zoomInVertexBuffer : *zoomOutVertexBuffer)
+            return std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>>{
+                gfx::attributeBinding(*patternToVertexBuffer),
+                gfx::attributeBinding(crossfade.fromScale == 2 ? *zoomInVertexBuffer : *zoomOutVertexBuffer)
             };
         }
     }
@@ -506,8 +505,7 @@ public:
     using InterpolationUniformList = typename Property<P>::InterpolationUniformList;
 
     using AttributeList = TypeListConcat<ZoomInterpolatedAttributeList<Ps>...>;
-    using Attributes = gl::Attributes<AttributeList>;
-    using AttributeBindings = typename Attributes::Bindings;
+    using AttributeBindings = gfx::AttributeBindings<AttributeList>;
 
     template <class EvaluatedProperties>
     AttributeBindings attributeBindings(const EvaluatedProperties& currentProperties) const {
@@ -518,7 +516,6 @@ public:
 
     using UniformList = TypeListConcat<InterpolationUniformList<Ps>..., typename Ps::UniformList...>;
     using UniformValues = gfx::UniformValues<UniformList>;
-    using Uniforms = gl::Uniforms<UniformList>;
 
     template <class EvaluatedProperties>
     UniformValues uniformValues(float currentZoom, EvaluatedProperties& currentProperties) const {
diff --git a/src/mbgl/renderer/render_static_data.cpp b/src/mbgl/renderer/render_static_data.cpp
index cae0e0a820..16d0d64a33 100644
--- a/src/mbgl/renderer/render_static_data.cpp
+++ b/src/mbgl/renderer/render_static_data.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/renderer/render_static_data.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/programs/program_parameters.hpp>
 
 namespace mbgl {
diff --git a/src/mbgl/renderer/render_static_data.hpp b/src/mbgl/renderer/render_static_data.hpp
index da887dff22..b9b52b09ca 100644
--- a/src/mbgl/renderer/render_static_data.hpp
+++ b/src/mbgl/renderer/render_static_data.hpp
@@ -2,6 +2,7 @@
 
 #include <mbgl/gfx/vertex_buffer.hpp>
 #include <mbgl/gfx/index_buffer.hpp>
+#include <mbgl/gl/renderbuffer.hpp>
 #include <mbgl/programs/background_program.hpp>
 #include <mbgl/programs/extrusion_texture_program.hpp>
 #include <mbgl/programs/programs.hpp>
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index d240189d74..24826bfd78 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/renderer/render_static_data.hpp>
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/map/transform_state.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/util/math.hpp>
 
@@ -103,7 +104,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
             *tile.debugBucket->indexBuffer,
             tile.debugBucket->segments,
             program.computeAllUniformValues(
-                DebugProgram::UniformValues {
+                DebugProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( matrix ),
                     uniforms::u_color::Value( Color::white() )
                 },
@@ -126,7 +127,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
             *tile.debugBucket->indexBuffer,
             tile.debugBucket->segments,
             program.computeAllUniformValues(
-                DebugProgram::UniformValues {
+                DebugProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( matrix ),
                     uniforms::u_color::Value( Color::black() )
                 },
@@ -151,7 +152,7 @@ void RenderTile::finishRender(PaintParameters& parameters) {
             parameters.staticData.tileBorderIndexBuffer,
             parameters.staticData.tileBorderSegments,
             program.computeAllUniformValues(
-                DebugProgram::UniformValues {
+                DebugProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( matrix ),
                     uniforms::u_color::Value( Color::red() )
                 },
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 8a9989dd51..471536cf40 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -461,7 +461,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                 parameters.staticData.quadTriangleIndexBuffer,
                 parameters.staticData.tileTriangleSegments,
                 program.computeAllUniformValues(
-                    ClippingMaskProgram::UniformValues {
+                    ClippingMaskProgram::LayoutUniformValues {
                         uniforms::u_matrix::Value( parameters.matrixForTile(clipID.first) ),
                     },
                     paintAttributeData,
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index cc8525aa9f..1b135a2838 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -7,6 +7,7 @@
 #include <mbgl/renderer/tile_parameters.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
 #include <mbgl/programs/programs.hpp>
+#include <mbgl/gl/context.hpp>
 #include <mbgl/util/tile_coordinate.hpp>
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/util/logging.hpp>
@@ -71,7 +72,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
             parameters.staticData.tileBorderIndexBuffer,
             parameters.staticData.tileBorderSegments,
             programInstance.computeAllUniformValues(
-                DebugProgram::UniformValues {
+                DebugProgram::LayoutUniformValues {
                     uniforms::u_matrix::Value( matrix ),
                     uniforms::u_color::Value( Color::red() )
                 },
diff --git a/src/mbgl/shaders/background.cpp b/src/mbgl/shaders/background.cpp
deleted file mode 100644
index 60f2d228be..0000000000
--- a/src/mbgl/shaders/background.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#include <mbgl/shaders/background.hpp>
-#include <mbgl/shaders/source.hpp>
-
-namespace mbgl {
-namespace shaders {
-
-const char* background::name = "background";
-const char* background::vertexSource = source() + 1429;
-const char* background::fragmentSource = source() + 1525;
-
-// Uncompressed source of background.vertex.glsl:
-/*
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
-    gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-*/
-
-// Uncompressed source of background.fragment.glsl:
-/*
-uniform vec4 u_color;
-uniform float u_opacity;
-
-void main() {
-    gl_FragColor = u_color * u_opacity;
-
-#ifdef OVERDRAW_INSPECTOR
-    gl_FragColor = vec4(1.0);
-#endif
-}
-
-*/
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/background.hpp b/src/mbgl/shaders/background.hpp
deleted file mode 100644
index 2fa6f56e29..0000000000
--- a/src/mbgl/shaders/background.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class background {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/background_pattern.hpp b/src/mbgl/shaders/background_pattern.hpp
deleted file mode 100644
index e970ffd670..0000000000
--- a/src/mbgl/shaders/background_pattern.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class background_pattern {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/circle.hpp b/src/mbgl/shaders/circle.hpp
deleted file mode 100644
index d14b26b783..0000000000
--- a/src/mbgl/shaders/circle.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class circle {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/clipping_mask.cpp b/src/mbgl/shaders/clipping_mask.cpp
deleted file mode 100644
index 717ebd3e84..0000000000
--- a/src/mbgl/shaders/clipping_mask.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#include <mbgl/shaders/clipping_mask.hpp>
-#include <mbgl/shaders/source.hpp>
-
-namespace mbgl {
-namespace shaders {
-
-const char* clipping_mask::name = "clipping_mask";
-const char* clipping_mask::vertexSource = source() + 7848;
-const char* clipping_mask::fragmentSource = source() + 7944;
-
-// Uncompressed source of clipping_mask.vertex.glsl:
-/*
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
-    gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-*/
-
-// Uncompressed source of clipping_mask.fragment.glsl:
-/*
-void main() {
-    gl_FragColor = vec4(1.0);
-}
-
-*/
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/clipping_mask.hpp b/src/mbgl/shaders/clipping_mask.hpp
deleted file mode 100644
index bd01ab62fa..0000000000
--- a/src/mbgl/shaders/clipping_mask.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class clipping_mask {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/collision_box.hpp b/src/mbgl/shaders/collision_box.hpp
deleted file mode 100644
index e0f70c7968..0000000000
--- a/src/mbgl/shaders/collision_box.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class collision_box {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/collision_circle.hpp b/src/mbgl/shaders/collision_circle.hpp
deleted file mode 100644
index 12b1bcd445..0000000000
--- a/src/mbgl/shaders/collision_circle.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class collision_circle {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/debug.cpp b/src/mbgl/shaders/debug.cpp
deleted file mode 100644
index 9f3a9cbc37..0000000000
--- a/src/mbgl/shaders/debug.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#include <mbgl/shaders/debug.hpp>
-#include <mbgl/shaders/source.hpp>
-
-namespace mbgl {
-namespace shaders {
-
-const char* debug::name = "debug";
-const char* debug::vertexSource = source() + 12450;
-const char* debug::fragmentSource = source() + 12546;
-
-// Uncompressed source of debug.vertex.glsl:
-/*
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
-    gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-*/
-
-// Uncompressed source of debug.fragment.glsl:
-/*
-uniform highp vec4 u_color;
-
-void main() {
-    gl_FragColor = u_color;
-}
-
-*/
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/debug.hpp b/src/mbgl/shaders/debug.hpp
deleted file mode 100644
index 207c7bf075..0000000000
--- a/src/mbgl/shaders/debug.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class debug {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/extrusion_texture.hpp b/src/mbgl/shaders/extrusion_texture.hpp
deleted file mode 100644
index 05e54c5499..0000000000
--- a/src/mbgl/shaders/extrusion_texture.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class extrusion_texture {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill.hpp b/src/mbgl/shaders/fill.hpp
deleted file mode 100644
index 29fede7b55..0000000000
--- a/src/mbgl/shaders/fill.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion.hpp b/src/mbgl/shaders/fill_extrusion.hpp
deleted file mode 100644
index 949ae57f12..0000000000
--- a/src/mbgl/shaders/fill_extrusion.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill_extrusion {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion_pattern.hpp b/src/mbgl/shaders/fill_extrusion_pattern.hpp
deleted file mode 100644
index e9ae001d4e..0000000000
--- a/src/mbgl/shaders/fill_extrusion_pattern.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill_extrusion_pattern {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline.hpp b/src/mbgl/shaders/fill_outline.hpp
deleted file mode 100644
index ef685e62fa..0000000000
--- a/src/mbgl/shaders/fill_outline.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill_outline {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline_pattern.hpp b/src/mbgl/shaders/fill_outline_pattern.hpp
deleted file mode 100644
index e1c7a173f4..0000000000
--- a/src/mbgl/shaders/fill_outline_pattern.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill_outline_pattern {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_pattern.hpp b/src/mbgl/shaders/fill_pattern.hpp
deleted file mode 100644
index 4d09519ed8..0000000000
--- a/src/mbgl/shaders/fill_pattern.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class fill_pattern {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap.hpp b/src/mbgl/shaders/heatmap.hpp
deleted file mode 100644
index a3c64db942..0000000000
--- a/src/mbgl/shaders/heatmap.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class heatmap {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap_texture.hpp b/src/mbgl/shaders/heatmap_texture.hpp
deleted file mode 100644
index c51dc6b178..0000000000
--- a/src/mbgl/shaders/heatmap_texture.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class heatmap_texture {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade.hpp b/src/mbgl/shaders/hillshade.hpp
deleted file mode 100644
index a4a27cb595..0000000000
--- a/src/mbgl/shaders/hillshade.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class hillshade {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade_prepare.hpp b/src/mbgl/shaders/hillshade_prepare.hpp
deleted file mode 100644
index c38b4a0d19..0000000000
--- a/src/mbgl/shaders/hillshade_prepare.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class hillshade_prepare {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line.hpp b/src/mbgl/shaders/line.hpp
deleted file mode 100644
index c0d81e6202..0000000000
--- a/src/mbgl/shaders/line.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class line {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_gradient.hpp b/src/mbgl/shaders/line_gradient.hpp
deleted file mode 100644
index 87a9d6d38c..0000000000
--- a/src/mbgl/shaders/line_gradient.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class line_gradient {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_pattern.hpp b/src/mbgl/shaders/line_pattern.hpp
deleted file mode 100644
index 0394e83fe0..0000000000
--- a/src/mbgl/shaders/line_pattern.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class line_pattern {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/line_sdf.hpp b/src/mbgl/shaders/line_sdf.hpp
deleted file mode 100644
index 1d4b566f25..0000000000
--- a/src/mbgl/shaders/line_sdf.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class line_sdf {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/preludes.cpp b/src/mbgl/shaders/preludes.cpp
deleted file mode 100644
index a9a507742c..0000000000
--- a/src/mbgl/shaders/preludes.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#include <mbgl/shaders/preludes.hpp>
-#include <mbgl/shaders/source.hpp>
-
-namespace mbgl {
-namespace shaders {
-
-const char* vertexPrelude = source() + 0;
-const char* fragmentPrelude = source() + 1252;
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/preludes.hpp b/src/mbgl/shaders/preludes.hpp
deleted file mode 100644
index a3abc9001f..0000000000
--- a/src/mbgl/shaders/preludes.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-extern const char* vertexPrelude;
-extern const char* fragmentPrelude;
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/raster.hpp b/src/mbgl/shaders/raster.hpp
deleted file mode 100644
index 791e2c8be0..0000000000
--- a/src/mbgl/shaders/raster.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class raster {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/source.cpp b/src/mbgl/shaders/source.cpp
deleted file mode 100644
index bc105946ba..0000000000
--- a/src/mbgl/shaders/source.cpp
+++ /dev/null
@@ -1,917 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#include <mbgl/shaders/source.hpp>
-#include <mbgl/util/compression.hpp>
-
-#include <cstdint>
-
-namespace mbgl {
-namespace shaders {
-
-const char* source() {
-    static const uint8_t compressed[] = {
-        0x78, 0xda, 0xed, 0x3d, 0xfd, 0x6f, 0xe3, 0x36,
-        0xb2, 0xf7, 0x73, 0xfe, 0x0a, 0x17, 0x05, 0x0e,
-        0x92, 0x2c, 0x5b, 0xb6, 0x93, 0xec, 0x97, 0x4e,
-        0xaf, 0x08, 0x76, 0xb3, 0x7d, 0x01, 0xda, 0xdd,
-        0x60, 0xd3, 0xf6, 0x15, 0x57, 0x2c, 0x0c, 0xc9,
-        0x56, 0x6c, 0xdf, 0xd9, 0x96, 0x9f, 0xad, 0x24,
-        0x76, 0x0e, 0xf9, 0xdf, 0x1f, 0x87, 0xdf, 0xa4,
-        0x48, 0x59, 0x76, 0x12, 0xe7, 0xe3, 0x19, 0x45,
-        0x37, 0x16, 0x39, 0x1c, 0x0e, 0xc9, 0xe1, 0x70,
-        0x66, 0x48, 0x0e, 0x7f, 0x1c, 0x5d, 0xf6, 0xd3,
-        0xcb, 0xda, 0xcf, 0xbf, 0x74, 0x4f, 0x2f, 0x0e,
-        0x66, 0xf3, 0xb4, 0x37, 0x5a, 0x8c, 0xb2, 0x69,
-        0x6d, 0x38, 0x1a, 0x0c, 0x67, 0xb5, 0xcb, 0x71,
-        0x16, 0xe7, 0xe1, 0xc1, 0x8f, 0xe9, 0x78, 0x91,
-        0x1e, 0xfc, 0x38, 0xba, 0xac, 0xfd, 0x80, 0x60,
-        0x47, 0xd3, 0xb4, 0xef, 0x8c, 0xb3, 0x9b, 0x99,
-        0x7b, 0xf0, 0x23, 0xf9, 0xac, 0xc1, 0x17, 0x82,
-        0x9a, 0xf6, 0x47, 0x97, 0x2a, 0xd8, 0x24, 0xed,
-        0x8f, 0xae, 0x26, 0x12, 0x24, 0x4d, 0x30, 0x02,
-        0xe3, 0x3a, 0x05, 0x28, 0xfe, 0xe4, 0x80, 0xe4,
-        0xcf, 0x75, 0xda, 0xeb, 0xd4, 0xae, 0xa6, 0xb3,
-        0xb8, 0xf7, 0xef, 0x2e, 0x26, 0xce, 0xe9, 0x65,
-        0xd3, 0x45, 0x4e, 0x08, 0xad, 0x41, 0x72, 0xda,
-        0xff, 0x23, 0x1e, 0x5f, 0xa5, 0x6e, 0xed, 0x3f,
-        0xa3, 0x29, 0x4b, 0x39, 0x9b, 0xe6, 0x38, 0x31,
-        0x42, 0x49, 0x8e, 0x0c, 0x14, 0x02, 0xcc, 0x75,
-        0x2b, 0x52, 0xc1, 0x82, 0xce, 0xf1, 0x9b, 0x70,
-        0x9e, 0xe6, 0x57, 0xf3, 0x69, 0x0d, 0x2a, 0x74,
-        0xae, 0x5b, 0xbe, 0x0a, 0xd1, 0xb8, 0x6e, 0x79,
-        0x08, 0xc8, 0x0d, 0xef, 0x64, 0x82, 0x32, 0xf4,
-        0xef, 0x28, 0x5f, 0x19, 0x48, 0xfa, 0x4a, 0x72,
-        0x28, 0x51, 0xe8, 0x7f, 0x9a, 0x20, 0x11, 0xc4,
-        0x40, 0x82, 0x8e, 0x52, 0x35, 0x69, 0xa4, 0x28,
-        0xe1, 0x06, 0xed, 0xce, 0xdb, 0x66, 0xcb, 0x9f,
-        0x64, 0x7d, 0xb5, 0xa0, 0xdf, 0x69, 0xb6, 0x5c,
-        0x42, 0xd0, 0x51, 0xad, 0x9f, 0xf6, 0xb2, 0x7e,
-        0xda, 0xed, 0x65, 0xe3, 0x6c, 0x4e, 0xc9, 0xc1,
-        0x84, 0xa6, 0x53, 0x48, 0xef, 0x7f, 0x84, 0x74,
-        0x44, 0x8c, 0xa8, 0xe8, 0xc8, 0x51, 0x3a, 0x55,
-        0x86, 0xfb, 0xab, 0xf5, 0x1d, 0x11, 0x75, 0x7c,
-        0x8c, 0x2a, 0xb5, 0xc3, 0xb4, 0x19, 0xcc, 0x01,
-        0x22, 0x81, 0xb4, 0x9c, 0x02, 0x4f, 0x46, 0xcb,
-        0x2e, 0x6e, 0x89, 0x44, 0x86, 0x34, 0x04, 0xbe,
-        0xdc, 0x59, 0xb9, 0xa0, 0x09, 0x15, 0x93, 0x47,
-        0x0a, 0x11, 0xe1, 0xcb, 0x9f, 0xed, 0xef, 0x7e,
-        0xce, 0x1a, 0x2b, 0x55, 0xa4, 0x35, 0xf8, 0x88,
-        0xd6, 0x84, 0x69, 0x5c, 0x14, 0xaa, 0xc2, 0x10,
-        0x93, 0xd1, 0x14, 0x67, 0x47, 0x4a, 0x9f, 0x61,
-        0x8a, 0xe5, 0xc2, 0x82, 0x00, 0xfa, 0x8d, 0x5a,
-        0xec, 0x86, 0x04, 0x43, 0xbc, 0xac, 0x84, 0xa1,
-        0xa3, 0x61, 0x38, 0x04, 0x0c, 0x52, 0x73, 0x19,
-        0x25, 0x3e, 0x43, 0xc8, 0x9a, 0xd8, 0xa9, 0x0d,
-        0xd2, 0xbc, 0x3b, 0x8b, 0xf3, 0x3c, 0x9d, 0x4f,
-        0xbb, 0xb3, 0x6c, 0xa1, 0xf4, 0xe5, 0x68, 0x99,
-        0x8e, 0x51, 0x9d, 0xd9, 0xbc, 0xdf, 0xbd, 0x9a,
-        0xcd, 0xd2, 0xb9, 0x6f, 0xc9, 0x44, 0x73, 0x54,
-        0xcb, 0xa4, 0x08, 0x17, 0xa3, 0x5b, 0x6d, 0x18,
-        0x46, 0xe3, 0xb4, 0x7b, 0x35, 0x1d, 0xe5, 0x8b,
-        0x6e, 0x9e, 0x75, 0x31, 0x8e, 0x85, 0x52, 0x30,
-        0x5b, 0x90, 0xde, 0xeb, 0xd4, 0xb2, 0xcb, 0xcb,
-        0x45, 0x9a, 0x47, 0xc0, 0x8d, 0xec, 0xff, 0x22,
-        0x41, 0x72, 0x45, 0x2e, 0xcc, 0x9b, 0x66, 0xcb,
-        0x94, 0x56, 0x2f, 0x52, 0xab, 0x40, 0xb1, 0xbe,
-        0x72, 0x4c, 0xf4, 0x79, 0x88, 0xa8, 0x3a, 0xa1,
-        0xc6, 0x0d, 0xe4, 0x62, 0xe1, 0xdd, 0xc1, 0xdf,
-        0x7e, 0x34, 0xcb, 0x38, 0x2a, 0x8b, 0x9e, 0x9f,
-        0x94, 0xfb, 0x1b, 0xa2, 0x7f, 0x3e, 0x4a, 0xae,
-        0xf2, 0x94, 0x74, 0x78, 0x0c, 0x83, 0x1e, 0xa2,
-        0x16, 0x5f, 0x66, 0xf3, 0x09, 0xe2, 0xb7, 0x1c,
-        0x31, 0x7d, 0x17, 0xfd, 0x99, 0x8f, 0x96, 0xe1,
-        0x75, 0x36, 0xea, 0xa3, 0xa4, 0xd1, 0xd4, 0x41,
-        0x63, 0x32, 0x18, 0x77, 0xcf, 0xb3, 0xc5, 0x28,
-        0x47, 0xad, 0x8b, 0x18, 0x84, 0x87, 0xa7, 0x37,
-        0x46, 0xe1, 0xb7, 0xfc, 0xb6, 0x0b, 0x1d, 0xc2,
-        0x50, 0x91, 0xf9, 0x43, 0x38, 0x96, 0xe3, 0xa7,
-        0xd3, 0x97, 0x89, 0xb3, 0x42, 0x0d, 0x9f, 0xe7,
-        0xf1, 0x80, 0x30, 0x3c, 0x2d, 0xe9, 0x09, 0xd8,
-        0x03, 0xda, 0xd5, 0x5f, 0xff, 0x38, 0xfd, 0xf6,
-        0xe9, 0xdb, 0xc9, 0xff, 0x74, 0xcf, 0xbe, 0x5c,
-        0x9c, 0x9f, 0x7e, 0xfc, 0xed, 0xeb, 0xb7, 0x03,
-        0xa5, 0x24, 0xa6, 0xa9, 0x8d, 0x24, 0x56, 0xc8,
-        0xda, 0x2c, 0x51, 0xa5, 0x36, 0x50, 0xa2, 0x15,
-        0x49, 0xda, 0xae, 0x3c, 0xb6, 0xdd, 0xb8, 0x34,
-        0x37, 0x29, 0xe4, 0xea, 0xac, 0x59, 0x06, 0x80,
-        0x39, 0xb0, 0xd0, 0x29, 0x8b, 0x5e, 0x3c, 0x96,
-        0xeb, 0x55, 0xd3, 0x93, 0x42, 0xba, 0x89, 0x57,
-        0x43, 0xe3, 0xf0, 0x5e, 0xc7, 0xf3, 0xd5, 0x68,
-        0x3a, 0x20, 0x49, 0xd7, 0x90, 0x84, 0xaa, 0x31,
-        0x24, 0x26, 0x5b, 0x0c, 0x39, 0x45, 0x17, 0xe9,
-        0x72, 0xc4, 0xd0, 0x25, 0xbe, 0xa1, 0x17, 0x7c,
-        0xde, 0x6e, 0x4f, 0x1f, 0x00, 0xdf, 0xdc, 0x44,
-        0x1f, 0x57, 0xce, 0x2a, 0x4e, 0xee, 0x5d, 0x71,
-        0xa2, 0x57, 0x9c, 0xac, 0xa9, 0x58, 0x65, 0x72,
-        0x99, 0x35, 0xf2, 0xb1, 0x9d, 0x6d, 0x92, 0xb9,
-        0x3d, 0x0f, 0x95, 0x4b, 0x4a, 0xca, 0x15, 0xf2,
-        0xf2, 0x74, 0x89, 0xe5, 0x8f, 0xce, 0x11, 0x13,
-        0x89, 0xa7, 0xf5, 0xa9, 0xc6, 0xd2, 0x17, 0xf1,
-        0x64, 0x36, 0x4e, 0xe7, 0x9d, 0x4f, 0x28, 0x6f,
-        0x34, 0x89, 0x07, 0xe9, 0xb6, 0xdc, 0x81, 0x73,
-        0x30, 0x06, 0xdc, 0xab, 0x58, 0x50, 0xd3, 0xd2,
-        0x3e, 0x9e, 0x7e, 0x4c, 0xa0, 0x47, 0xb0, 0x02,
-        0xa9, 0x9d, 0x14, 0xf0, 0x36, 0xf8, 0x6a, 0x0f,
-        0x49, 0x19, 0x02, 0x35, 0x5d, 0x0c, 0xb1, 0x40,
-        0x68, 0x47, 0x28, 0x1f, 0xc9, 0xea, 0xb4, 0xf3,
-        0xc9, 0xa1, 0x0d, 0xf0, 0x09, 0x3b, 0xa8, 0xe4,
-        0x20, 0xc6, 0x10, 0x04, 0x25, 0x2a, 0x41, 0x9d,
-        0x22, 0x45, 0x89, 0x8d, 0xa2, 0xc4, 0x48, 0x51,
-        0x37, 0x91, 0x69, 0xea, 0x98, 0x69, 0xea, 0xb8,
-        0xa1, 0x22, 0x98, 0xa0, 0x52, 0xd2, 0x06, 0x9f,
-        0x14, 0xf3, 0xf1, 0x88, 0xb9, 0xbb, 0x91, 0x71,
-        0x49, 0x96, 0x8d, 0xb9, 0x30, 0xb9, 0x19, 0xe5,
-        0x43, 0x04, 0x30, 0xd3, 0x73, 0x67, 0xa3, 0xbc,
-        0x37, 0x2c, 0xe6, 0x52, 0xb6, 0x43, 0x8d, 0x9c,
-        0x5f, 0x21, 0x2d, 0x04, 0xe3, 0xe0, 0x99, 0x92,
-        0x3a, 0x0f, 0xf2, 0x3e, 0x9e, 0xa4, 0xf3, 0x18,
-        0x26, 0x4d, 0x2f, 0x9d, 0xa2, 0x4e, 0xec, 0xf6,
-        0x47, 0x8b, 0x3c, 0x9e, 0xf6, 0x52, 0xb3, 0x64,
-        0x82, 0x06, 0x4f, 0xa1, 0xc5, 0xff, 0x7d, 0x72,
-        0xd1, 0xfd, 0xfd, 0xcb, 0xd9, 0xe7, 0xaf, 0xdf,
-        0x7e, 0xed, 0x52, 0xd9, 0x7f, 0xc0, 0x6a, 0x80,
-        0xc5, 0x91, 0x56, 0x10, 0x93, 0xac, 0x6e, 0x2e,
-        0xa1, 0x23, 0x04, 0xe0, 0xe1, 0xa0, 0xd9, 0x9c,
-        0x7b, 0xa5, 0x2c, 0x92, 0x41, 0x57, 0x62, 0x95,
-        0x76, 0x65, 0xa9, 0x92, 0x16, 0x56, 0x03, 0x61,
-        0xf3, 0x18, 0xad, 0xbe, 0x0b, 0x33, 0x65, 0x24,
-        0x4f, 0x21, 0x8d, 0xa9, 0x01, 0xb4, 0xc5, 0x04,
-        0x82, 0x53, 0xa7, 0x28, 0x09, 0x35, 0x9a, 0xa9,
-        0x51, 0xa8, 0xc2, 0x30, 0x02, 0xd6, 0x50, 0x99,
-        0x8c, 0xaf, 0x2c, 0xbd, 0x07, 0x39, 0x0a, 0x85,
-        0x38, 0x97, 0x92, 0x07, 0x99, 0x9c, 0x38, 0xa9,
-        0x18, 0x4e, 0xd7, 0xe8, 0x92, 0xb2, 0x49, 0x7d,
-        0x6b, 0x48, 0xa2, 0x1c, 0x6e, 0xa6, 0x8a, 0x66,
-        0x5a, 0x09, 0xe3, 0xea, 0x42, 0x91, 0x36, 0x31,
-        0x73, 0xec, 0xe4, 0x49, 0x30, 0x25, 0x14, 0x2e,
-        0xf2, 0x79, 0xf6, 0xef, 0xb4, 0x8c, 0xf5, 0x64,
-        0x08, 0x3b, 0x07, 0xca, 0x50, 0x26, 0x46, 0x54,
-        0xf2, 0xcb, 0xf8, 0x51, 0x07, 0x5c, 0x4f, 0xfb,
-        0xcd, 0xa8, 0x9f, 0x0f, 0x4b, 0x69, 0xc7, 0x10,
-        0x65, 0x2c, 0x2a, 0xc3, 0x59, 0x18, 0x55, 0x01,
-        0x59, 0xc3, 0xae, 0x3a, 0xec, 0xfa, 0x36, 0x94,
-        0x32, 0x8a, 0x0a, 0x63, 0xe5, 0x17, 0x15, 0xcc,
-        0xc4, 0x36, 0x1a, 0x44, 0x19, 0xf7, 0x14, 0x41,
-        0x89, 0xbb, 0x40, 0x2c, 0x90, 0x87, 0x68, 0x81,
-        0xec, 0xc7, 0x79, 0x2c, 0xad, 0x8f, 0xf0, 0x0b,
-        0xad, 0x91, 0xa5, 0xe2, 0xad, 0x47, 0x14, 0x5d,
-        0xdd, 0xc4, 0xa4, 0x32, 0xcc, 0xe7, 0xa2, 0xce,
-        0x65, 0xe4, 0xe9, 0xd2, 0x2c, 0xda, 0x48, 0x66,
-        0x91, 0x3f, 0x91, 0x6e, 0x3b, 0x33, 0xa9, 0xe4,
-        0x0b, 0x01, 0xc6, 0x2b, 0x34, 0x09, 0xa8, 0x68,
-        0x13, 0x19, 0x04, 0xff, 0x18, 0x6a, 0x84, 0x64,
-        0x9f, 0x09, 0x23, 0x5e, 0x9b, 0x26, 0x71, 0xa2,
-        0x8d, 0xe4, 0x0a, 0xfd, 0x6b, 0xa8, 0x8c, 0xe6,
-        0xf8, 0x92, 0x98, 0x31, 0x55, 0xc9, 0x11, 0x6c,
-        0x23, 0x2e, 0xe4, 0x0f, 0xd3, 0x88, 0xca, 0xf9,
-        0xbe, 0x2e, 0x48, 0x4c, 0xe3, 0xab, 0x22, 0xdc,
-        0x5a, 0x14, 0xc8, 0x1f, 0x86, 0xae, 0x91, 0xb3,
-        0x7d, 0x5d, 0x46, 0x58, 0xb8, 0x40, 0x45, 0x79,
-        0x8f, 0x09, 0xae, 0x7e, 0xda, 0xa9, 0x13, 0xe3,
-        0xa7, 0xcf, 0x7e, 0xd3, 0x30, 0xea, 0x58, 0xad,
-        0xd3, 0x17, 0xfb, 0xac, 0x88, 0x42, 0x13, 0xe1,
-        0x0a, 0x41, 0x5d, 0x24, 0x76, 0x0d, 0xb8, 0xbb,
-        0x3c, 0xf4, 0x4f, 0x43, 0x68, 0x8d, 0xbd, 0xd1,
-        0xbc, 0x87, 0xf4, 0x26, 0xa2, 0xd3, 0x44, 0xa8,
-        0x2a, 0x3c, 0xac, 0x08, 0xd8, 0x6b, 0x35, 0x8f,
-        0xdd, 0x10, 0x19, 0xe1, 0x8e, 0xae, 0x3d, 0x31,
-        0x15, 0xb9, 0x97, 0xcd, 0xa7, 0x48, 0x0f, 0x9a,
-        0x31, 0x4b, 0x4a, 0x41, 0x45, 0x4b, 0xaa, 0x5a,
-        0x19, 0x2a, 0xa9, 0x15, 0xaa, 0x47, 0x94, 0x54,
-        0xcf, 0x21, 0x93, 0xaf, 0x2e, 0xf7, 0x3b, 0x68,
-        0x90, 0xaa, 0x6e, 0x76, 0x57, 0x83, 0x7e, 0xa1,
-        0x6e, 0xa8, 0xd9, 0x3c, 0xfb, 0x57, 0xda, 0xcb,
-        0xd3, 0x3e, 0x23, 0x5f, 0xb5, 0xe5, 0x14, 0x7a,
-        0x88, 0x4d, 0x77, 0xbf, 0xda, 0x3d, 0x47, 0xaf,
-        0xb1, 0x79, 0x13, 0x94, 0x68, 0x86, 0xc8, 0xa2,
-        0xb2, 0x5b, 0x9a, 0x1a, 0x29, 0xd4, 0xcd, 0x40,
-        0x9b, 0x57, 0x52, 0xac, 0xd8, 0x28, 0x4b, 0x4f,
-        0x4b, 0x38, 0x9a, 0xcb, 0xd5, 0xa6, 0x4d, 0x2d,
-        0x53, 0x78, 0x0d, 0x54, 0x6e, 0x51, 0x83, 0x5c,
-        0xfa, 0x26, 0xbc, 0xbb, 0x93, 0xd7, 0xc3, 0x69,
-        0x3e, 0x8a, 0xc7, 0xa3, 0x78, 0x81, 0xc5, 0x25,
-        0x62, 0xd6, 0xe0, 0xd3, 0xe9, 0x1f, 0x67, 0x1f,
-        0x4f, 0xbb, 0xe7, 0x67, 0x7f, 0x9e, 0xfe, 0xd2,
-        0xfd, 0x76, 0xf2, 0xdb, 0xd9, 0xd7, 0xc0, 0x58,
-        0x4b, 0x48, 0x16, 0x2c, 0x60, 0xfc, 0x43, 0x87,
-        0xd6, 0xd7, 0x5c, 0xfa, 0xec, 0x17, 0x9a, 0x6c,
-        0x32, 0x6a, 0x97, 0x3a, 0xba, 0xac, 0x2b, 0xd9,
-        0x63, 0xab, 0xdb, 0xbb, 0x51, 0x98, 0x1f, 0x59,
-        0xf3, 0xdd, 0x9d, 0xf2, 0xfa, 0x14, 0x4a, 0xe7,
-        0x53, 0xaa, 0x8a, 0x4f, 0xa0, 0xdf, 0x51, 0xdd,
-        0xce, 0x36, 0x21, 0xaa, 0x68, 0x6a, 0x56, 0x6e,
-        0xaf, 0xac, 0x75, 0x59, 0xf8, 0x78, 0xbd, 0x1e,
-        0x65, 0x67, 0xd2, 0xaa, 0x0a, 0xd1, 0x1a, 0x0e,
-        0xdc, 0x5c, 0x93, 0x59, 0xc3, 0x5e, 0x5b, 0xe9,
-        0x20, 0x6b, 0x19, 0xe7, 0xde, 0x7a, 0x03, 0x66,
-        0x0b, 0x24, 0xd4, 0x43, 0x82, 0x84, 0x49, 0xee,
-        0x71, 0x3a, 0x1d, 0x20, 0xca, 0xc8, 0x1f, 0x26,
-        0x5f, 0xdd, 0xd0, 0x2a, 0xba, 0x29, 0x9e, 0xdb,
-        0x50, 0xcb, 0x44, 0x0b, 0x28, 0xce, 0x6f, 0x4c,
-        0xe2, 0xa5, 0x43, 0x94, 0x66, 0x55, 0x2e, 0x2b,
-        0x23, 0xd5, 0xcd, 0xa3, 0xc5, 0x24, 0xcb, 0xf2,
-        0xe1, 0x22, 0x4f, 0x67, 0x4e, 0xab, 0xd9, 0xf2,
-        0x75, 0x44, 0xbe, 0x4a, 0x20, 0xd1, 0x6f, 0x08,
-        0x0e, 0xaa, 0x8b, 0x46, 0x72, 0x5f, 0xd6, 0xfe,
-        0x51, 0x43, 0x58, 0xda, 0xb5, 0x9f, 0xe0, 0x4f,
-        0xed, 0x43, 0x4d, 0xc2, 0x5e, 0xc0, 0x0c, 0xd5,
-        0x69, 0xd8, 0x09, 0xc3, 0x9a, 0x17, 0x20, 0xcd,
-        0x35, 0xc6, 0x5b, 0xe0, 0x71, 0x27, 0x99, 0xc7,
-        0xf4, 0x3e, 0x99, 0x63, 0x3c, 0x4d, 0x27, 0x94,
-        0x34, 0xe8, 0x7b, 0x38, 0xce, 0x1e, 0x7b, 0x4b,
-        0xc4, 0xbe, 0xcb, 0x21, 0xc8, 0xb1, 0xae, 0xb0,
-        0x37, 0x29, 0x9a, 0x4b, 0xb9, 0xd9, 0x1c, 0x26,
-        0x79, 0x66, 0x57, 0x44, 0x87, 0xe7, 0x6b, 0x4e,
-        0x08, 0x52, 0x98, 0x66, 0x19, 0x97, 0x02, 0x26,
-        0x19, 0x05, 0xcc, 0x63, 0x7b, 0xc4, 0x36, 0x5b,
-        0xc3, 0xcb, 0x1d, 0x9d, 0xac, 0x90, 0xd9, 0x5b,
-        0x69, 0x73, 0x8b, 0xb3, 0xf4, 0x11, 0xd2, 0xe1,
-        0xa6, 0x0b, 0xc8, 0xa9, 0xb2, 0x93, 0x42, 0xeb,
-        0x08, 0xc9, 0x0e, 0xa6, 0xdc, 0x7b, 0xff, 0x3c,
-        0xfd, 0xf6, 0x15, 0xab, 0x64, 0x78, 0xeb, 0x3a,
-        0x68, 0xbf, 0x69, 0xb6, 0x42, 0xbe, 0x31, 0xf7,
-        0xf3, 0xc9, 0xef, 0x17, 0x17, 0xdd, 0x8f, 0x5f,
-        0x4f, 0x3f, 0xa3, 0x99, 0x75, 0xf8, 0xfe, 0xdd,
-        0xfb, 0xa3, 0x4e, 0xe7, 0x5d, 0xeb, 0xa8, 0xd5,
-        0x3e, 0x3a, 0xec, 0xbc, 0x3d, 0xa8, 0xea, 0x45,
-        0xa0, 0x9c, 0x41, 0xfe, 0x18, 0xec, 0x27, 0x92,
-        0xe1, 0x0b, 0x36, 0xd1, 0x0c, 0x4d, 0x99, 0x11,
-        0xa2, 0xcd, 0x46, 0xdb, 0xbc, 0x44, 0x3d, 0xb8,
-        0x67, 0x81, 0x9e, 0x80, 0xc0, 0x23, 0xd8, 0xef,
-        0x56, 0xb2, 0xd6, 0x08, 0xc2, 0x8b, 0x68, 0xf1,
-        0xbf, 0xf3, 0xdc, 0x69, 0xa0, 0x64, 0x6f, 0x9c,
-        0x0d, 0x1c, 0x18, 0x8d, 0x80, 0x34, 0x30, 0x90,
-        0xc6, 0x38, 0x10, 0x03, 0xe1, 0xba, 0xc1, 0x21,
-        0x1a, 0x22, 0x3e, 0xa4, 0xd1, 0x85, 0xa7, 0x57,
-        0x1c, 0x6a, 0xb2, 0x9f, 0xe9, 0xf1, 0x84, 0xe8,
-        0x82, 0x0d, 0x46, 0x6c, 0xaf, 0x6c, 0x41, 0x26,
-        0xb9, 0x6e, 0x32, 0xd6, 0x29, 0x30, 0x11, 0x12,
-        0x46, 0x49, 0x02, 0xfc, 0xb6, 0x4e, 0x2c, 0x3c,
-        0xd0, 0xd4, 0x36, 0x03, 0x89, 0xb9, 0x60, 0x61,
-        0xfb, 0x8d, 0x19, 0xda, 0xaa, 0x36, 0xd1, 0xe6,
-        0x54, 0x61, 0x4c, 0x92, 0xdb, 0x8f, 0x1a, 0xa8,
-        0x1b, 0x3d, 0x34, 0x66, 0xf8, 0xff, 0x7e, 0x96,
-        0x3b, 0x9c, 0x2e, 0x9f, 0xff, 0x62, 0xfc, 0x70,
-        0x1d, 0x8f, 0x23, 0x82, 0xc6, 0x93, 0x9a, 0xe5,
-        0x09, 0xb2, 0xbd, 0x74, 0x39, 0x73, 0xfa, 0xda,
-        0xaa, 0x84, 0x07, 0x0e, 0x15, 0x85, 0xdd, 0x23,
-        0xf6, 0xbf, 0xbb, 0x83, 0x7d, 0xe8, 0x9b, 0x6c,
-        0x3e, 0xee, 0x57, 0xdd, 0xc9, 0xdd, 0x68, 0x49,
-        0xf2, 0x28, 0x72, 0x69, 0xeb, 0xb6, 0xb9, 0x8c,
-        0x62, 0xf2, 0x97, 0x7e, 0xaf, 0x40, 0x6c, 0x35,
-        0x48, 0xda, 0x4a, 0xde, 0xec, 0x2c, 0xee, 0x1c,
-        0x9a, 0x72, 0xc8, 0x92, 0x3c, 0x47, 0x29, 0xf6,
-        0x5d, 0xff, 0x35, 0x8d, 0xa0, 0x47, 0x45, 0x0c,
-        0xbb, 0x6a, 0x18, 0xd8, 0x6d, 0xce, 0xa5, 0xcd,
-        0x37, 0x05, 0x4a, 0x54, 0xee, 0x63, 0x29, 0x91,
-        0xfb, 0x30, 0xd7, 0xb4, 0x61, 0xbd, 0xd7, 0xc1,
-        0x82, 0x56, 0x15, 0xdd, 0xa1, 0x90, 0x18, 0x4f,
-        0x7b, 0xc3, 0x6c, 0x6e, 0xce, 0x63, 0x93, 0xa9,
-        0x88, 0x69, 0x1c, 0xf7, 0x52, 0x03, 0x1f, 0x2c,
-        0x86, 0xa3, 0xcb, 0x3c, 0xac, 0xc4, 0x49, 0xe5,
-        0x6b, 0xa0, 0xdd, 0x75, 0xc1, 0x46, 0x88, 0xce,
-        0x1e, 0x46, 0x8a, 0x9e, 0x3c, 0xcd, 0xf2, 0xdf,
-        0x17, 0x90, 0xae, 0xed, 0x0b, 0x4b, 0x3e, 0xa7,
-        0xf3, 0x0c, 0x4d, 0xb7, 0x02, 0x2b, 0x8a, 0xfe,
-        0x20, 0x9c, 0x28, 0xcf, 0x7b, 0x41, 0x15, 0x85,
-        0x62, 0x54, 0x45, 0x2a, 0xd2, 0xe6, 0x8d, 0x5a,
-        0x2c, 0x1b, 0x8f, 0xf1, 0xd9, 0x9b, 0xee, 0x2c,
-        0x9d, 0x2f, 0x66, 0x08, 0x6e, 0x74, 0x9d, 0x22,
-        0x56, 0x40, 0x53, 0x21, 0xea, 0x8d, 0x11, 0x47,
-        0xa0, 0xa1, 0x3b, 0xae, 0x83, 0xcc, 0x70, 0x4a,
-        0x5a, 0x1e, 0x58, 0x6b, 0x77, 0xb1, 0x8a, 0x7b,
-        0x04, 0xc3, 0xbf, 0x56, 0xef, 0x63, 0xa2, 0x42,
-        0xf7, 0xfc, 0x38, 0x7c, 0xb4, 0xeb, 0x74, 0x18,
-        0xd7, 0xf8, 0x7b, 0xbc, 0x92, 0x56, 0x85, 0x6c,
-        0x58, 0x22, 0xc6, 0x2a, 0x78, 0x0a, 0xd3, 0x31,
-        0x11, 0x89, 0x78, 0x0e, 0xdf, 0x67, 0x40, 0xa9,
-        0x36, 0x37, 0x9e, 0x0d, 0xe3, 0x08, 0xf5, 0x5f,
-        0x68, 0x94, 0x72, 0xb8, 0xd1, 0xac, 0xe1, 0x1e,
-        0x06, 0xc6, 0x1e, 0x37, 0x56, 0x55, 0xed, 0xbf,
-        0x6a, 0x30, 0x15, 0x4d, 0xfa, 0xaf, 0x54, 0x12,
-        0x4f, 0x57, 0x5a, 0xfa, 0x8e, 0x14, 0xa7, 0x24,
-        0x19, 0xcb, 0x7b, 0x51, 0xb3, 0x1d, 0xde, 0xed,
-        0x64, 0x16, 0x3e, 0xab, 0xe9, 0xa6, 0xa5, 0x6b,
-        0xdb, 0xca, 0xda, 0x22, 0x6d, 0x4e, 0x66, 0x4a,
-        0xca, 0x7e, 0xe6, 0x1a, 0x67, 0xae, 0x4c, 0xdf,
-        0x2c, 0xee, 0xf7, 0x51, 0x07, 0x76, 0x2f, 0xe3,
-        0x5e, 0x9e, 0x81, 0x9f, 0xb5, 0x53, 0x98, 0xd8,
-        0x9c, 0x7f, 0x0a, 0xd3, 0x59, 0x2d, 0xfc, 0x18,
-        0xb3, 0x9b, 0x8d, 0x7f, 0x14, 0x27, 0x0b, 0x21,
-        0x60, 0x9a, 0x2b, 0x57, 0x52, 0x66, 0x05, 0x7d,
-        0x2a, 0x3d, 0xa1, 0xc6, 0x0f, 0xd1, 0x06, 0xfe,
-        0xed, 0x52, 0xea, 0x25, 0xb5, 0x81, 0xaf, 0xfe,
-        0xd7, 0x08, 0x0a, 0x7b, 0xdf, 0x59, 0xdd, 0xcf,
-        0x83, 0xeb, 0x75, 0xf1, 0x26, 0xa9, 0x16, 0x1b,
-        0x0b, 0xb7, 0xde, 0xb6, 0x52, 0xad, 0x47, 0xc5,
-        0x59, 0x87, 0x1d, 0x71, 0x56, 0x08, 0xd6, 0x1c,
-        0x4a, 0x5a, 0x73, 0xdc, 0x52, 0xef, 0x93, 0xd0,
-        0x85, 0x3d, 0x13, 0xce, 0xd0, 0xe0, 0x51, 0x6b,
-        0x23, 0x8b, 0xd5, 0x08, 0x1c, 0x18, 0x46, 0x51,
-        0xb1, 0xe0, 0xd8, 0xa8, 0x94, 0x55, 0xc5, 0xf8,
-        0x07, 0x58, 0x2a, 0xed, 0x0f, 0x52, 0xcc, 0xb7,
-        0x46, 0xd7, 0x51, 0xa9, 0x7f, 0xab, 0xa1, 0x6c,
-        0x5e, 0x42, 0x4f, 0x37, 0x74, 0xcc, 0x56, 0x27,
-        0x13, 0xf1, 0x3e, 0xde, 0xed, 0xee, 0x30, 0xac,
-        0x61, 0xe3, 0x63, 0xed, 0xd1, 0xd7, 0x0d, 0xe9,
-        0x7b, 0x69, 0x27, 0xa9, 0x9e, 0xd3, 0x81, 0xa0,
-        0x82, 0x81, 0xfa, 0xe4, 0x67, 0x36, 0x76, 0x70,
-        0xac, 0xa1, 0x2a, 0x0f, 0x3f, 0xc9, 0xc6, 0xdf,
-        0x03, 0x6f, 0x9a, 0x3d, 0xf2, 0xc6, 0xcd, 0x46,
-        0xbb, 0x27, 0x06, 0x5b, 0xf4, 0x41, 0x8e, 0x7f,
-        0x6e, 0x20, 0x2b, 0x8c, 0xfe, 0x06, 0x83, 0x55,
-        0x6e, 0x1b, 0x9c, 0xab, 0x7c, 0x3c, 0x9a, 0x96,
-        0x1e, 0x95, 0x53, 0x40, 0xec, 0x32, 0x46, 0x01,
-        0x33, 0xc9, 0x1a, 0x15, 0xa0, 0x8c, 0xab, 0x0a,
-        0x90, 0xaf, 0x48, 0xf6, 0xa8, 0x1d, 0xae, 0x7c,
-        0x99, 0x64, 0x91, 0x02, 0xe0, 0x17, 0x06, 0xc3,
-        0x24, 0x9b, 0x34, 0x9c, 0x5b, 0xf5, 0xe6, 0x53,
-        0xcb, 0x2a, 0xcc, 0xb3, 0x91, 0xa3, 0xea, 0xe6,
-        0x81, 0xa2, 0x71, 0xd7, 0x61, 0xd2, 0x04, 0xe0,
-        0x15, 0x66, 0x5c, 0x6f, 0x15, 0x70, 0x6a, 0x9f,
-        0xef, 0x9c, 0x35, 0x1f, 0x8a, 0xbb, 0xd6, 0xb8,
-        0xda, 0x2c, 0xf2, 0x4c, 0x69, 0xfb, 0x36, 0x6c,
-        0x72, 0x4f, 0x19, 0x29, 0x34, 0x45, 0xa1, 0xc6,
-        0x22, 0xda, 0x1b, 0x5c, 0x0a, 0x66, 0x73, 0x64,
-        0x0f, 0xad, 0x98, 0x82, 0x48, 0x94, 0x77, 0x70,
-        0x5b, 0x6a, 0x1b, 0xa0, 0xa0, 0x7c, 0x03, 0x16,
-        0x5d, 0x13, 0x94, 0xc9, 0xf6, 0x1c, 0x5c, 0x9c,
-        0x09, 0xe1, 0xdd, 0x39, 0x78, 0x1f, 0xee, 0x06,
-        0x11, 0x3b, 0xbb, 0x81, 0x8d, 0x9b, 0xfb, 0xde,
-        0x00, 0xaa, 0xbe, 0x0c, 0x3c, 0xfb, 0x23, 0xdd,
-        0xec, 0x1e, 0xc7, 0xe5, 0x3c, 0x9b, 0x98, 0xc9,
-        0x94, 0x21, 0x8c, 0xb4, 0x1e, 0x69, 0x40, 0x2a,
-        0xc1, 0xf4, 0x22, 0xa8, 0x94, 0x6d, 0x22, 0x9a,
-        0x0e, 0x8f, 0x0e, 0x57, 0x81, 0xf0, 0x3c, 0x2b,
-        0x27, 0x1b, 0x19, 0x3a, 0xeb, 0x88, 0xce, 0xb3,
-        0x12, 0x92, 0x51, 0x66, 0x05, 0x82, 0x09, 0x54,
-        0xf5, 0xd5, 0xea, 0xa9, 0x8e, 0xe4, 0x2a, 0xc3,
-        0x2d, 0x7f, 0x44, 0x71, 0xd7, 0x34, 0x48, 0xd2,
-        0x5e, 0xb4, 0x3a, 0x8a, 0xd1, 0xb6, 0x83, 0x25,
-        0x7e, 0x46, 0x71, 0xb7, 0xd8, 0xc9, 0xc6, 0x0a,
-        0x11, 0xac, 0xb9, 0xab, 0xe5, 0x8b, 0xb4, 0x70,
-        0x69, 0x2a, 0x92, 0x69, 0x82, 0x43, 0x27, 0x0a,
-        0x04, 0xdc, 0x9e, 0x52, 0x21, 0x6e, 0x6f, 0x42,
-        0x1d, 0x47, 0x12, 0x89, 0x8a, 0x4c, 0x18, 0x94,
-        0x7c, 0x54, 0x9e, 0x3a, 0xc0, 0x40, 0xf0, 0x7c,
-        0xc3, 0xfe, 0x38, 0x2a, 0x64, 0x9a, 0xcb, 0x50,
-        0xdc, 0xe7, 0x55, 0x73, 0xd8, 0x59, 0x18, 0x20,
-        0xe1, 0x82, 0xfa, 0x94, 0x48, 0x0e, 0x3b, 0xde,
-        0x92, 0x67, 0x6a, 0xfa, 0x4d, 0x58, 0x6d, 0x79,
-        0x07, 0x5a, 0x91, 0x30, 0x9f, 0x8d, 0xe3, 0x15,
-        0xbd, 0x21, 0x48, 0xb6, 0x82, 0x1d, 0xb9, 0x0b,
-        0x9a, 0xcb, 0x86, 0xdc, 0x67, 0xcd, 0xa5, 0x1b,
-        0x08, 0xf2, 0x7d, 0x15, 0x74, 0xa5, 0x82, 0xae,
-        0x64, 0x50, 0x53, 0x7d, 0x49, 0xb1, 0xbe, 0x44,
-        0xad, 0x2f, 0x29, 0xa9, 0x2f, 0x51, 0xeb, 0x4b,
-        0x0a, 0xf5, 0xdd, 0xf3, 0x22, 0x25, 0xef, 0x70,
-        0x4f, 0xed, 0x24, 0x9f, 0x8f, 0xd1, 0x43, 0xdd,
-        0x9c, 0xa4, 0x03, 0xa8, 0xd6, 0x93, 0x58, 0xea,
-        0xd9, 0x42, 0x21, 0x5b, 0x73, 0xdb, 0xd1, 0xbe,
-        0x0f, 0xc9, 0x56, 0x87, 0xcb, 0xb8, 0x9f, 0x3e,
-        0xea, 0x92, 0xb7, 0xbb, 0x55, 0x6b, 0xd7, 0xcb,
-        0xcd, 0x63, 0xae, 0x15, 0x8f, 0x71, 0xec, 0x50,
-        0xe9, 0xac, 0x6d, 0x04, 0x7a, 0x69, 0x6f, 0xbc,
-        0x38, 0x81, 0xbd, 0xd9, 0xa5, 0x5c, 0xcb, 0x95,
-        0xdc, 0x27, 0xba, 0x90, 0x6b, 0xb9, 0x8e, 0xfb,
-        0x60, 0x97, 0x71, 0x1f, 0xd9, 0xa8, 0x30, 0x5d,
-        0xef, 0x05, 0x41, 0x44, 0x3d, 0xff, 0xde, 0x0e,
-        0xe3, 0x18, 0x3c, 0x0f, 0x4b, 0x62, 0x6f, 0x36,
-        0xec, 0xcd, 0x86, 0xbd, 0xd9, 0xb0, 0x37, 0x1b,
-        0x2c, 0x66, 0xc3, 0x3f, 0xb3, 0x6c, 0x72, 0x7f,
-        0xd3, 0xe1, 0xb5, 0x5b, 0x05, 0x3b, 0x89, 0xc1,
-        0x52, 0x6a, 0x3a, 0xf0, 0x71, 0xda, 0x81, 0xf9,
-        0x50, 0xa8, 0x6b, 0xbd, 0x35, 0xa0, 0xe8, 0xfc,
-        0x0f, 0x11, 0xe4, 0x64, 0xaf, 0xfa, 0xef, 0x55,
-        0xff, 0xbd, 0xea, 0xff, 0xba, 0x54, 0xff, 0x8a,
-        0x8a, 0xfa, 0x6e, 0x54, 0xf4, 0x43, 0x94, 0x3a,
-        0x86, 0xb3, 0xe8, 0x6a, 0x6c, 0x34, 0x36, 0xa5,
-        0x78, 0xb6, 0xbc, 0x7f, 0xab, 0xc8, 0x12, 0x9c,
-        0x2b, 0x0e, 0xe7, 0xeb, 0x92, 0xf0, 0x3a, 0x9d,
-        0xe7, 0x23, 0x24, 0x61, 0xbb, 0x03, 0x38, 0x46,
-        0x93, 0x4e, 0xf3, 0x70, 0xfd, 0xf1, 0x48, 0x50,
-        0xfd, 0xa6, 0x08, 0x09, 0x2a, 0x95, 0x2a, 0x5b,
-        0xc1, 0x47, 0x48, 0x2e, 0xb2, 0xdd, 0x1d, 0xf3,
-        0xd5, 0xd9, 0xd8, 0x2c, 0xf2, 0x62, 0x9c, 0x63,
-        0xbf, 0x9b, 0x04, 0xb9, 0xe5, 0x77, 0x14, 0x18,
-        0x44, 0x89, 0xf4, 0x1a, 0x96, 0x5c, 0x8e, 0x1a,
-        0xae, 0xb9, 0x1c, 0x35, 0xac, 0x70, 0x4d, 0x62,
-        0x58, 0xe5, 0x4e, 0xcc, 0x7d, 0x8f, 0xd8, 0x54,
-        0x3f, 0x2b, 0x51, 0x45, 0x8d, 0xc6, 0xe3, 0x21,
-        0xb7, 0x02, 0x12, 0x4c, 0x31, 0x38, 0x50, 0xb2,
-        0xcf, 0x06, 0xc9, 0x78, 0x33, 0x88, 0x14, 0xdc,
-        0x60, 0x18, 0xe4, 0xc2, 0x43, 0xdb, 0xad, 0xa4,
-        0x21, 0xbb, 0x95, 0x34, 0x2c, 0xbb, 0x95, 0xc4,
-        0x8a, 0x6f, 0x32, 0x02, 0xc5, 0xb3, 0x1b, 0x0f,
-        0x78, 0x4c, 0x07, 0x4f, 0x4c, 0x32, 0x43, 0x22,
-        0x69, 0xaa, 0x20, 0xc1, 0x7c, 0x1b, 0xe2, 0x8e,
-        0x82, 0x2b, 0x9a, 0xe0, 0x1d, 0x80, 0x0f, 0x37,
-        0xa4, 0xf4, 0xb3, 0x44, 0xf2, 0xc9, 0x3c, 0x0b,
-        0x24, 0xa8, 0x25, 0xc1, 0xd1, 0x5c, 0xe2, 0x0b,
-        0x4c, 0x6b, 0xf5, 0xbc, 0x1c, 0x1f, 0x15, 0x6c,
-        0xd5, 0x7e, 0xa2, 0x5d, 0x53, 0xfb, 0x80, 0xc7,
-        0x07, 0xb4, 0x3f, 0xe9, 0x02, 0xe7, 0x35, 0x0e,
-        0x45, 0x8b, 0x7f, 0x36, 0xe7, 0x5e, 0xab, 0xd9,
-        0x69, 0x77, 0xde, 0xd4, 0xc9, 0xe7, 0x00, 0x7d,
-        0xbe, 0x6d, 0x1f, 0x77, 0xe8, 0x67, 0x82, 0x3e,
-        0x5b, 0x6f, 0x3b, 0x9d, 0x90, 0x4e, 0x6f, 0xf5,
-        0xd0, 0x22, 0x3f, 0x07, 0x4b, 0x18, 0x75, 0x92,
-        0x80, 0x18, 0xc1, 0x62, 0x87, 0xc3, 0x1d, 0xfa,
-        0xe2, 0x1f, 0x0c, 0x8a, 0xd1, 0xd4, 0x23, 0x19,
-        0x98, 0xbb, 0x5c, 0xe6, 0x70, 0x38, 0x34, 0x9b,
-        0xa2, 0xbe, 0x23, 0x07, 0x7a, 0xe1, 0xba, 0x0e,
-        0x69, 0x7f, 0xd0, 0x7e, 0x73, 0xf8, 0xee, 0x08,
-        0x02, 0xc0, 0x72, 0xa1, 0xe7, 0x8a, 0xea, 0xe5,
-        0x92, 0x20, 0xb6, 0x41, 0xd8, 0x36, 0x74, 0x01,
-        0xe8, 0x42, 0x54, 0x53, 0x92, 0x25, 0x3a, 0xa1,
-        0x5e, 0x84, 0x02, 0x8c, 0xbe, 0x84, 0x91, 0x84,
-        0x84, 0xa0, 0xc3, 0xb0, 0xaa, 0xfd, 0x10, 0xc1,
-        0xdd, 0x8e, 0xda, 0x7f, 0x24, 0x08, 0x2f, 0x62,
-        0x35, 0x16, 0x64, 0xaa, 0x5b, 0x77, 0x0c, 0xa9,
-        0x1e, 0x69, 0x9e, 0x93, 0xd7, 0x31, 0x1b, 0x78,
-        0xb3, 0xec, 0xc6, 0x21, 0xe3, 0x15, 0xb4, 0x8f,
-        0x5b, 0xf4, 0x24, 0xa8, 0x0f, 0x2d, 0x41, 0x83,
-        0x81, 0x3e, 0xde, 0xbf, 0xf3, 0xcd, 0x2d, 0x02,
-        0x5a, 0x71, 0xc8, 0xdd, 0x2e, 0x1d, 0xcc, 0x3a,
-        0xed, 0x39, 0x36, 0xb6, 0x32, 0x95, 0xf2, 0x72,
-        0xd2, 0x9c, 0x53, 0xf4, 0x50, 0xd7, 0xa1, 0x8c,
-        0x9d, 0x66, 0xbb, 0x74, 0x60, 0x29, 0xe2, 0x81,
-        0x8a, 0x78, 0x60, 0x47, 0x3c, 0x28, 0x47, 0x3c,
-        0xd0, 0x10, 0x27, 0x2a, 0xe2, 0xc4, 0x8e, 0x38,
-        0x29, 0x47, 0x9c, 0x50, 0xc4, 0xd2, 0x2d, 0x06,
-        0x65, 0x5d, 0x2a, 0xb9, 0x5d, 0x2b, 0xad, 0x5c,
-        0xcf, 0xd6, 0xe3, 0xa6, 0x2e, 0x35, 0xec, 0x54,
-        0xad, 0xd1, 0x1f, 0xb7, 0x7e, 0xa1, 0x7f, 0x44,
-        0x2d, 0xe3, 0x1e, 0x3a, 0x44, 0xf5, 0xed, 0x17,
-        0x18, 0x55, 0x5a, 0xef, 0xe0, 0x01, 0x14, 0x0e,
-        0x25, 0xb8, 0x1d, 0x2c, 0x63, 0xa6, 0x10, 0x1f,
-        0x06, 0x3d, 0x44, 0x0d, 0xf1, 0xf1, 0xe0, 0x6a,
-        0x88, 0x4c, 0xd6, 0x50, 0xbd, 0xa2, 0x2d, 0x15,
-        0x35, 0xeb, 0x27, 0x0a, 0x69, 0x95, 0x16, 0xc7,
-        0xbd, 0x37, 0xf3, 0x29, 0xbc, 0x99, 0x98, 0x4b,
-        0x37, 0x52, 0xbd, 0x34, 0x9e, 0xdc, 0x4c, 0xf3,
-        0xda, 0x5c, 0xdb, 0x2a, 0x70, 0x5a, 0xb4, 0x0d,
-        0x3f, 0xed, 0xdd, 0xa5, 0x2f, 0xe7, 0x94, 0x45,
-        0x99, 0x0a, 0x4b, 0x6f, 0x90, 0xf4, 0x07, 0x29,
-        0xbf, 0xb3, 0x25, 0x83, 0xbc, 0x7e, 0x3f, 0xeb,
-        0x43, 0xe8, 0xf0, 0x24, 0xe7, 0x36, 0xb2, 0xe8,
-        0xea, 0x6b, 0x75, 0xfc, 0x5b, 0x7e, 0xcc, 0x05,
-        0xbc, 0x34, 0x0c, 0x77, 0x04, 0x7b, 0x90, 0xb5,
-        0xbf, 0xff, 0xbd, 0xc6, 0x34, 0xd5, 0x08, 0x14,
-        0x55, 0x29, 0xe1, 0x16, 0x41, 0x10, 0x25, 0xfa,
-        0xe0, 0x27, 0xb2, 0x2e, 0x1f, 0x7c, 0x20, 0x2f,
-        0x3c, 0xc8, 0xe3, 0xe9, 0xdf, 0x7a, 0x9a, 0x92,
-        0xb1, 0x93, 0x23, 0x27, 0xbb, 0x39, 0x70, 0x42,
-        0x6b, 0x61, 0xaa, 0x83, 0xc5, 0x98, 0xa9, 0x68,
-        0x8d, 0x1c, 0x3e, 0x84, 0x35, 0x02, 0x57, 0x16,
-        0x5f, 0x8b, 0x09, 0xc2, 0xba, 0xb5, 0x39, 0x1f,
-        0x70, 0xad, 0xde, 0xa6, 0xcd, 0x63, 0xcc, 0x38,
-        0xac, 0x1c, 0x34, 0xc5, 0xa7, 0xbf, 0x0e, 0xdd,
-        0x82, 0x5e, 0x4f, 0xf3, 0xda, 0xe4, 0x69, 0x91,
-        0xdd, 0xbb, 0xf9, 0xb7, 0xd1, 0x3a, 0x1f, 0x57,
-        0x7d, 0xdc, 0x95, 0x0e, 0xf8, 0xba, 0xf7, 0x15,
-        0xf0, 0x40, 0xad, 0xd7, 0xa5, 0xac, 0xa3, 0x50,
-        0x4d, 0x2f, 0xda, 0xef, 0x46, 0xec, 0x77, 0x23,
-        0xb6, 0xde, 0x8d, 0xa0, 0x8f, 0x03, 0x2d, 0xe9,
-        0x73, 0x3d, 0xf6, 0x0d, 0x89, 0xc2, 0xbe, 0x05,
-        0x2d, 0xe1, 0x69, 0xf2, 0x6a, 0x1f, 0x8e, 0xc6,
-        0x78, 0x0c, 0xb4, 0x6a, 0xbc, 0x19, 0xa5, 0x9f,
-        0x6c, 0x41, 0x67, 0x1e, 0x2a, 0x60, 0x4c, 0xa5,
-        0x2e, 0xef, 0x8f, 0x26, 0xb0, 0x0c, 0x67, 0xd3,
-        0xb0, 0x5a, 0x64, 0x0b, 0x4a, 0xf4, 0x43, 0x8c,
-        0x89, 0x1c, 0xd6, 0x81, 0x04, 0xbc, 0x9a, 0x2d,
-        0x46, 0x63, 0x04, 0x0b, 0xc1, 0xcc, 0x64, 0xca,
-        0xe8, 0xc5, 0x71, 0x6c, 0x64, 0x38, 0x52, 0x06,
-        0xd2, 0xc9, 0x41, 0x1b, 0x0e, 0x94, 0x24, 0x76,
-        0x16, 0x58, 0x21, 0x35, 0x78, 0xd7, 0x7e, 0x8f,
-        0xa3, 0x77, 0x61, 0x24, 0x75, 0x5a, 0x51, 0xc9,
-        0xab, 0x4a, 0xda, 0xcb, 0x71, 0x4a, 0xe8, 0xaa,
-        0x2a, 0xba, 0x80, 0xbd, 0x9b, 0x75, 0xd6, 0xb9,
-        0xcd, 0x90, 0x70, 0x2e, 0x3c, 0xaf, 0x12, 0x2f,
-        0x71, 0x3a, 0xf9, 0x46, 0xca, 0xec, 0xe9, 0x38,
-        0xbd, 0x06, 0xfd, 0x73, 0xea, 0xd0, 0x48, 0xcf,
-        0x48, 0x08, 0xf8, 0x74, 0xd9, 0x19, 0xc5, 0x0b,
-        0x16, 0x52, 0x03, 0x87, 0xda, 0x2d, 0xf2, 0x15,
-        0x91, 0x60, 0x1e, 0x0e, 0x10, 0xc7, 0x1f, 0xa0,
-        0xc2, 0x81, 0x20, 0xe7, 0x75, 0xfc, 0x67, 0x40,
-        0x1f, 0xaf, 0xc2, 0x1f, 0x09, 0xf9, 0x20, 0xff,
-        0xba, 0x01, 0xd2, 0xf6, 0x91, 0x6a, 0x56, 0x78,
-        0x8f, 0xa5, 0x7c, 0xb0, 0xb0, 0xa6, 0x2f, 0x11,
-        0x0d, 0x7d, 0x52, 0xc7, 0x96, 0x42, 0x83, 0x16,
-        0x44, 0xa6, 0x0c, 0xff, 0xb9, 0xc2, 0xaa, 0x2f,
-        0x53, 0x9b, 0x13, 0x6b, 0xd9, 0x96, 0xad, 0x48,
-        0xcf, 0x5a, 0x64, 0x6d, 0x6d, 0xfd, 0x2a, 0x94,
-        0xb6, 0x94, 0x22, 0xa9, 0xa1, 0x88, 0x9c, 0x7f,
-        0x59, 0x81, 0x1a, 0x15, 0xe3, 0xa0, 0x0a, 0x11,
-        0x66, 0xfa, 0x87, 0x25, 0xbd, 0x65, 0x2e, 0x31,
-        0xaa, 0x40, 0x9e, 0xb9, 0x64, 0xba, 0x8c, 0x07,
-        0x83, 0x14, 0xc7, 0xdd, 0x80, 0x19, 0x0d, 0x2c,
-        0x5a, 0xfb, 0x47, 0xad, 0x83, 0x0d, 0xd0, 0x56,
-        0xf3, 0x08, 0x59, 0x9f, 0x3c, 0xf1, 0xa8, 0x79,
-        0x8c, 0x13, 0x0f, 0x8f, 0x51, 0x2a, 0xfa, 0x43,
-        0xcd, 0xec, 0x74, 0x3e, 0xba, 0xa6, 0xd6, 0x75,
-        0xaf, 0x7e, 0x89, 0xfe, 0x1b, 0xb9, 0x0d, 0x27,
-        0xae, 0xf7, 0xd1, 0x7f, 0x03, 0xd7, 0x77, 0x06,
-        0xf5, 0x21, 0xfa, 0x8f, 0xa4, 0x25, 0xe8, 0xbf,
-        0x9e, 0xeb, 0x06, 0x35, 0xb0, 0x2b, 0x50, 0x1d,
-        0xbe, 0x43, 0x90, 0x37, 0xf8, 0xf4, 0x80, 0x38,
-        0x13, 0x82, 0xa0, 0x7a, 0xfb, 0x7d, 0x13, 0xb1,
-        0x6c, 0xa7, 0x41, 0xc0, 0xf4, 0x50, 0x5c, 0xd8,
-        0x96, 0xc0, 0xc2, 0x07, 0x13, 0xd1, 0x5c, 0xc2,
-        0x5d, 0x00, 0x88, 0xf5, 0xe2, 0x93, 0xef, 0x15,
-        0xff, 0x66, 0xf1, 0xd7, 0x84, 0x39, 0xf6, 0x08,
-        0x2b, 0xdf, 0x13, 0x49, 0x5b, 0x22, 0x1c, 0x4d,
-        0xb2, 0xb1, 0x7c, 0xc1, 0x5b, 0x2f, 0xe1, 0xc6,
-        0xa8, 0xc2, 0x78, 0x2a, 0xad, 0x8d, 0x2c, 0x1d,
-        0x2b, 0xb4, 0xfa, 0x2e, 0xc3, 0x30, 0xee, 0x67,
-        0x37, 0x7a, 0x2a, 0x08, 0x5d, 0x23, 0x78, 0xdc,
-        0x83, 0x88, 0x30, 0x22, 0x08, 0xe0, 0xf9, 0x59,
-        0xed, 0xb0, 0xd9, 0x3e, 0x6a, 0x1f, 0xbf, 0xef,
-        0xbc, 0x39, 0x3e, 0x3c, 0x7e, 0xf7, 0xfe, 0xed,
-        0xfb, 0xc3, 0x03, 0x43, 0x80, 0x21, 0x30, 0xef,
-        0xad, 0xcb, 0xac, 0xcc, 0x91, 0x0e, 0x79, 0xf0,
-        0x0f, 0x99, 0x9d, 0x10, 0xdf, 0xd1, 0x95, 0x03,
-        0x3c, 0xe2, 0x15, 0xe3, 0x33, 0x09, 0xc8, 0xd3,
-        0xcb, 0x16, 0x38, 0xc6, 0x6c, 0x3c, 0x5d, 0x38,
-        0x8e, 0x68, 0xf2, 0x5f, 0xad, 0xef, 0x0d, 0xe9,
-        0xab, 0xfd, 0xdd, 0xf5, 0xb0, 0x25, 0x4d, 0xd5,
-        0x0a, 0xb7, 0xae, 0x66, 0x72, 0xcc, 0xe3, 0x6c,
-        0x96, 0x46, 0x48, 0xe2, 0x4e, 0x11, 0x74, 0xe7,
-        0xd8, 0xa3, 0x47, 0xc5, 0x31, 0x45, 0x6e, 0x20,
-        0xd5, 0xcb, 0xcf, 0x89, 0xe3, 0xd0, 0x37, 0x11,
-        0xe5, 0x5f, 0x62, 0xc3, 0xa3, 0x49, 0x86, 0x31,
-        0x50, 0x26, 0xf6, 0x1b, 0x34, 0xd7, 0x45, 0xd3,
-        0xee, 0xfc, 0x0c, 0xdf, 0x77, 0x61, 0x79, 0xdc,
-        0x57, 0x04, 0x5e, 0x9e, 0x0f, 0x72, 0x1b, 0xb9,
-        0x2d, 0x1e, 0xd1, 0xf1, 0xe2, 0xfe, 0xc0, 0xf8,
-        0x76, 0x34, 0xb9, 0xc2, 0xa1, 0x8f, 0x49, 0xfa,
-        0xaa, 0x7e, 0x7e, 0x16, 0x4a, 0xe6, 0x4e, 0xbb,
-        0xf9, 0xee, 0xed, 0x71, 0x43, 0xc4, 0x39, 0x6c,
-        0x37, 0xdf, 0x1e, 0xd3, 0x7c, 0x34, 0x49, 0xc9,
-        0x7b, 0xa5, 0x10, 0x4f, 0x89, 0x97, 0x22, 0x81,
-        0x2e, 0x2f, 0x70, 0xd3, 0x79, 0x31, 0xdc, 0x14,
-        0x90, 0x17, 0x68, 0x1c, 0xd0, 0x64, 0xc7, 0x5e,
-        0x6b, 0xdc, 0x3b, 0x64, 0x24, 0x02, 0x91, 0xca,
-        0x90, 0x92, 0x0c, 0xd7, 0x63, 0xdf, 0x10, 0x33,
-        0x18, 0x0a, 0x30, 0xb2, 0x31, 0xc3, 0xe0, 0xf1,
-        0x92, 0x2a, 0x64, 0x9b, 0xcc, 0x38, 0x93, 0x6e,
-        0x46, 0xe3, 0x81, 0x22, 0x29, 0xa0, 0x78, 0x91,
-        0x5f, 0xd4, 0xb3, 0x21, 0x9a, 0xd5, 0x29, 0x3a,
-        0x77, 0x80, 0x85, 0x49, 0x44, 0x19, 0xd0, 0xf1,
-        0x1d, 0x32, 0x36, 0x75, 0xda, 0x5f, 0x6e, 0x70,
-        0x7e, 0x86, 0x65, 0x89, 0xe0, 0x26, 0x12, 0xa2,
-        0x1a, 0x0a, 0xd1, 0x9a, 0xc9, 0xcb, 0x60, 0x64,
-        0x26, 0xf8, 0x12, 0xf3, 0xfb, 0x18, 0x08, 0xa9,
-        0x2a, 0x88, 0x93, 0x65, 0xe2, 0xcb, 0x89, 0x52,
-        0xe4, 0x90, 0xdc, 0x42, 0xc2, 0x8a, 0x52, 0xc5,
-        0xcd, 0xd8, 0xad, 0x4b, 0x9f, 0xf7, 0x13, 0x6e,
-        0x7c, 0x4a, 0x9e, 0x7c, 0xf9, 0xed, 0xec, 0xe4,
-        0x97, 0xb3, 0x93, 0x8b, 0xb3, 0x2f, 0x3f, 0xd7,
-        0x2c, 0x0f, 0x04, 0x20, 0x82, 0x39, 0x3c, 0x6e,
-        0x19, 0x0e, 0xfa, 0x7c, 0xfc, 0xee, 0xed, 0x61,
-        0xab, 0xfd, 0xe6, 0xa0, 0xb0, 0xc3, 0x07, 0x56,
-        0x13, 0x71, 0x58, 0x15, 0x77, 0xff, 0x70, 0x90,
-        0xf4, 0x72, 0x05, 0xb7, 0x18, 0xda, 0x17, 0xc2,
-        0x45, 0x69, 0xd2, 0x09, 0xb5, 0x50, 0x7f, 0xd7,
-        0x50, 0x13, 0x75, 0x94, 0x02, 0x2d, 0x15, 0xc7,
-        0x02, 0xea, 0x14, 0x22, 0x45, 0x0d, 0xe2, 0xc9,
-        0x24, 0x66, 0xa1, 0x9f, 0x0c, 0x01, 0x53, 0xc1,
-        0x9a, 0x9a, 0xa6, 0x8b, 0xec, 0x32, 0x9e, 0xbf,
-        0xb8, 0x30, 0x3a, 0xfb, 0xa7, 0xbe, 0xb6, 0x38,
-        0x66, 0x3b, 0x88, 0x67, 0x25, 0x4f, 0x65, 0xb1,
-        0xdc, 0xb2, 0xb8, 0xd5, 0x0c, 0x66, 0x5d, 0xe4,
-        0x6a, 0x19, 0xae, 0xac, 0xcb, 0xf0, 0xeb, 0xb2,
-        0x96, 0x1e, 0xc3, 0x79, 0xf6, 0x0e, 0xc3, 0xd9,
-        0xe5, 0x9d, 0xc2, 0x41, 0x4a, 0x48, 0x28, 0xe9,
-        0x90, 0xb5, 0xbd, 0x51, 0xa9, 0x2b, 0xd4, 0x7e,
-        0x78, 0x7e, 0x21, 0x97, 0x5e, 0xfb, 0x83, 0x55,
-        0x9c, 0xe9, 0xd5, 0x81, 0x61, 0xc9, 0x06, 0x42,
-        0x58, 0x96, 0x2f, 0xcf, 0x09, 0x4b, 0x08, 0x6f,
-        0x81, 0x66, 0x43, 0x9e, 0x97, 0x5b, 0x44, 0x5e,
-        0x7c, 0x36, 0xf4, 0x08, 0xce, 0xf0, 0xc5, 0x5c,
-        0x30, 0xf6, 0x07, 0x2d, 0xbd, 0x09, 0xbb, 0xab,
-        0x6d, 0xb0, 0xf5, 0x03, 0xeb, 0x84, 0xf2, 0x1e,
-        0x60, 0xcd, 0xd7, 0xf8, 0x5c, 0x09, 0x2f, 0x1a,
-        0xc5, 0xec, 0xc5, 0x88, 0x46, 0xbb, 0xf3, 0x0e,
-        0xa9, 0xf7, 0x6c, 0x8a, 0xf1, 0xed, 0x94, 0x88,
-        0x04, 0x36, 0x27, 0xef, 0x41, 0xe0, 0xa0, 0x95,
-        0xa0, 0xa8, 0x84, 0xd2, 0x12, 0x15, 0xf1, 0x58,
-        0xe2, 0x04, 0x08, 0x5c, 0x01, 0x6e, 0x9d, 0x7e,
-        0xdd, 0x78, 0x6f, 0x8e, 0x68, 0x3c, 0x74, 0xe1,
-        0x61, 0x95, 0x17, 0x6d, 0xf0, 0xdd, 0x2a, 0xb3,
-        0x97, 0x6f, 0x08, 0x4b, 0x30, 0xe0, 0xbf, 0xa5,
-        0xbf, 0xe9, 0x36, 0x64, 0xc8, 0xc7, 0x97, 0xfd,
-        0x00, 0xbd, 0x81, 0x19, 0xbb, 0xf1, 0xf8, 0x92,
-        0x64, 0x8a, 0x1c, 0x3a, 0x1a, 0x40, 0xbc, 0x47,
-        0x07, 0x84, 0x69, 0xb5, 0x90, 0xce, 0xb0, 0xd4,
-        0x1d, 0xf6, 0x8b, 0xeb, 0xc1, 0x8a, 0xce, 0x02,
-        0x56, 0x2a, 0x57, 0xee, 0xb2, 0xab, 0x5c, 0x29,
-        0xcb, 0xeb, 0xf5, 0x8a, 0x58, 0x3a, 0xf8, 0xc5,
-        0x0a, 0x50, 0x8c, 0xea, 0x8e, 0xa0, 0x8f, 0xea,
-        0xe6, 0xe4, 0x39, 0x0b, 0xb9, 0x22, 0x57, 0xed,
-        0x14, 0x7c, 0x49, 0x94, 0x54, 0xe7, 0x89, 0xd8,
-        0x99, 0x44, 0x83, 0xd0, 0xe4, 0x1a, 0x56, 0xa4,
-        0xa5, 0x01, 0xd4, 0xf2, 0x73, 0xe2, 0xbe, 0x44,
-        0x0a, 0xe9, 0x95, 0x56, 0x07, 0xe9, 0x95, 0x4e,
-        0x44, 0xfe, 0xea, 0xd5, 0x78, 0x6c, 0x53, 0x10,
-        0x29, 0xd3, 0x39, 0x04, 0xb2, 0x6e, 0x5c, 0xf9,
-        0x57, 0xf0, 0x6a, 0xbb, 0xf6, 0xa4, 0x17, 0x63,
-        0x2c, 0xd5, 0xb6, 0x04, 0xfa, 0x03, 0xaa, 0x5c,
-        0xb1, 0x3d, 0xd0, 0xb2, 0x33, 0xa6, 0xe2, 0x85,
-        0xf3, 0x8e, 0x52, 0x0c, 0xf7, 0x5f, 0xa1, 0x32,
-        0x63, 0xbc, 0x49, 0xfc, 0xa6, 0x16, 0xea, 0x32,
-        0x39, 0x18, 0x28, 0xbb, 0x67, 0x4b, 0x6e, 0xcb,
-        0x5a, 0x4b, 0x99, 0x8a, 0x14, 0x2a, 0x2d, 0x84,
-        0x0e, 0xf0, 0x4c, 0x7a, 0x22, 0xd8, 0xd2, 0x92,
-        0xba, 0x17, 0xad, 0xa7, 0x31, 0x58, 0x43, 0x50,
-        0xc8, 0xd4, 0x4a, 0xe2, 0x20, 0x21, 0x4c, 0xe1,
-        0x63, 0x2e, 0x7e, 0xba, 0xf0, 0x78, 0x2f, 0xe8,
-        0xbd, 0xaa, 0x72, 0x15, 0xdd, 0xac, 0xce, 0x1b,
-        0x15, 0xf7, 0xc7, 0x0d, 0xe1, 0xb7, 0x9b, 0x97,
-        0x93, 0x4c, 0x57, 0xd0, 0x49, 0xdb, 0x5d, 0x8f,
-        0xf5, 0x4d, 0x73, 0x11, 0x0a, 0x12, 0x3a, 0x11,
-        0x7e, 0xf7, 0xa7, 0x6e, 0xb6, 0xdd, 0xa0, 0x90,
-        0xdc, 0x47, 0xf2, 0xc5, 0x75, 0x62, 0x97, 0x4e,
-        0x50, 0x7f, 0x41, 0x75, 0x0d, 0x87, 0xa3, 0xcf,
-        0x1b, 0x18, 0xb1, 0xeb, 0x8b, 0x0a, 0x71, 0xe4,
-        0x54, 0x37, 0xc0, 0xe9, 0x16, 0xe3, 0xf5, 0x11,
-        0x42, 0x65, 0x71, 0xab, 0xf3, 0xd7, 0x93, 0x3f,
-        0xbb, 0xbf, 0x9c, 0x7d, 0x39, 0xed, 0x7e, 0x3a,
-        0xbb, 0xf8, 0xed, 0xe4, 0xcb, 0xc7, 0xd3, 0xda,
-        0x61, 0xe7, 0xed, 0x9b, 0xb7, 0x92, 0x5d, 0xba,
-        0xb7, 0x63, 0xab, 0xdb, 0xb1, 0x48, 0x72, 0x0e,
-        0xe6, 0xe9, 0xc2, 0x1a, 0xc3, 0x64, 0x6f, 0x31,
-        0xee, 0x2d, 0xc6, 0xd7, 0x6a, 0x31, 0xee, 0x6d,
-        0xb8, 0xbd, 0x0d, 0xf7, 0xcc, 0x6d, 0x38, 0x26,
-        0x9e, 0xab, 0x9a, 0x71, 0x41, 0x61, 0x75, 0xdc,
-        0x1b, 0x76, 0x7b, 0xc3, 0x6e, 0x6f, 0xd8, 0x3d,
-        0x91, 0x61, 0xf7, 0x82, 0x2c, 0xaf, 0xca, 0xfb,
-        0xc6, 0xdb, 0xdb, 0x64, 0xeb, 0x95, 0xd0, 0x2a,
-        0x27, 0x36, 0xf7, 0xa6, 0x97, 0x6e, 0x7a, 0x59,
-        0x9e, 0x37, 0xa3, 0x1b, 0xe5, 0xc0, 0xae, 0x6a,
-        0x37, 0xdb, 0x9f, 0x39, 0x7b, 0x1c, 0x8b, 0xad,
-        0x68, 0x5f, 0xb1, 0x1c, 0x65, 0xa5, 0xea, 0x5e,
-        0x7c, 0x3c, 0xf9, 0xe5, 0xb4, 0xd6, 0xd9, 0xc2,
-        0x92, 0x7b, 0x68, 0x7b, 0xcd, 0x6e, 0x91, 0x95,
-        0x5b, 0x74, 0xf7, 0xb1, 0xd7, 0xc4, 0xae, 0x62,
-        0xd9, 0x24, 0xda, 0x9b, 0x69, 0x0f, 0x67, 0xa6,
-        0x3d, 0x03, 0xab, 0xe8, 0xd9, 0x59, 0x8a, 0x3b,
-        0x36, 0xd3, 0xf6, 0x97, 0x50, 0x9f, 0xd1, 0x25,
-        0xd4, 0x57, 0x6e, 0x0e, 0x3f, 0xad, 0xf9, 0xf9,
-        0xdc, 0x8c, 0xf1, 0x5d, 0x99, 0xc3, 0xff, 0x6f,
-        0xae, 0x05, 0xdf, 0xdf, 0xe4, 0x67, 0x70, 0x9b,
-        0x6d, 0xde, 0x1a, 0x74, 0xa8, 0xbd, 0xcd, 0xbf,
-        0xb7, 0xf9, 0xf7, 0x36, 0xff, 0x43, 0xd8, 0xfc,
-        0x62, 0x2a, 0xc6, 0xb2, 0x82, 0x5e, 0xee, 0x0b,
-        0xd8, 0xe6, 0x72, 0xaa, 0x22, 0x6f, 0xf4, 0x10,
-        0x2e, 0x6b, 0x6d, 0xf2, 0xdd, 0x19, 0x1a, 0xaf,
-        0xe5, 0x6e, 0xe8, 0xcb, 0xdf, 0x29, 0x5f, 0xef,
-        0x2a, 0x79, 0x46, 0x97, 0x4c, 0x9f, 0xd0, 0x95,
-        0xb3, 0x0f, 0x71, 0xfc, 0xba, 0x1e, 0x3e, 0x91,
-        0xbb, 0x5a, 0x6e, 0x9f, 0xda, 0xe6, 0xe6, 0xd2,
-        0xe3, 0xbd, 0x16, 0xa8, 0xc1, 0x82, 0x35, 0xc0,
-        0x95, 0x09, 0x67, 0x62, 0xc0, 0x89, 0xa8, 0xf6,
-        0x68, 0x7f, 0x97, 0x61, 0x04, 0x8a, 0xc3, 0x17,
-        0xe5, 0x3f, 0x24, 0xd8, 0x96, 0xa8, 0x23, 0xc9,
-        0x55, 0x67, 0xbe, 0x40, 0x04, 0x6a, 0x3f, 0x37,
-        0x97, 0x2a, 0x7c, 0x52, 0x0e, 0x9f, 0xa8, 0xf0,
-        0xab, 0x2e, 0x7e, 0x31, 0xb9, 0xce, 0x7b, 0x02,
-        0x29, 0x38, 0xf4, 0x46, 0x17, 0xa7, 0x0f, 0xd3,
-        0xe4, 0x68, 0xb5, 0xae, 0xea, 0x1d, 0xfa, 0xec,
-        0x8b, 0xab, 0x13, 0xb4, 0x12, 0xc8, 0x93, 0x6d,
-        0x90, 0x27, 0x76, 0xe4, 0x89, 0x60, 0x0c, 0x1c,
-        0xf5, 0x64, 0xf3, 0x8b, 0xe7, 0x98, 0x83, 0x50,
-        0xaf, 0xfa, 0xa8, 0xe5, 0xae, 0x84, 0x2b, 0xd9,
-        0xe2, 0xda, 0x38, 0xc5, 0x95, 0x20, 0x5c, 0x89,
-        0xab, 0x78, 0x7c, 0x01, 0x97, 0xf1, 0xea, 0x38,
-        0xaa, 0xd4, 0x37, 0x67, 0x24, 0xae, 0xf9, 0xca,
-        0x38, 0xf1, 0x01, 0x3f, 0xe0, 0xfb, 0x13, 0x2f,
-        0xd8, 0x03, 0x5c, 0xe9, 0xc4, 0x0e, 0x1d, 0x2c,
-        0xf2, 0x6c, 0x75, 0x5c, 0x50, 0xf0, 0x50, 0xef,
-        0x77, 0x57, 0x52, 0xba, 0xa9, 0x54, 0x62, 0x29,
-        0x95, 0x3c, 0xd2, 0xe9, 0x20, 0x9a, 0x0a, 0x95,
-        0xc4, 0xa6, 0xc4, 0x64, 0x1b, 0xa5, 0x70, 0x7f,
-        0xdf, 0x65, 0x7f, 0x7a, 0x69, 0x7f, 0x7a, 0xa9,
-        0xdc, 0x2d, 0xce, 0x86, 0xcc, 0xe0, 0x33, 0x7b,
-        0x08, 0x97, 0x39, 0x76, 0x14, 0x95, 0x50, 0x29,
-        0xf2, 0xad, 0x7d, 0x25, 0x40, 0x4c, 0xfc, 0x25,
-        0xe5, 0x96, 0xf5, 0xa6, 0x0a, 0xb6, 0xbf, 0xbc,
-        0xb3, 0x3f, 0xf8, 0xf5, 0x4c, 0x0e, 0x7e, 0xed,
-        0xce, 0xb7, 0x2d, 0x4d, 0x45, 0xf1, 0xd3, 0x50,
-        0xb3, 0xc8, 0xf4, 0xd5, 0xf9, 0x69, 0x6a, 0xb2,
-        0x8c, 0xc9, 0x38, 0xc9, 0xf6, 0x2e, 0xe8, 0xbd,
-        0x0b, 0x7a, 0xef, 0x82, 0x7e, 0x85, 0x2e, 0x68,
-        0xac, 0xaa, 0x47, 0x54, 0x66, 0xf0, 0x79, 0xe9,
-        0xe9, 0xd6, 0x47, 0x73, 0x19, 0x48, 0x02, 0x85,
-        0x8f, 0x5f, 0x01, 0x6c, 0x55, 0xe7, 0x86, 0x89,
-        0x4b, 0xb1, 0x27, 0x6b, 0xb1, 0x27, 0xd5, 0xb0,
-        0x27, 0x12, 0x76, 0x88, 0x6e, 0x56, 0xcd, 0x4d,
-        0xbe, 0x3e, 0x34, 0xd7, 0xa2, 0x7f, 0x89, 0xbb,
-        0xb5, 0x18, 0x63, 0x09, 0x59, 0x6c, 0xcf, 0xcc,
-        0x0a, 0xda, 0xdf, 0xe2, 0x2a, 0x5f, 0x87, 0x77,
-        0xa7, 0x07, 0x3f, 0xae, 0x12, 0xfb, 0x12, 0x2f,
-        0x94, 0x19, 0x31, 0x94, 0x1c, 0x04, 0x28, 0xf6,
-        0x78, 0x69, 0x87, 0x6f, 0xa0, 0xae, 0xbc, 0x40,
-        0xff, 0x28, 0x12, 0x42, 0x90, 0xdb, 0x8d, 0x8d,
-        0xd1, 0x88, 0xb0, 0x28, 0x71, 0x9b, 0xb1, 0x06,
-        0x9c, 0x58, 0x81, 0x93, 0x02, 0x30, 0x76, 0xe5,
-        0xf1, 0x5a, 0x7c, 0x8e, 0xc2, 0xc7, 0x72, 0xce,
-        0x0d, 0x89, 0x63, 0x2e, 0x52, 0xde, 0x97, 0x3d,
-        0x6e, 0x08, 0xe9, 0x28, 0x4b, 0x68, 0x12, 0x50,
-        0xd8, 0x94, 0x43, 0xd1, 0x3e, 0xfe, 0xf1, 0xcf,
-        0x4a, 0x27, 0x2c, 0xf3, 0x31, 0x5a, 0x41, 0xe6,
-        0xf2, 0x63, 0x14, 0x5c, 0xe6, 0xe3, 0x15, 0xc5,
-        0x92, 0x99, 0x5c, 0x5d, 0x5e, 0xa6, 0xf3, 0xb2,
-        0x87, 0x67, 0x37, 0x0c, 0xc3, 0xd5, 0x32, 0xa4,
-        0xb5, 0xb7, 0x8d, 0xcd, 0xd5, 0x8a, 0x1c, 0xc7,
-        0x1c, 0xbb, 0xb0, 0x01, 0x27, 0x6f, 0x03, 0x95,
-        0xfe, 0x9a, 0x0b, 0x51, 0x86, 0x48, 0xc9, 0x76,
-        0x44, 0x42, 0xb9, 0xc1, 0x03, 0xe7, 0x72, 0x07,
-        0x40, 0xf8, 0x29, 0xd1, 0x55, 0x52, 0xe7, 0xca,
-        0x7b, 0xc9, 0xdd, 0xdc, 0x1a, 0xd3, 0xd2, 0xba,
-        0xd4, 0xb6, 0xec, 0x59, 0xed, 0xca, 0xdd, 0x54,
-        0x18, 0x9d, 0x39, 0xc4, 0x40, 0x42, 0xaa, 0xc4,
-        0x02, 0x22, 0x72, 0x97, 0x65, 0x83, 0xb0, 0x2c,
-        0x8e, 0x7c, 0x8c, 0xba, 0x0d, 0x87, 0x83, 0xd3,
-        0xdf, 0x37, 0x61, 0x10, 0xbd, 0x6c, 0x9a, 0xcf,
-        0xe3, 0x85, 0xe9, 0xfd, 0x13, 0x78, 0xa9, 0x64,
-        0x31, 0x1b, 0x4d, 0xbb, 0x37, 0x38, 0x0a, 0xaf,
-        0x76, 0xa4, 0x5c, 0x88, 0xe5, 0x56, 0x71, 0x62,
-        0xb6, 0x48, 0x50, 0xb1, 0xd6, 0x9a, 0x30, 0xb1,
-        0x6d, 0x02, 0xd6, 0x26, 0xd1, 0xb8, 0x09, 0xb2,
-        0x66, 0x4c, 0x54, 0x7f, 0x54, 0x05, 0x4d, 0x98,
-        0x0f, 0x92, 0x48, 0xfc, 0x0c, 0x18, 0x58, 0x78,
-        0xc7, 0x0b, 0xb5, 0xf5, 0x42, 0x6d, 0x51, 0xa8,
-        0x2d, 0x0a, 0xb5, 0xa1, 0x90, 0xe6, 0xef, 0x27,
-        0xd8, 0x7c, 0x1a, 0x05, 0x96, 0x8d, 0x3e, 0x7d,
-        0x54, 0xa9, 0x89, 0x64, 0x84, 0x14, 0xcd, 0x14,
-        0xba, 0x84, 0xe3, 0x05, 0xb4, 0x21, 0x7c, 0xe1,
-        0x68, 0xda, 0x10, 0xc9, 0x1c, 0x7d, 0xf8, 0x6a,
-        0x8f, 0x41, 0x84, 0x7f, 0xd7, 0xb7, 0xe4, 0xdd,
-        0x2e, 0x57, 0xd6, 0xbc, 0xd5, 0xed, 0x92, 0xc7,
-        0x45, 0x8b, 0xaf, 0x53, 0x24, 0x1d, 0xd2, 0x88,
-        0xbd, 0x40, 0xc4, 0x9e, 0x95, 0x62, 0xef, 0x49,
-        0xb9, 0xc1, 0x21, 0x84, 0xb1, 0x84, 0x08, 0xe1,
-        0x0e, 0x85, 0x6d, 0xa0, 0x2f, 0x08, 0xdf, 0x55,
-        0x1c, 0x7e, 0x20, 0x18, 0x2a, 0xc4, 0xb3, 0xc7,
-        0x2b, 0x0c, 0x3f, 0x99, 0x3e, 0x64, 0xe8, 0x81,
-        0xa1, 0xc0, 0xbe, 0x26, 0x0d, 0xd4, 0x59, 0xd1,
-        0x5f, 0x9b, 0xe0, 0x32, 0x44, 0xe8, 0xb7, 0x05,
-        0x0f, 0x54, 0xe1, 0x57, 0x48, 0xd1, 0x24, 0x2c,
-        0x96, 0x14, 0x24, 0x5e, 0x18, 0x23, 0xd2, 0xe7,
-        0xd5, 0xf8, 0xb8, 0xed, 0x74, 0xf8, 0x7c, 0x16,
-        0xe2, 0xeb, 0x7e, 0xf2, 0x17, 0xf5, 0xd2, 0x22,
-        0xa7, 0x53, 0xe6, 0xfc, 0x2c, 0x2a, 0x04, 0xdb,
-        0x0b, 0x8d, 0x5b, 0x26, 0xd4, 0x5a, 0x36, 0x6f,
-        0x99, 0x28, 0xa9, 0x87, 0x50, 0x82, 0xdb, 0x49,
-        0xaa, 0xcc, 0xe5, 0x5e, 0x47, 0x60, 0x4c, 0x5d,
-        0x08, 0x25, 0x59, 0x36, 0x06, 0x21, 0xb3, 0x20,
-        0x1b, 0x6d, 0x10, 0xe8, 0xb1, 0x8b, 0x89, 0x8d,
-        0x25, 0x49, 0xaf, 0x01, 0x5d, 0xa6, 0x31, 0x96,
-        0xa5, 0x05, 0x38, 0xf5, 0x05, 0x3e, 0x0c, 0x5b,
-        0x96, 0x69, 0xc9, 0xea, 0xc5, 0x13, 0xc4, 0x83,
-        0x60, 0xc8, 0x41, 0xd0, 0x35, 0x24, 0x99, 0xd9,
-        0x3b, 0x08, 0x16, 0xf8, 0xd9, 0x28, 0xef, 0x0d,
-        0x75, 0x5a, 0xe7, 0x59, 0x1e, 0xe7, 0x69, 0x77,
-        0xb1, 0x9a, 0x24, 0xd9, 0xd8, 0x52, 0x90, 0x84,
-        0x98, 0xd3, 0x76, 0x93, 0x14, 0x21, 0xde, 0x1b,
-        0xe2, 0x08, 0x8c, 0x2f, 0x60, 0xf7, 0x60, 0xcd,
-        0x06, 0x1a, 0x49, 0x1d, 0xc7, 0x49, 0x8a, 0x16,
-        0xae, 0x71, 0x3c, 0x4d, 0x2d, 0x10, 0x03, 0xf6,
-        0x7a, 0x83, 0x96, 0x2d, 0x38, 0x00, 0x44, 0xb0,
-        0x9e, 0x8c, 0x47, 0x80, 0x98, 0xcb, 0x93, 0x78,
-        0x16, 0x5a, 0x8e, 0x5c, 0x15, 0x4d, 0xbb, 0x82,
-        0x61, 0xa7, 0xb0, 0xe8, 0x33, 0x79, 0x79, 0x5c,
-        0xe8, 0x31, 0x91, 0x3c, 0x2b, 0xf9, 0x49, 0x13,
-        0xe6, 0x1d, 0x55, 0x73, 0xd9, 0x39, 0x15, 0xac,
-        0x79, 0x08, 0x0f, 0x20, 0x4b, 0x84, 0x0e, 0x61,
-        0xa9, 0x08, 0x54, 0xe6, 0xcb, 0x45, 0x3a, 0x98,
-        0x40, 0xb0, 0x41, 0xc4, 0x79, 0xe3, 0x34, 0x6a,
-        0x68, 0xf3, 0xfa, 0xaf, 0xce, 0x77, 0xa6, 0xa8,
-        0x42, 0x9f, 0xc2, 0x02, 0xf6, 0x83, 0x65, 0xfa,
-        0xc2, 0x3b, 0x23, 0x3f, 0xd8, 0x67, 0x2d, 0xea,
-        0x54, 0x4c, 0x05, 0x88, 0x41, 0x42, 0xd0, 0x5f,
-        0xad, 0xef, 0x3e, 0xfd, 0xd5, 0xfe, 0xee, 0xb3,
-        0x09, 0xec, 0x06, 0x38, 0x6e, 0x71, 0x78, 0x57,
-        0x83, 0x3e, 0xab, 0x41, 0x8d, 0xf7, 0xab, 0x90,
-        0x57, 0x56, 0x44, 0x5c, 0xd6, 0x94, 0xf5, 0x88,
-        0xa9, 0x54, 0xa1, 0xf8, 0xd4, 0x34, 0xd5, 0x57,
-        0x76, 0x9e, 0x8d, 0xa6, 0xf9, 0xba, 0x10, 0xda,
-        0x34, 0x12, 0x32, 0x97, 0x46, 0x48, 0x04, 0x0d,
-        0x33, 0x21, 0x8d, 0x22, 0x15, 0x5b, 0x53, 0x1d,
-        0x45, 0x06, 0x45, 0xa4, 0x4b, 0xa4, 0xcf, 0x91,
-        0xda, 0x4f, 0x07, 0x56, 0xc4, 0x41, 0x89, 0x08,
-        0xac, 0x7d, 0x38, 0x28, 0xc9, 0x0d, 0xac, 0x38,
-        0x15, 0xda, 0x24, 0x97, 0x16, 0x25, 0x8f, 0x98,
-        0x65, 0x60, 0xa7, 0x80, 0x0b, 0x53, 0xa5, 0x1d,
-        0x9b, 0x5e, 0xe0, 0x59, 0x0e, 0xa1, 0x27, 0xbd,
-        0xa8, 0x50, 0x9a, 0x9d, 0x8b, 0x42, 0x8a, 0x00,
-        0x3b, 0xff, 0x44, 0xe5, 0x44, 0xed, 0x27, 0xcc,
-        0xa5, 0x41, 0xe7, 0x08, 0x7b, 0x59, 0xf1, 0x48,
-        0x28, 0xac, 0x8e, 0xa5, 0x33, 0x91, 0xd5, 0xa0,
-        0xc9, 0xa3, 0x9a, 0x42, 0xc2, 0x5f, 0x8a, 0xf8,
-        0x66, 0xba, 0x22, 0x99, 0x5a, 0xe7, 0x6b, 0x07,
-        0x91, 0xc4, 0x5e, 0x6e, 0xe3, 0x90, 0xd0, 0xfc,
-        0x5d, 0x9e, 0x58, 0x1f, 0xaf, 0xe5, 0x2a, 0x28,
-        0x8c, 0x20, 0x86, 0x4c, 0x22, 0x53, 0x45, 0x00,
-        0x6f, 0x4c, 0xbf, 0x09, 0xf5, 0x66, 0xe0, 0xf8,
-        0xb1, 0x0e, 0x9c, 0x9d, 0xc2, 0x07, 0xb4, 0xd4,
-        0x85, 0xc6, 0x87, 0xe3, 0x57, 0x70, 0xc6, 0x2b,
-        0xbc, 0x93, 0xbb, 0x02, 0xcf, 0x76, 0xc4, 0xab,
-        0xd3, 0x08, 0x87, 0x29, 0x95, 0x65, 0x40, 0x5d,
-        0xc3, 0xaf, 0xf2, 0x27, 0x29, 0xd8, 0x43, 0xd2,
-        0x09, 0x07, 0x67, 0x2d, 0x2f, 0x08, 0x0e, 0xe4,
-        0x1a, 0xfb, 0xa4, 0x1d, 0x17, 0x61, 0xaf, 0x32,
-        0x47, 0xe3, 0x63, 0x3f, 0x3d, 0x27, 0xc7, 0xd7,
-        0x7f, 0xf5, 0x68, 0xa4, 0x5f, 0xd9, 0xf3, 0x0c,
-        0xb2, 0xd1, 0xb4, 0xba, 0xf0, 0x31, 0x91, 0x21,
-        0x51, 0x47, 0x2a, 0x81, 0x6a, 0x24, 0x3b, 0x4e,
-        0x5b, 0x7d, 0xa8, 0x43, 0x5a, 0x2b, 0x1c, 0xa8,
-        0x09, 0x37, 0x75, 0xad, 0x3d, 0x1e, 0xdf, 0xb8,
-        0x0a, 0x0e, 0x21, 0x5a, 0x2f, 0xe7, 0x4b, 0x29,
-        0xfe, 0xf4, 0x35, 0x95, 0xca, 0xe8, 0xdf, 0x40,
-        0x5a, 0xa0, 0x60, 0xf4, 0xe5, 0x25, 0x88, 0x2d,
-        0x27, 0xf4, 0xd3, 0x51, 0x75, 0x28, 0x1e, 0x9d,
-        0x5c, 0x68, 0x0a, 0x91, 0x9c, 0x8f, 0x84, 0x28,
-        0xb6, 0x29, 0x20, 0x0e, 0xaf, 0xa2, 0x4f, 0xd4,
-        0x3e, 0x34, 0x54, 0xfd, 0x42, 0x5d, 0xf8, 0xf8,
-        0xb3, 0x55, 0xe0, 0x26, 0x81, 0xd8, 0xd9, 0x0a,
-        0xd2, 0xd6, 0xf7, 0xba, 0x54, 0xd4, 0xb5, 0x3a,
-        0x6f, 0xa9, 0xa9, 0x14, 0x3e, 0x49, 0xa8, 0xa8,
-        0xcd, 0xd7, 0xf6, 0x7b, 0x3a, 0xd3, 0x64, 0xd5,
-        0x0b, 0x3b, 0x9a, 0x28, 0x80, 0xa7, 0xd5, 0x6b,
-        0x7d, 0x2f, 0x82, 0xfe, 0x26, 0xfe, 0x20, 0x97,
-        0x9c, 0xbb, 0xda, 0xab, 0xfc, 0x0f, 0xaf, 0xf2,
-        0xdb, 0x3c, 0xc5, 0xa3, 0xf1, 0xb8, 0xec, 0xe4,
-        0x92, 0xc8, 0xb7, 0x1f, 0x5f, 0x12, 0x30, 0xa6,
-        0x33, 0x4c, 0x52, 0x6e, 0x99, 0xf3, 0x5f, 0x05,
-        0x2b, 0x7b, 0xf9, 0x29, 0x1e, 0x67, 0x65, 0x14,
-        0x8b, 0x7c, 0x3b, 0xc5, 0x02, 0xc6, 0x44, 0xb1,
-        0x94, 0x5b, 0x46, 0xb1, 0x0a, 0xf6, 0xa2, 0x0f,
-        0x3b, 0xe1, 0xa6, 0x94, 0x9c, 0x9b, 0x11, 0xf9,
-        0xf6, 0x47, 0x59, 0x39, 0x88, 0xf1, 0x61, 0x56,
-        0x91, 0x5b, 0xfa, 0x30, 0x97, 0x02, 0xb6, 0x8e,
-        0x60, 0xfb, 0xb9, 0x36, 0x9e, 0x5d, 0x4e, 0xae,
-        0xed, 0x84, 0x9b, 0xc8, 0x5c, 0x4b, 0xac, 0xb2,
-        0x37, 0xf1, 0x1c, 0x6d, 0xc1, 0xc7, 0x34, 0xd9,
-        0x37, 0x75, 0x1f, 0x98, 0x4c, 0xfc, 0x6a, 0x36,
-        0x2b, 0x48, 0x61, 0xc5, 0xed, 0x7a, 0x48, 0x13,
-        0xdb, 0x95, 0xac, 0x55, 0x49, 0xca, 0x89, 0x9f,
-        0xa6, 0x23, 0x56, 0x22, 0xd7, 0x57, 0x65, 0x9f,
-        0xe9, 0xb0, 0x95, 0x8c, 0x6a, 0x2b, 0xf9, 0x25,
-        0x7e, 0x9a, 0x68, 0x11, 0xb9, 0xbe, 0x2a, 0xd5,
-        0x4c, 0xb4, 0xc8, 0xa8, 0x36, 0x97, 0x4c, 0x3b,
-        0x3f, 0x9b, 0x25, 0x09, 0x1c, 0xf1, 0xd3, 0xf4,
-        0x16, 0x2f, 0xcf, 0xf4, 0x55, 0x29, 0x64, 0x7c,
-        0x93, 0x57, 0xc2, 0xb4, 0x8d, 0x28, 0xe1, 0xbf,
-        0x6c, 0x84, 0xd0, 0x53, 0x71, 0x92, 0x74, 0xb1,
-        0x92, 0x41, 0xb7, 0x2e, 0x8b, 0x32, 0x62, 0xef,
-        0xd5, 0xd8, 0x7b, 0x35, 0xf6, 0x5e, 0x8d, 0xbd,
-        0x57, 0x63, 0xef, 0xd5, 0x78, 0x3d, 0x5e, 0x0d,
-        0x76, 0x22, 0x58, 0x9c, 0x79, 0x53, 0x4e, 0xc9,
-        0x11, 0x3e, 0x78, 0x56, 0x8e, 0x0f, 0xf1, 0x5a,
-        0xd2, 0x7c, 0x96, 0x8d, 0x63, 0x68, 0xfd, 0x3d,
-        0x3c, 0x21, 0x54, 0x3f, 0x23, 0x27, 0xdc, 0x50,
-        0xdb, 0x9a, 0x4b, 0xb8, 0x73, 0x85, 0xaf, 0x8e,
-        0x11, 0x25, 0x8d, 0x6c, 0x20, 0x4a, 0x1d, 0xe4,
-        0x93, 0x67, 0x40, 0x6d, 0xf5, 0x93, 0x60, 0x72,
-        0xf4, 0xf2, 0xd3, 0xc5, 0xa7, 0xcf, 0xdd, 0xf3,
-        0x3f, 0x6b, 0xef, 0xa4, 0xfb, 0x50, 0xa7, 0x9f,
-        0x7e, 0x3e, 0xed, 0xfe, 0x7c, 0xf2, 0xeb, 0xaf,
-        0x27, 0xa8, 0xb5, 0xed, 0xd6, 0xb1, 0xe1, 0x30,
-        0xcc, 0x41, 0x51, 0x6b, 0x86, 0xc5, 0xb8, 0x82,
-        0x1d, 0xbc, 0x5b, 0x1b, 0x76, 0x87, 0xf6, 0xe7,
-        0xae, 0x4c, 0xc8, 0x9d, 0xda, 0x7f, 0x8f, 0x60,
-        0xbe, 0x99, 0xbc, 0x79, 0x66, 0x93, 0x47, 0x3e,
-        0x6d, 0x65, 0xb1, 0xd2, 0xee, 0x61, 0xc8, 0x94,
-        0x72, 0xe9, 0x66, 0x76, 0x48, 0xb9, 0x19, 0xb2,
-        0x91, 0x19, 0xf1, 0x18, 0xa7, 0xef, 0x24, 0xe6,
-        0xd9, 0x4c, 0x9f, 0x2f, 0xe3, 0x8c, 0xcd, 0x54,
-        0x72, 0x10, 0xcf, 0x74, 0x78, 0x40, 0xb1, 0x2e,
-        0x8a, 0x74, 0x3a, 0x4c, 0xfc, 0xb2, 0x3a, 0xd6,
-        0x07, 0x59, 0xe2, 0x4a, 0x96, 0xcc, 0xac, 0xf1,
-        0x34, 0x53, 0xe8, 0xd8, 0x15, 0x75, 0x1a, 0x11,
-        0xb4, 0x81, 0x8c, 0x84, 0x34, 0xa4, 0x32, 0xfb,
-        0x61, 0xe2, 0x22, 0x21, 0x0a, 0x03, 0x87, 0xe3,
-        0xf7, 0x14, 0xd6, 0x74, 0x43, 0xf9, 0x4c, 0xe5,
-        0xd5, 0xe5, 0x65, 0xe4, 0x60, 0x55, 0xb9, 0x81,
-        0xef, 0x2d, 0x50, 0xb5, 0x99, 0x2b, 0xe2, 0xd0,
-        0x3f, 0xec, 0x30, 0x4e, 0x24, 0xb1, 0x00, 0xa9,
-        0xce, 0xe1, 0xdd, 0xe7, 0xb5, 0x9b, 0xed, 0xf7,
-        0x01, 0x11, 0xce, 0x75, 0x41, 0x85, 0x5b, 0x42,
-        0x06, 0xa9, 0x1b, 0x6a, 0x16, 0xa3, 0x19, 0x88,
-        0x05, 0x95, 0x22, 0x0b, 0xef, 0x24, 0x72, 0xf1,
-        0x91, 0x40, 0x93, 0xbf, 0x18, 0xbc, 0xc5, 0xcd,
-        0xb8, 0xd8, 0x21, 0xa4, 0xae, 0x7e, 0x84, 0x3f,
-        0x3c, 0x79, 0x82, 0x2a, 0x6a, 0x0e, 0xf6, 0x55,
-        0x4b, 0x87, 0x08, 0x81, 0xb4, 0x86, 0x8c, 0xc0,
-        0x87, 0x94, 0xba, 0x92, 0x52, 0xf1, 0xc4, 0xa0,
-        0xa7, 0xae, 0x64, 0xf7, 0xf2, 0x65, 0xff, 0x1f,
-        0x03, 0x90, 0xfe, 0x1c
-    };
-    static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
-    return decompressed.c_str();
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_icon.hpp b/src/mbgl/shaders/symbol_icon.hpp
deleted file mode 100644
index eccf17602d..0000000000
--- a/src/mbgl/shaders/symbol_icon.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class symbol_icon {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_sdf.hpp b/src/mbgl/shaders/symbol_sdf.hpp
deleted file mode 100644
index d5761d5fdb..0000000000
--- a/src/mbgl/shaders/symbol_sdf.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
-
-#pragma once
-
-namespace mbgl {
-namespace shaders {
-
-class symbol_sdf {
-public:
-    static const char* name;
-    static const char* vertexSource;
-    static const char* fragmentSource;
-};
-
-} // namespace shaders
-} // namespace mbgl