Bug 1512157 - Update webrender to commit 7c4162c581978d1a72ed2271a94382290855e227 (WR PR #3384). r=kats
authorWR Updater Bot <graphics-team@mozilla.staktrace.com>
Wed, 05 Dec 2018 12:18:24 +0000
changeset 449411 c67f67bb48d5594fba32666623cc7563aabcb08f
parent 449410 7ae0d4620e85c044345c86a26c91e1fe2f0ce6de
child 449412 6f780fe1f6ccba0bb6bb7a8284b0dc2f2b34cf92
push id74264
push userkgupta@mozilla.com
push dateWed, 05 Dec 2018 12:19:01 +0000
treeherderautoland@c67f67bb48d5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskats
bugs1512157
milestone65.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1512157 - Update webrender to commit 7c4162c581978d1a72ed2271a94382290855e227 (WR PR #3384). r=kats https://github.com/servo/webrender/pull/3384 Differential Revision: https://phabricator.services.mozilla.com/D13799
gfx/webrender_bindings/revision.txt
gfx/wr/webrender/res/brush.glsl
gfx/wr/webrender/res/clip_shared.glsl
gfx/wr/webrender/res/cs_clip_box_shadow.glsl
gfx/wr/webrender/res/cs_clip_image.glsl
gfx/wr/webrender/res/cs_clip_rectangle.glsl
gfx/wr/webrender/src/batch.rs
gfx/wr/webrender/src/border.rs
gfx/wr/webrender/src/box_shadow.rs
gfx/wr/webrender/src/clip.rs
gfx/wr/webrender/src/display_list_flattener.rs
gfx/wr/webrender/src/gpu_types.rs
gfx/wr/webrender/src/hit_test.rs
gfx/wr/webrender/src/prim_store.rs
gfx/wr/webrender/src/render_task.rs
gfx/wr/webrender/src/renderer.rs
gfx/wr/webrender/src/tiling.rs
gfx/wr/wrench/reftests/boxshadow/box-shadow-huge-radius.png
gfx/wr/wrench/reftests/boxshadow/box-shadow-large-blur-radius-3.png
--- a/gfx/webrender_bindings/revision.txt
+++ b/gfx/webrender_bindings/revision.txt
@@ -1,1 +1,1 @@
-6887ae38af2957ff04c6b33166ead0d9049bb0c1
+7c4162c581978d1a72ed2271a94382290855e227
--- a/gfx/wr/webrender/res/brush.glsl
+++ b/gfx/wr/webrender/res/brush.glsl
@@ -44,16 +44,17 @@ void main(void) {
         segment_data = vec4(0.0);
     } else {
         int segment_address = ph.specific_prim_address +
                               VECS_PER_SPECIFIC_BRUSH +
                               segment_index * VECS_PER_SEGMENT;
 
         vec4[2] segment_info = fetch_from_gpu_cache_2(segment_address);
         segment_rect = RectWithSize(segment_info[0].xy, segment_info[0].zw);
+        segment_rect.p0 += ph.local_rect.p0;
         segment_data = segment_info[1];
     }
 
     VertexInfo vi;
 
     // Fetch the dynamic picture that we are drawing on.
     PictureTask pic_task = fetch_picture_task(ph.render_task_index);
     ClipArea clip_area = fetch_clip_area(clip_address);
--- a/gfx/wr/webrender/res/clip_shared.glsl
+++ b/gfx/wr/webrender/res/clip_shared.glsl
@@ -12,35 +12,41 @@
 #define SEGMENT_CORNER_BL   3
 #define SEGMENT_CORNER_BR   4
 
 in int aClipRenderTaskAddress;
 in int aClipTransformId;
 in int aPrimTransformId;
 in int aClipSegment;
 in ivec4 aClipDataResourceAddress;
+in vec2 aClipLocalPos;
+in vec4 aClipTileRect;
 
 struct ClipMaskInstance {
     int render_task_address;
     int clip_transform_id;
     int prim_transform_id;
     int segment;
     ivec2 clip_data_address;
     ivec2 resource_address;
+    vec2 local_pos;
+    RectWithSize tile_rect;
 };
 
 ClipMaskInstance fetch_clip_item() {
     ClipMaskInstance cmi;
 
     cmi.render_task_address = aClipRenderTaskAddress;
     cmi.clip_transform_id = aClipTransformId;
     cmi.prim_transform_id = aPrimTransformId;
     cmi.segment = aClipSegment;
     cmi.clip_data_address = aClipDataResourceAddress.xy;
     cmi.resource_address = aClipDataResourceAddress.zw;
+    cmi.local_pos = aClipLocalPos;
+    cmi.tile_rect = RectWithSize(aClipTileRect.xy, aClipTileRect.zw);
 
     return cmi;
 }
 
 struct ClipVertexInfo {
     vec3 local_pos;
     RectWithSize clipped_local_rect;
 };
--- a/gfx/wr/webrender/res/cs_clip_box_shadow.glsl
+++ b/gfx/wr/webrender/res/cs_clip_box_shadow.glsl
@@ -41,18 +41,21 @@ BoxShadowData fetch_data(ivec2 address) 
 void main(void) {
     ClipMaskInstance cmi = fetch_clip_item();
     ClipArea area = fetch_clip_area(cmi.render_task_address);
     Transform clip_transform = fetch_transform(cmi.clip_transform_id);
     Transform prim_transform = fetch_transform(cmi.prim_transform_id);
     BoxShadowData bs_data = fetch_data(cmi.clip_data_address);
     ImageResource res = fetch_image_resource_direct(cmi.resource_address);
 
+    RectWithSize dest_rect = bs_data.dest_rect;
+    dest_rect.p0 += cmi.local_pos;
+
     ClipVertexInfo vi = write_clip_tile_vertex(
-        bs_data.dest_rect,
+        dest_rect,
         prim_transform,
         clip_transform,
         area
     );
     vLocalPos = vi.local_pos;
     vLayer = res.layer;
     vClipMode = bs_data.clip_mode;
 
@@ -60,39 +63,39 @@ void main(void) {
     vec2 uv1 = res.uv_rect.p1;
 
     vec2 texture_size = vec2(textureSize(sColor0, 0));
     vec2 local_pos = vLocalPos.xy / vLocalPos.z;
 
     switch (bs_data.stretch_mode_x) {
         case MODE_STRETCH: {
             vEdge.x = 0.5;
-            vEdge.z = (bs_data.dest_rect.size.x / bs_data.src_rect_size.x) - 0.5;
-            vUv.x = (local_pos.x - bs_data.dest_rect.p0.x) / bs_data.src_rect_size.x;
+            vEdge.z = (dest_rect.size.x / bs_data.src_rect_size.x) - 0.5;
+            vUv.x = (local_pos.x - dest_rect.p0.x) / bs_data.src_rect_size.x;
             break;
         }
         case MODE_SIMPLE:
         default: {
             vEdge.xz = vec2(1.0);
-            vUv.x = (local_pos.x - bs_data.dest_rect.p0.x) / bs_data.dest_rect.size.x;
+            vUv.x = (local_pos.x - dest_rect.p0.x) / dest_rect.size.x;
             break;
         }
     }
 
     switch (bs_data.stretch_mode_y) {
         case MODE_STRETCH: {
             vEdge.y = 0.5;
-            vEdge.w = (bs_data.dest_rect.size.y / bs_data.src_rect_size.y) - 0.5;
-            vUv.y = (local_pos.y - bs_data.dest_rect.p0.y) / bs_data.src_rect_size.y;
+            vEdge.w = (dest_rect.size.y / bs_data.src_rect_size.y) - 0.5;
+            vUv.y = (local_pos.y - dest_rect.p0.y) / bs_data.src_rect_size.y;
             break;
         }
         case MODE_SIMPLE:
         default: {
             vEdge.yw = vec2(1.0);
-            vUv.y = (local_pos.y - bs_data.dest_rect.p0.y) / bs_data.dest_rect.size.y;
+            vUv.y = (local_pos.y - dest_rect.p0.y) / dest_rect.size.y;
             break;
         }
     }
 
     vUvBounds = vec4(uv0 + vec2(0.5), uv1 - vec2(0.5)) / texture_size.xyxy;
     vUvBounds_NoClamp = vec4(uv0, uv1) / texture_size.xyxy;
 }
 #endif
--- a/gfx/wr/webrender/res/cs_clip_image.glsl
+++ b/gfx/wr/webrender/res/cs_clip_image.glsl
@@ -8,46 +8,43 @@ varying vec2 vLocalPos;
 varying vec2 vClipMaskImageUv;
 
 flat varying vec4 vClipMaskUvRect;
 flat varying vec4 vClipMaskUvInnerRect;
 flat varying float vLayer;
 
 #ifdef WR_VERTEX_SHADER
 struct ImageMaskData {
-    RectWithSize local_mask_rect;
-    RectWithSize local_tile_rect;
+    vec2 local_mask_size;
 };
 
 ImageMaskData fetch_mask_data(ivec2 address) {
-    vec4 data[2] = fetch_from_gpu_cache_2_direct(address);
-    RectWithSize mask_rect = RectWithSize(data[0].xy, data[0].zw);
-    RectWithSize tile_rect = RectWithSize(data[1].xy, data[1].zw);
-    ImageMaskData mask_data = ImageMaskData(mask_rect, tile_rect);
+    vec4 data = fetch_from_gpu_cache_1_direct(address);
+    ImageMaskData mask_data = ImageMaskData(data.xy);
     return mask_data;
 }
 
 void main(void) {
     ClipMaskInstance cmi = fetch_clip_item();
     ClipArea area = fetch_clip_area(cmi.render_task_address);
     Transform clip_transform = fetch_transform(cmi.clip_transform_id);
     Transform prim_transform = fetch_transform(cmi.prim_transform_id);
     ImageMaskData mask = fetch_mask_data(cmi.clip_data_address);
-    RectWithSize local_rect = mask.local_mask_rect;
+    RectWithSize local_rect = RectWithSize(cmi.local_pos, mask.local_mask_size);
     ImageResource res = fetch_image_resource_direct(cmi.resource_address);
 
     ClipVertexInfo vi = write_clip_tile_vertex(
         local_rect,
         prim_transform,
         clip_transform,
         area
     );
     vLocalPos = vi.local_pos.xy / vi.local_pos.z;
     vLayer = res.layer;
-    vClipMaskImageUv = (vLocalPos - mask.local_tile_rect.p0) / mask.local_tile_rect.size;
+    vClipMaskImageUv = (vLocalPos - cmi.tile_rect.p0) / cmi.tile_rect.size;
     vec2 texture_size = vec2(textureSize(sColor0, 0));
     vClipMaskUvRect = vec4(res.uv_rect.p0, res.uv_rect.p1 - res.uv_rect.p0) / texture_size.xyxy;
     // applying a half-texel offset to the UV boundaries to prevent linear samples from the outside
     vec4 inner_rect = vec4(res.uv_rect.p0, res.uv_rect.p1);
     vClipMaskUvInnerRect = (inner_rect + vec4(0.5, 0.5, -0.5, -0.5)) / texture_size.xyxy;
 }
 #endif
 
--- a/gfx/wr/webrender/res/cs_clip_rectangle.glsl
+++ b/gfx/wr/webrender/res/cs_clip_rectangle.glsl
@@ -58,17 +58,19 @@ ClipData fetch_clip(ivec2 address) {
 }
 
 void main(void) {
     ClipMaskInstance cmi = fetch_clip_item();
     ClipArea area = fetch_clip_area(cmi.render_task_address);
     Transform clip_transform = fetch_transform(cmi.clip_transform_id);
     Transform prim_transform = fetch_transform(cmi.prim_transform_id);
     ClipData clip = fetch_clip(cmi.clip_data_address);
+
     RectWithSize local_rect = clip.rect.rect;
+    local_rect.p0 = cmi.local_pos;
 
     ClipVertexInfo vi = write_clip_tile_vertex(
         local_rect,
         prim_transform,
         clip_transform,
         area
     );
 
--- a/gfx/wr/webrender/src/batch.rs
+++ b/gfx/wr/webrender/src/batch.rs
@@ -1966,17 +1966,17 @@ impl AlphaBatchBuilder {
         bounding_rect: &PictureRect,
         edge_flags: EdgeAaSegmentMask,
         uv_rect_address: GpuCacheAddress,
         z_id: ZBufferId,
     ) {
         let base_instance = BrushInstance {
             prim_header_index,
             clip_task_address,
-            segment_index: 0,
+            segment_index: INVALID_SEGMENT_INDEX,
             edge_flags,
             brush_flags: BrushFlags::PERSPECTIVE_INTERPOLATION,
             user_data: uv_rect_address.as_int(),
         };
 
         let batch_key = BatchKey {
             blend_mode,
             kind: BatchKind::Brush(batch_kind),
@@ -2183,17 +2183,17 @@ fn add_gradient_tiles(
             ..*base_prim_header
         };
         let prim_header_index = prim_headers.push(&prim_header, z_id, user_data);
 
         batch.push(PrimitiveInstanceData::from(
             BrushInstance {
                 prim_header_index,
                 clip_task_address,
-                segment_index: 0,
+                segment_index: INVALID_SEGMENT_INDEX,
                 edge_flags: EdgeAaSegmentMask::all(),
                 brush_flags: BrushFlags::PERSPECTIVE_INTERPOLATION,
                 user_data: 0,
             }
         ));
     }
 }
 
@@ -2437,24 +2437,27 @@ impl ClipBatcher {
             box_shadows: FastHashMap::default(),
         }
     }
 
     pub fn add_clip_region(
         &mut self,
         task_address: RenderTaskAddress,
         clip_data_address: GpuCacheAddress,
+        local_pos: LayoutPoint,
     ) {
         let instance = ClipMaskInstance {
             render_task_address: task_address,
             clip_transform_id: TransformPaletteId::IDENTITY,
             prim_transform_id: TransformPaletteId::IDENTITY,
             segment: 0,
             clip_data_address,
             resource_address: GpuCacheAddress::invalid(),
+            local_pos,
+            tile_rect: LayoutRect::zero(),
         };
 
         self.rectangles.push(instance);
     }
 
     pub fn add(
         &mut self,
         task_address: RenderTaskAddress,
@@ -2485,57 +2488,63 @@ impl ClipBatcher {
 
             let instance = ClipMaskInstance {
                 render_task_address: task_address,
                 clip_transform_id,
                 prim_transform_id,
                 segment: 0,
                 clip_data_address: GpuCacheAddress::invalid(),
                 resource_address: GpuCacheAddress::invalid(),
+                local_pos: clip_instance.local_pos,
+                tile_rect: LayoutRect::zero(),
             };
 
             match clip_node.item {
-                ClipItem::Image { ref mask, ref visible_tiles } => {
+                ClipItem::Image { image, size, .. } => {
                     let request = ImageRequest {
-                        key: mask.image,
+                        key: image,
                         rendering: ImageRendering::Auto,
                         tile: None,
                     };
-                    let mut add_image = |request: ImageRequest, clip_data_address: GpuCacheAddress| {
+
+                    let clip_data_address =
+                        gpu_cache.get_address(&clip_node.gpu_cache_handle);
+
+                    let mut add_image = |request: ImageRequest, local_tile_rect: LayoutRect| {
                         let cache_item = match resource_cache.get_cached_image(request) {
                             Ok(item) => item,
                             Err(..) => {
                                 warn!("Warnings: skip a image mask");
-                                debug!("Mask: {:?}, request: {:?}", mask, request);
+                                debug!("request: {:?}", request);
                                 return;
                             }
                         };
                         self.images
                             .entry(cache_item.texture_id)
                             .or_insert(Vec::new())
                             .push(ClipMaskInstance {
                                 clip_data_address,
                                 resource_address: gpu_cache.get_address(&cache_item.uv_rect_handle),
+                                tile_rect: local_tile_rect,
                                 ..instance
                             });
                     };
 
-                    match *visible_tiles {
+                    match clip_instance.visible_tiles {
                         Some(ref tiles) => {
                             for tile in tiles {
                                 add_image(
                                     request.with_tile(tile.tile_offset),
-                                    gpu_cache.get_address(&tile.handle),
+                                    tile.tile_rect,
                                 )
                             }
                         }
                         None => {
-                            let gpu_address =
-                                gpu_cache.get_address(&clip_node.gpu_cache_handle);
-                            add_image(request, gpu_address)
+                            let mask_rect = LayoutRect::new(clip_instance.local_pos, size);
+                            add_image(request, mask_rect)
                         }
                     }
                 }
                 ClipItem::BoxShadow(ref info) => {
                     let gpu_address =
                         gpu_cache.get_address(&clip_node.gpu_cache_handle);
                     let rt_handle = info
                         .cache_handle
--- a/gfx/wr/webrender/src/border.rs
+++ b/gfx/wr/webrender/src/border.rs
@@ -166,42 +166,42 @@ pub struct BorderSegmentCacheKey {
     pub side0: BorderSideAu,
     pub side1: BorderSideAu,
     pub segment: BorderSegment,
     pub do_aa: bool,
 }
 
 pub fn ensure_no_corner_overlap(
     radius: &mut BorderRadius,
-    rect: &LayoutRect,
+    size: LayoutSize,
 ) {
     let mut ratio = 1.0;
     let top_left_radius = &mut radius.top_left;
     let top_right_radius = &mut radius.top_right;
     let bottom_right_radius = &mut radius.bottom_right;
     let bottom_left_radius = &mut radius.bottom_left;
 
     let sum = top_left_radius.width + top_right_radius.width;
-    if rect.size.width < sum {
-        ratio = f32::min(ratio, rect.size.width / sum);
+    if size.width < sum {
+        ratio = f32::min(ratio, size.width / sum);
     }
 
     let sum = bottom_left_radius.width + bottom_right_radius.width;
-    if rect.size.width < sum {
-        ratio = f32::min(ratio, rect.size.width / sum);
+    if size.width < sum {
+        ratio = f32::min(ratio, size.width / sum);
     }
 
     let sum = top_left_radius.height + bottom_left_radius.height;
-    if rect.size.height < sum {
-        ratio = f32::min(ratio, rect.size.height / sum);
+    if size.height < sum {
+        ratio = f32::min(ratio, size.height / sum);
     }
 
     let sum = top_right_radius.height + bottom_right_radius.height;
-    if rect.size.height < sum {
-        ratio = f32::min(ratio, rect.size.height / sum);
+    if size.height < sum {
+        ratio = f32::min(ratio, size.height / sum);
     }
 
     if ratio < 1. {
         top_left_radius.width *= ratio;
         top_left_radius.height *= ratio;
 
         top_right_radius.width *= ratio;
         top_right_radius.height *= ratio;
@@ -218,17 +218,17 @@ impl<'a> DisplayListFlattener<'a> {
     pub fn add_normal_border(
         &mut self,
         info: &LayoutPrimitiveInfo,
         border: &NormalBorder,
         widths: LayoutSideOffsets,
         clip_and_scroll: ScrollNodeAndClipChain,
     ) {
         let mut border = *border;
-        ensure_no_corner_overlap(&mut border.radius, &info.rect);
+        ensure_no_corner_overlap(&mut border.radius, info.rect.size);
 
         self.add_primitive(
             clip_and_scroll,
             info,
             Vec::new(),
             PrimitiveKeyKind::NormalBorder {
                 border: border.into(),
                 widths: widths.to_au(),
@@ -644,22 +644,27 @@ fn get_edge_info(
             EdgeInfo::new(0.0, avail_size, 8.0)
         }
     }
 }
 
 /// Create the set of border segments and render task
 /// cache keys for a given CSS border.
 pub fn create_border_segments(
-    rect: &LayoutRect,
+    size: LayoutSize,
     border: &NormalBorder,
     widths: &LayoutSideOffsets,
     border_segments: &mut Vec<BorderSegmentInfo>,
     brush_segments: &mut Vec<BrushSegment>,
 ) {
+    let rect = LayoutRect::new(
+        LayoutPoint::zero(),
+        size,
+    );
+
     let local_size_tl = LayoutSize::new(
         border.radius.top_left.width.max(widths.left),
         border.radius.top_left.height.max(widths.top),
     );
     let local_size_tr = LayoutSize::new(
         border.radius.top_right.width.max(widths.right),
         border.radius.top_right.height.max(widths.top),
     );
@@ -1138,18 +1143,23 @@ pub fn build_border_instances(
     );
 
     instances
 }
 
 impl NinePatchDescriptor {
     pub fn create_segments(
         &self,
-        rect: &LayoutRect,
+        size: LayoutSize,
     ) -> Vec<BrushSegment> {
+        let rect = LayoutRect::new(
+            LayoutPoint::zero(),
+            size,
+        );
+
         // Calculate the modified rect as specific by border-image-outset
         let origin = LayoutPoint::new(
             rect.origin.x - self.outset.left,
             rect.origin.y - self.outset.top,
         );
         let size = LayoutSize::new(
             rect.size.width + self.outset.left + self.outset.right,
             rect.size.height + self.outset.top + self.outset.bottom,
--- a/gfx/wr/webrender/src/box_shadow.rs
+++ b/gfx/wr/webrender/src/box_shadow.rs
@@ -112,92 +112,117 @@ impl<'a> DisplayListFlattener<'a> {
             let mut clips = Vec::with_capacity(2);
             let (final_prim_rect, clip_radius) = match clip_mode {
                 BoxShadowClipMode::Outset => {
                     if !shadow_rect.is_well_formed_and_nonempty() {
                         return;
                     }
 
                     // TODO(gw): Add a fast path for ClipOut + zero border radius!
-                    clips.push(ClipItemKey::rounded_rect(
-                        prim_info.rect,
-                        border_radius,
-                        ClipMode::ClipOut,
-                    ));
+                    clips.push(
+                        (
+                            prim_info.rect.origin,
+                            ClipItemKey::rounded_rect(
+                                prim_info.rect.size,
+                                border_radius,
+                                ClipMode::ClipOut,
+                            ),
+                        )
+                    );
 
                     (shadow_rect, shadow_radius)
                 }
                 BoxShadowClipMode::Inset => {
                     if shadow_rect.is_well_formed_and_nonempty() {
-                        clips.push(ClipItemKey::rounded_rect(
-                            shadow_rect,
-                            shadow_radius,
-                            ClipMode::ClipOut,
-                        ));
+                        clips.push(
+                            (
+                                shadow_rect.origin,
+                                ClipItemKey::rounded_rect(
+                                    shadow_rect.size,
+                                    shadow_radius,
+                                    ClipMode::ClipOut,
+                                ),
+                            )
+                        );
                     }
 
                     (prim_info.rect, border_radius)
                 }
             };
 
-            clips.push(ClipItemKey::rounded_rect(
-                final_prim_rect,
-                clip_radius,
-                ClipMode::Clip,
-            ));
+            clips.push(
+                (
+                    final_prim_rect.origin,
+                    ClipItemKey::rounded_rect(
+                        final_prim_rect.size,
+                        clip_radius,
+                        ClipMode::Clip,
+                    ),
+                )
+            );
 
             self.add_primitive(
                 clip_and_scroll,
                 &LayoutPrimitiveInfo::with_clip_rect(final_prim_rect, prim_info.clip_rect),
                 clips,
                 PrimitiveKeyKind::Rectangle {
                     color: color.into(),
                 },
             );
         } else {
             // Normal path for box-shadows with a valid blur radius.
             let blur_offset = BLUR_SAMPLE_SCALE * blur_radius;
             let mut extra_clips = vec![];
 
             // Add a normal clip mask to clip out the contents
             // of the surrounding primitive.
-            extra_clips.push(ClipItemKey::rounded_rect(
-                prim_info.rect,
-                border_radius,
-                prim_clip_mode,
-            ));
+            extra_clips.push(
+                (
+                    prim_info.rect.origin,
+                    ClipItemKey::rounded_rect(
+                        prim_info.rect.size,
+                        border_radius,
+                        prim_clip_mode,
+                    ),
+                )
+            );
 
             // Get the local rect of where the shadow will be drawn,
             // expanded to include room for the blurred region.
             let dest_rect = shadow_rect.inflate(blur_offset, blur_offset);
 
             // Draw the box-shadow as a solid rect, using a box-shadow
             // clip mask item.
             let prim = PrimitiveKeyKind::Rectangle {
                 color: color.into(),
             };
 
             // Create the box-shadow clip item.
             let shadow_clip_source = ClipItemKey::box_shadow(
                 shadow_rect,
                 shadow_radius,
-                dest_rect,
+                dest_rect.translate(&LayoutVector2D::new(-prim_info.rect.origin.x, -prim_info.rect.origin.y)),
                 blur_radius,
                 clip_mode,
             );
 
             let prim_info = match clip_mode {
                 BoxShadowClipMode::Outset => {
                     // Certain spread-radii make the shadow invalid.
                     if !shadow_rect.is_well_formed_and_nonempty() {
                         return;
                     }
 
                     // Add the box-shadow clip source.
-                    extra_clips.push(shadow_clip_source);
+                    extra_clips.push(
+                        (
+                            prim_info.rect.origin,
+                            shadow_clip_source,
+                        ),
+                    );
 
                     // Outset shadows are expanded by the shadow
                     // region from the original primitive.
                     LayoutPrimitiveInfo::with_clip_rect(dest_rect, prim_info.clip_rect)
                 }
                 BoxShadowClipMode::Inset => {
                     // If the inner shadow rect contains the prim
                     // rect, no pixels will be shadowed.
@@ -207,17 +232,22 @@ impl<'a> DisplayListFlattener<'a> {
                     {
                         return;
                     }
 
                     // Inset shadows are still visible, even if the
                     // inset shadow rect becomes invalid (they will
                     // just look like a solid rectangle).
                     if shadow_rect.is_well_formed_and_nonempty() {
-                        extra_clips.push(shadow_clip_source);
+                        extra_clips.push(
+                            (
+                                prim_info.rect.origin,
+                                shadow_clip_source,
+                            ),
+                        );
                     }
 
                     // Inset shadows draw inside the original primitive.
                     prim_info.clone()
                 }
             };
 
             self.add_primitive(
--- a/gfx/wr/webrender/src/clip.rs
+++ b/gfx/wr/webrender/src/clip.rs
@@ -1,28 +1,29 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use api::{BorderRadius, ClipMode, ComplexClipRegion, DeviceIntRect, DevicePixelScale, ImageMask};
 use api::{ImageRendering, LayoutRect, LayoutSize, LayoutPoint, LayoutVector2D};
 use api::{BoxShadowClipMode, LayoutToWorldScale, PicturePixel, WorldPixel};
 use api::{PictureRect, LayoutPixel, WorldPoint, WorldSize, WorldRect, LayoutToWorldTransform};
-use api::{VoidPtrToSizeFn, LayoutRectAu, ImageKey, AuHelpers};
+use api::{VoidPtrToSizeFn, ImageKey};
 use app_units::Au;
 use border::{ensure_no_corner_overlap, BorderRadiusAu};
 use box_shadow::{BLUR_SAMPLE_SCALE, BoxShadowClipSource, BoxShadowCacheKey};
 use clip_scroll_tree::{ClipScrollTree, ROOT_SPATIAL_NODE_INDEX, SpatialNodeIndex};
 use ellipse::Ellipse;
 use gpu_cache::{GpuCache, GpuCacheHandle, ToGpuBlocks};
 use gpu_types::{BoxShadowStretchMode};
 use image::{self, Repetition};
 use intern;
 use internal_types::FastHashSet;
 use prim_store::{ClipData, ImageMaskData, SpaceMapper, VisibleMaskImageTile};
+use prim_store::{PointKey, SizeKey, RectangleKey};
 use render_task::to_cache_size;
 use resource_cache::{ImageRequest, ResourceCache};
 use std::{cmp, u32};
 use std::os::raw::c_void;
 use util::{extract_inner_rect_safe, project_rect, ScaleOffset};
 
 /*
 
@@ -131,41 +132,39 @@ pub struct ClipNode {
 
 // Convert from an interning key for a clip item
 // to a clip node, which is cached in the document.
 // TODO(gw): These enums are a bit messy - we should
 //           convert them to use named fields.
 impl From<ClipItemKey> for ClipNode {
     fn from(item: ClipItemKey) -> Self {
         let item = match item {
-            ClipItemKey::Rectangle(rect, mode) => {
-                ClipItem::Rectangle(LayoutRect::from_au(rect), mode)
+            ClipItemKey::Rectangle(size, mode) => {
+                ClipItem::Rectangle(size.into(), mode)
             }
-            ClipItemKey::RoundedRectangle(rect, radius, mode) => {
+            ClipItemKey::RoundedRectangle(size, radius, mode) => {
                 ClipItem::RoundedRectangle(
-                    LayoutRect::from_au(rect),
+                    size.into(),
                     radius.into(),
                     mode,
                 )
             }
-            ClipItemKey::ImageMask(rect, image, repeat) => {
+            ClipItemKey::ImageMask(size, image, repeat) => {
                 ClipItem::Image {
-                    mask: ImageMask {
-                        image,
-                        rect: LayoutRect::from_au(rect),
-                        repeat,
-                    },
-                    visible_tiles: None,
+                    image,
+                    size: size.into(),
+                    repeat,
                 }
             }
-            ClipItemKey::BoxShadow(shadow_rect, shadow_radius, prim_shadow_rect, blur_radius, clip_mode) => {
+            ClipItemKey::BoxShadow(shadow_rect_fract_offset, shadow_rect_size, shadow_radius, prim_shadow_rect, blur_radius, clip_mode) => {
                 ClipItem::new_box_shadow(
-                    LayoutRect::from_au(shadow_rect),
+                    shadow_rect_fract_offset.into(),
+                    shadow_rect_size.into(),
                     shadow_radius.into(),
-                    LayoutRect::from_au(prim_shadow_rect),
+                    prim_shadow_rect.into(),
                     blur_radius.to_f32_px(),
                     clip_mode,
                 )
             }
         };
 
         ClipNode {
             item,
@@ -198,39 +197,43 @@ impl ClipChainId {
     pub const NONE: Self = ClipChainId(u32::MAX);
 }
 
 // A clip chain node is an id for a range of clip sources,
 // and a link to a parent clip chain node, or ClipChainId::NONE.
 #[derive(Clone)]
 pub struct ClipChainNode {
     pub handle: ClipDataHandle,
+    pub local_pos: LayoutPoint,
     pub spatial_node_index: SpatialNodeIndex,
     pub parent_clip_chain_id: ClipChainId,
 }
 
 // An index into the clip_nodes array.
 #[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct ClipNodeIndex(pub u32);
 
 // When a clip node is found to be valid for a
 // clip chain instance, it's stored in an index
 // buffer style structure. This struct contains
 // an index to the node data itself, as well as
 // some flags describing how this clip node instance
 // is positioned.
-#[derive(Clone, Copy, Debug)]
+#[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct ClipNodeInstance {
     pub handle: ClipDataHandle,
     pub flags: ClipNodeFlags,
     pub spatial_node_index: SpatialNodeIndex,
+    pub local_pos: LayoutPoint,
+
+    pub visible_tiles: Option<Vec<VisibleMaskImageTile>>,
 }
 
 // A range of clip node instances that were found by
 // building a clip chain instance.
 #[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct ClipNodeRange {
@@ -250,94 +253,121 @@ enum ClipSpaceConversion {
     Transform(LayoutToWorldTransform),
 }
 
 // Temporary information that is cached and reused
 // during building of a clip chain instance.
 struct ClipNodeInfo {
     conversion: ClipSpaceConversion,
     handle: ClipDataHandle,
+    local_pos: LayoutPoint,
     spatial_node_index: SpatialNodeIndex,
 }
 
+impl ClipNodeInfo {
+    fn create_instance(
+        &self,
+        node: &ClipNode,
+        clipped_rect: &LayoutRect,
+        gpu_cache: &mut GpuCache,
+        resource_cache: &mut ResourceCache,
+    ) -> ClipNodeInstance {
+        // Calculate some flags that are required for the segment
+        // building logic.
+        let flags = match self.conversion {
+            ClipSpaceConversion::Local => {
+                ClipNodeFlags::SAME_SPATIAL_NODE | ClipNodeFlags::SAME_COORD_SYSTEM
+            }
+            ClipSpaceConversion::ScaleOffset(..) => {
+                ClipNodeFlags::SAME_COORD_SYSTEM
+            }
+            ClipSpaceConversion::Transform(..) => {
+                ClipNodeFlags::empty()
+            }
+        };
+
+        let mut visible_tiles = None;
+
+        if let ClipItem::Image { size, image, repeat } = node.item {
+            let request = ImageRequest {
+                key: image,
+                rendering: ImageRendering::Auto,
+                tile: None,
+            };
+
+            if let Some(props) = resource_cache.get_image_properties(image) {
+                if let Some(tile_size) = props.tiling {
+                    let mut mask_tiles = Vec::new();
+                    let mask_rect = LayoutRect::new(self.local_pos, size);
+
+                    let device_image_size = props.descriptor.size;
+                    let visible_rect = if repeat {
+                        *clipped_rect
+                    } else {
+                        clipped_rect.intersection(&mask_rect).unwrap()
+                    };
+
+                    let repetitions = image::repetitions(
+                        &mask_rect,
+                        &visible_rect,
+                        size,
+                    );
+
+                    for Repetition { origin, .. } in repetitions {
+                        let image_rect = LayoutRect {
+                            origin,
+                            size,
+                        };
+                        let tiles = image::tiles(
+                            &image_rect,
+                            &visible_rect,
+                            &device_image_size,
+                            tile_size as i32,
+                        );
+                        for tile in tiles {
+                            resource_cache.request_image(
+                                request.with_tile(tile.offset),
+                                gpu_cache,
+                            );
+                            mask_tiles.push(VisibleMaskImageTile {
+                                tile_offset: tile.offset,
+                                tile_rect: tile.rect,
+                            });
+                        }
+                    }
+                    visible_tiles = Some(mask_tiles);
+                } else {
+                    resource_cache.request_image(request, gpu_cache);
+                }
+            }
+        }
+
+        ClipNodeInstance {
+            handle: self.handle,
+            flags,
+            spatial_node_index: self.spatial_node_index,
+            local_pos: self.local_pos,
+            visible_tiles,
+        }
+    }
+}
+
 impl ClipNode {
     pub fn update(
         &mut self,
         gpu_cache: &mut GpuCache,
-        resource_cache: &mut ResourceCache,
         device_pixel_scale: DevicePixelScale,
-        clipped_rect: &LayoutRect,
     ) {
         match self.item {
-            ClipItem::Image { ref mask, ref mut visible_tiles } => {
-                let request = ImageRequest {
-                    key: mask.image,
-                    rendering: ImageRendering::Auto,
-                    tile: None,
-                };
-                *visible_tiles = None;
-                if let Some(props) = resource_cache.get_image_properties(mask.image) {
-                    if let Some(tile_size) = props.tiling {
-                        let mut mask_tiles = Vec::new();
-
-                        let device_image_size = props.descriptor.size;
-                        let visible_rect = if mask.repeat {
-                            *clipped_rect
-                        } else {
-                            clipped_rect.intersection(&mask.rect).unwrap()
-                        };
-
-                        let repetitions = image::repetitions(
-                            &mask.rect,
-                            &visible_rect,
-                            mask.rect.size,
-                        );
-
-                        for Repetition { origin, .. } in repetitions {
-                            let image_rect = LayoutRect {
-                                origin,
-                                size: mask.rect.size,
-                            };
-                            let tiles = image::tiles(
-                                &image_rect,
-                                &visible_rect,
-                                &device_image_size,
-                                tile_size as i32,
-                            );
-                            for tile in tiles {
-                                resource_cache.request_image(
-                                    request.with_tile(tile.offset),
-                                    gpu_cache,
-                                );
-                                let mut handle = GpuCacheHandle::new();
-                                if let Some(request) = gpu_cache.request(&mut handle) {
-                                    let data = ImageMaskData {
-                                        local_mask_rect: mask.rect,
-                                        local_tile_rect: tile.rect,
-                                    };
-                                    data.write_gpu_blocks(request);
-                                }
-
-                                mask_tiles.push(VisibleMaskImageTile {
-                                    tile_offset: tile.offset,
-                                    handle,
-                                });
-                            }
-                        }
-                        *visible_tiles = Some(mask_tiles);
-                    } else {
-                        if let Some(request) = gpu_cache.request(&mut self.gpu_cache_handle) {
-                            let data = ImageMaskData {
-                                local_mask_rect: mask.rect,
-                                local_tile_rect: mask.rect,
-                            };
-                            data.write_gpu_blocks(request);
-                        }
-                        resource_cache.request_image(request, gpu_cache);
-                    }
+            ClipItem::Image { size, .. } => {
+                if let Some(request) = gpu_cache.request(&mut self.gpu_cache_handle) {
+                    let data = ImageMaskData {
+                        local_mask_size: size,
+                    };
+                    data.write_gpu_blocks(request);
                 }
             }
             ClipItem::BoxShadow(ref mut info) => {
                 if let Some(mut request) = gpu_cache.request(&mut self.gpu_cache_handle) {
                     request.push([
                         info.original_alloc_size.width,
                         info.original_alloc_size.height,
                         info.clip_mode as i32 as f32,
@@ -371,33 +401,33 @@ impl ClipNode {
                     br_bottom_right: (info.shadow_radius.bottom_right * content_scale).round().to_i32(),
                     br_bottom_left: (info.shadow_radius.bottom_left * content_scale).round().to_i32(),
                 };
 
                 info.cache_key = Some((cache_size, bs_cache_key));
 
                 if let Some(mut request) = gpu_cache.request(&mut info.clip_data_handle) {
                     let data = ClipData::rounded_rect(
-                        &info.minimal_shadow_rect,
+                        info.minimal_shadow_rect.size,
                         &info.shadow_radius,
                         ClipMode::Clip,
                     );
 
                     data.write(&mut request);
                 }
             }
-            ClipItem::Rectangle(rect, mode) => {
+            ClipItem::Rectangle(size, mode) => {
                 if let Some(mut request) = gpu_cache.request(&mut self.gpu_cache_handle) {
-                    let data = ClipData::uniform(rect, 0.0, mode);
+                    let data = ClipData::uniform(size, 0.0, mode);
                     data.write(&mut request);
                 }
             }
-            ClipItem::RoundedRectangle(ref rect, ref radius, mode) => {
+            ClipItem::RoundedRectangle(size, ref radius, mode) => {
                 if let Some(mut request) = gpu_cache.request(&mut self.gpu_cache_handle) {
-                    let data = ClipData::rounded_rect(rect, radius, mode);
+                    let data = ClipData::rounded_rect(size, radius, mode);
                     data.write(&mut request);
                 }
             }
         }
     }
 }
 
 // The main clipping public interface that other modules access.
@@ -437,23 +467,25 @@ impl ClipStore {
 
     pub fn get_clip_chain(&self, clip_chain_id: ClipChainId) -> &ClipChainNode {
         &self.clip_chain_nodes[clip_chain_id.0 as usize]
     }
 
     pub fn add_clip_chain_node(
         &mut self,
         handle: ClipDataHandle,
+        local_pos: LayoutPoint,
         spatial_node_index: SpatialNodeIndex,
         parent_clip_chain_id: ClipChainId,
     ) -> ClipChainId {
         let id = ClipChainId(self.clip_chain_nodes.len() as u32);
         self.clip_chain_nodes.push(ClipChainNode {
             handle,
             spatial_node_index,
+            local_pos,
             parent_clip_chain_id,
         });
         id
     }
 
     pub fn get_instance_from_range(
         &self,
         node_range: &ClipNodeRange,
@@ -518,16 +550,17 @@ impl ClipStore {
             }) {
                 Some(collector) => {
                     collector.insert(current_clip_chain_id);
                 }
                 None => {
                     if !add_clip_node_to_current_chain(
                         clip_chain_node.handle,
                         clip_chain_node.spatial_node_index,
+                        clip_chain_node.local_pos,
                         spatial_node_index,
                         &mut local_clip_rect,
                         &mut self.clip_node_info,
                         clip_data_store,
                         clip_scroll_tree,
                     ) {
                         return None;
                     }
@@ -536,24 +569,25 @@ impl ClipStore {
 
             current_clip_chain_id = clip_chain_node.parent_clip_chain_id;
         }
 
         // Add any collected clips from primitives that should be
         // handled as part of this rasterization root.
         if let Some(clip_node_collector) = clip_node_collector {
             for clip_chain_id in &clip_node_collector.clips {
-                let (handle, clip_spatial_node_index) = {
+                let (handle, clip_spatial_node_index, local_pos) = {
                     let clip_chain_node = &self.clip_chain_nodes[clip_chain_id.0 as usize];
-                    (clip_chain_node.handle, clip_chain_node.spatial_node_index)
+                    (clip_chain_node.handle, clip_chain_node.spatial_node_index, clip_chain_node.local_pos)
                 };
 
                 if !add_clip_node_to_current_chain(
                     handle,
                     clip_spatial_node_index,
+                    local_pos,
                     spatial_node_index,
                     &mut local_clip_rect,
                     &mut self.clip_node_info,
                     clip_data_store,
                     clip_scroll_tree,
                 ) {
                     return None;
                 }
@@ -575,25 +609,26 @@ impl ClipStore {
 
         // For each potential clip node
         for node_info in self.clip_node_info.drain(..) {
             let node = &mut clip_data_store[node_info.handle];
 
             // See how this clip affects the prim region.
             let clip_result = match node_info.conversion {
                 ClipSpaceConversion::Local => {
-                    node.item.get_clip_result(&local_bounding_rect)
+                    node.item.get_clip_result(node_info.local_pos, &local_bounding_rect)
                 }
                 ClipSpaceConversion::ScaleOffset(ref scale_offset) => {
                     has_non_local_clips = true;
-                    node.item.get_clip_result(&scale_offset.unmap_rect(&local_bounding_rect))
+                    node.item.get_clip_result(node_info.local_pos, &scale_offset.unmap_rect(&local_bounding_rect))
                 }
                 ClipSpaceConversion::Transform(ref transform) => {
                     has_non_local_clips = true;
                     node.item.get_clip_result_complex(
+                        node_info.local_pos,
                         transform,
                         &world_clip_rect,
                         world_rect,
                     )
                 }
             };
 
             match clip_result {
@@ -605,60 +640,47 @@ impl ClipStore {
                     return None;
                 }
                 ClipResult::Partial => {
                     // Needs a mask -> add to clip node indices
 
                     // TODO(gw): Ensure this only runs once on each node per frame?
                     node.update(
                         gpu_cache,
-                        resource_cache,
                         device_pixel_scale,
-                        &local_bounding_rect,
                     );
 
-                    // Calculate some flags that are required for the segment
-                    // building logic.
-                    let flags = match node_info.conversion {
-                        ClipSpaceConversion::Local => {
-                            ClipNodeFlags::SAME_SPATIAL_NODE | ClipNodeFlags::SAME_COORD_SYSTEM
-                        }
-                        ClipSpaceConversion::ScaleOffset(..) => {
-                            ClipNodeFlags::SAME_COORD_SYSTEM
-                        }
-                        ClipSpaceConversion::Transform(..) => {
-                            ClipNodeFlags::empty()
-                        }
-                    };
+                    // Create the clip node instance for this clip node
+                    let instance = node_info.create_instance(
+                        node,
+                        &local_bounding_rect,
+                        gpu_cache,
+                        resource_cache,
+                    );
 
                     // As a special case, a partial accept of a clip rect that is
                     // in the same coordinate system as the primitive doesn't need
                     // a clip mask. Instead, it can be handled by the primitive
                     // vertex shader as part of the local clip rect. This is an
                     // important optimization for reducing the number of clip
                     // masks that are allocated on common pages.
                     needs_mask |= match node.item {
                         ClipItem::Rectangle(_, ClipMode::ClipOut) |
                         ClipItem::RoundedRectangle(..) |
                         ClipItem::Image { .. } |
                         ClipItem::BoxShadow(..) => {
                             true
                         }
 
                         ClipItem::Rectangle(_, ClipMode::Clip) => {
-                            !flags.contains(ClipNodeFlags::SAME_COORD_SYSTEM)
+                            !instance.flags.contains(ClipNodeFlags::SAME_COORD_SYSTEM)
                         }
                     };
 
                     // Store this in the index buffer for this clip chain instance.
-                    let instance = ClipNodeInstance {
-                        handle: node_info.handle,
-                        flags,
-                        spatial_node_index: node_info.spatial_node_index,
-                    };
                     self.clip_node_instances.push(instance);
                 }
             }
         }
 
         // Get the range identifying the clip nodes in the index buffer.
         let clips_range = ClipNodeRange {
             first: first_clip_node_index,
@@ -810,94 +832,101 @@ pub struct ClipItemSceneData {
 // comparison of clip node equality by handle, and also allows
 // the uploaded GPU cache handle to be retained between display lists.
 // TODO(gw): Maybe we should consider constructing these directly
 //           in the DL builder?
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum ClipItemKey {
-    Rectangle(LayoutRectAu, ClipMode),
-    RoundedRectangle(LayoutRectAu, BorderRadiusAu, ClipMode),
-    ImageMask(LayoutRectAu, ImageKey, bool),
-    BoxShadow(LayoutRectAu, BorderRadiusAu, LayoutRectAu, Au, BoxShadowClipMode),
+    Rectangle(SizeKey, ClipMode),
+    RoundedRectangle(SizeKey, BorderRadiusAu, ClipMode),
+    ImageMask(SizeKey, ImageKey, bool),
+    BoxShadow(PointKey, SizeKey, BorderRadiusAu, RectangleKey, Au, BoxShadowClipMode),
 }
 
 impl ClipItemKey {
-    pub fn rectangle(rect: LayoutRect, mode: ClipMode) -> Self {
-        ClipItemKey::Rectangle(rect.to_au(), mode)
+    pub fn rectangle(size: LayoutSize, mode: ClipMode) -> Self {
+        ClipItemKey::Rectangle(size.into(), mode)
     }
 
-    pub fn rounded_rect(rect: LayoutRect, mut radii: BorderRadius, mode: ClipMode) -> Self {
+    pub fn rounded_rect(size: LayoutSize, mut radii: BorderRadius, mode: ClipMode) -> Self {
         if radii.is_zero() {
-            ClipItemKey::rectangle(rect, mode)
+            ClipItemKey::rectangle(size, mode)
         } else {
-            ensure_no_corner_overlap(&mut radii, &rect);
+            ensure_no_corner_overlap(&mut radii, size);
             ClipItemKey::RoundedRectangle(
-                rect.to_au(),
+                size.into(),
                 radii.into(),
                 mode,
             )
         }
     }
 
     pub fn image_mask(image_mask: &ImageMask) -> Self {
         ClipItemKey::ImageMask(
-            image_mask.rect.to_au(),
+            image_mask.rect.size.into(),
             image_mask.image,
             image_mask.repeat,
         )
     }
 
     pub fn box_shadow(
         shadow_rect: LayoutRect,
         shadow_radius: BorderRadius,
         prim_shadow_rect: LayoutRect,
         blur_radius: f32,
         clip_mode: BoxShadowClipMode,
     ) -> Self {
+        // Get the fractional offsets required to match the
+        // source rect with a minimal rect.
+        let fract_offset = LayoutPoint::new(
+            shadow_rect.origin.x.fract().abs(),
+            shadow_rect.origin.y.fract().abs(),
+        );
+
         ClipItemKey::BoxShadow(
-            shadow_rect.to_au(),
+            fract_offset.into(),
+            shadow_rect.size.into(),
             shadow_radius.into(),
-            prim_shadow_rect.to_au(),
+            prim_shadow_rect.into(),
             Au::from_f32_px(blur_radius),
             clip_mode,
         )
     }
 }
 
 #[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum ClipItem {
-    Rectangle(LayoutRect, ClipMode),
-    RoundedRectangle(LayoutRect, BorderRadius, ClipMode),
-    Image { mask: ImageMask, visible_tiles: Option<Vec<VisibleMaskImageTile>> },
+    Rectangle(LayoutSize, ClipMode),
+    RoundedRectangle(LayoutSize, BorderRadius, ClipMode),
+    Image {
+        image: ImageKey,
+        size: LayoutSize,
+        repeat: bool,
+    },
     BoxShadow(BoxShadowClipSource),
 }
 
 fn compute_box_shadow_parameters(
-    shadow_rect: LayoutRect,
+    shadow_rect_fract_offset: LayoutPoint,
+    shadow_rect_size: LayoutSize,
     mut shadow_radius: BorderRadius,
     prim_shadow_rect: LayoutRect,
     blur_radius: f32,
     clip_mode: BoxShadowClipMode,
 ) -> BoxShadowClipSource {
     // Make sure corners don't overlap.
-    ensure_no_corner_overlap(&mut shadow_radius, &shadow_rect);
+    ensure_no_corner_overlap(&mut shadow_radius, shadow_rect_size);
 
-    // Get the fractional offsets required to match the
-    // source rect with a minimal rect.
-    let fract_offset = LayoutPoint::new(
-        shadow_rect.origin.x.fract().abs(),
-        shadow_rect.origin.y.fract().abs(),
-    );
     let fract_size = LayoutSize::new(
-        shadow_rect.size.width.fract().abs(),
-        shadow_rect.size.height.fract().abs(),
+        shadow_rect_size.width.fract().abs(),
+        shadow_rect_size.height.fract().abs(),
     );
 
     // Create a minimal size primitive mask to blur. In this
     // case, we ensure the size of each corner is the same,
     // to simplify the shader logic that stretches the blurred
     // result across the primitive.
     let max_corner_width = shadow_radius.top_left.width
                                 .max(shadow_radius.bottom_left.width)
@@ -920,39 +949,39 @@ fn compute_box_shadow_parameters(
     let min_shadow_rect_size = LayoutSize::new(
         2.0 * used_corner_width + blur_region,
         2.0 * used_corner_height + blur_region,
     );
 
     // The minimal rect to blur.
     let mut minimal_shadow_rect = LayoutRect::new(
         LayoutPoint::new(
-            blur_region + fract_offset.x,
-            blur_region + fract_offset.y,
+            blur_region + shadow_rect_fract_offset.x,
+            blur_region + shadow_rect_fract_offset.y,
         ),
         LayoutSize::new(
             min_shadow_rect_size.width + fract_size.width,
             min_shadow_rect_size.height + fract_size.height,
         ),
     );
 
     // If the width or height ends up being bigger than the original
     // primitive shadow rect, just blur the entire rect along that
     // axis and draw that as a simple blit. This is necessary for
     // correctness, since the blur of one corner may affect the blur
     // in another corner.
     let mut stretch_mode_x = BoxShadowStretchMode::Stretch;
-    if shadow_rect.size.width < minimal_shadow_rect.size.width {
-        minimal_shadow_rect.size.width = shadow_rect.size.width;
+    if shadow_rect_size.width < minimal_shadow_rect.size.width {
+        minimal_shadow_rect.size.width = shadow_rect_size.width;
         stretch_mode_x = BoxShadowStretchMode::Simple;
     }
 
     let mut stretch_mode_y = BoxShadowStretchMode::Stretch;
-    if shadow_rect.size.height < minimal_shadow_rect.size.height {
-        minimal_shadow_rect.size.height = shadow_rect.size.height;
+    if shadow_rect_size.height < minimal_shadow_rect.size.height {
+        minimal_shadow_rect.size.height = shadow_rect_size.height;
         stretch_mode_y = BoxShadowStretchMode::Simple;
     }
 
     // Expand the shadow rect by enough room for the blur to take effect.
     let shadow_rect_alloc_size = LayoutSize::new(
         2.0 * blur_region + minimal_shadow_rect.size.width.ceil(),
         2.0 * blur_region + minimal_shadow_rect.size.height.ceil(),
     );
@@ -970,24 +999,26 @@ fn compute_box_shadow_parameters(
         cache_key: None,
         clip_data_handle: GpuCacheHandle::new(),
         minimal_shadow_rect,
     }
 }
 
 impl ClipItem {
     pub fn new_box_shadow(
-        shadow_rect: LayoutRect,
+        shadow_rect_fract_offset: LayoutPoint,
+        shadow_rect_size: LayoutSize,
         mut shadow_radius: BorderRadius,
         prim_shadow_rect: LayoutRect,
         blur_radius: f32,
         clip_mode: BoxShadowClipMode,
     ) -> Self {
         let mut source = compute_box_shadow_parameters(
-            shadow_rect,
+            shadow_rect_fract_offset,
+            shadow_rect_size,
             shadow_radius,
             prim_shadow_rect,
             blur_radius,
             clip_mode,
         );
 
         fn needed_downscaling(source: &BoxShadowClipSource) -> Option<f32> {
             // This size is fairly arbitrary, but it's the same as the size that
@@ -1014,57 +1045,71 @@ impl ClipItem {
             shadow_radius.bottom_right.height *= downscale;
             shadow_radius.bottom_right.width *= downscale;
             shadow_radius.top_left.height *= downscale;
             shadow_radius.top_left.width *= downscale;
             shadow_radius.top_right.height *= downscale;
             shadow_radius.top_right.width *= downscale;
 
             let original_alloc_size = source.shadow_rect_alloc_size;
+
             source = compute_box_shadow_parameters(
-                shadow_rect.scale(downscale, downscale),
+                shadow_rect_fract_offset * downscale,
+                shadow_rect_size * downscale,
                 shadow_radius,
                 prim_shadow_rect,
                 blur_radius * downscale,
                 clip_mode,
             );
             source.original_alloc_size = original_alloc_size;
         }
         ClipItem::BoxShadow(source)
     }
 
     // Get an optional clip rect that a clip source can provide to
     // reduce the size of a primitive region. This is typically
     // used to eliminate redundant clips, and reduce the size of
     // any clip mask that eventually gets drawn.
-    fn get_local_clip_rect(&self) -> Option<LayoutRect> {
-        match *self {
-            ClipItem::Rectangle(clip_rect, ClipMode::Clip) => Some(clip_rect),
+    fn get_local_clip_rect(&self, local_pos: LayoutPoint) -> Option<LayoutRect> {
+        let size = match *self {
+            ClipItem::Rectangle(size, ClipMode::Clip) => Some(size),
             ClipItem::Rectangle(_, ClipMode::ClipOut) => None,
-            ClipItem::RoundedRectangle(clip_rect, _, ClipMode::Clip) => Some(clip_rect),
+            ClipItem::RoundedRectangle(size, _, ClipMode::Clip) => Some(size),
             ClipItem::RoundedRectangle(_, _, ClipMode::ClipOut) => None,
-            ClipItem::Image { ref mask, .. } if mask.repeat => None,
-            ClipItem::Image { ref mask, .. } => Some(mask.rect),
+            ClipItem::Image { repeat, size, .. } => {
+                if repeat {
+                    None
+                } else {
+                    Some(size)
+                }
+            }
             ClipItem::BoxShadow(..) => None,
-        }
+        };
+
+        size.map(|size| {
+            LayoutRect::new(local_pos, size)
+        })
     }
 
     fn get_clip_result_complex(
         &self,
+        local_pos: LayoutPoint,
         transform: &LayoutToWorldTransform,
         prim_world_rect: &WorldRect,
         world_rect: &WorldRect,
     ) -> ClipResult {
         let (clip_rect, inner_rect) = match *self {
-            ClipItem::Rectangle(clip_rect, ClipMode::Clip) => {
+            ClipItem::Rectangle(size, ClipMode::Clip) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
                 (clip_rect, Some(clip_rect))
             }
-            ClipItem::RoundedRectangle(ref clip_rect, ref radius, ClipMode::Clip) => {
-                let inner_clip_rect = extract_inner_rect_safe(clip_rect, radius);
-                (*clip_rect, inner_clip_rect)
+            ClipItem::RoundedRectangle(size, ref radius, ClipMode::Clip) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
+                let inner_clip_rect = extract_inner_rect_safe(&clip_rect, radius);
+                (clip_rect, inner_clip_rect)
             }
             ClipItem::Rectangle(_, ClipMode::ClipOut) |
             ClipItem::RoundedRectangle(_, _, ClipMode::ClipOut) |
             ClipItem::Image { .. } |
             ClipItem::BoxShadow(..) => {
                 return ClipResult::Partial
             }
         };
@@ -1096,94 +1141,104 @@ impl ClipItem {
                 ClipResult::Reject
             }
         }
     }
 
     // Check how a given clip source affects a local primitive region.
     fn get_clip_result(
         &self,
+        local_pos: LayoutPoint,
         prim_rect: &LayoutRect,
     ) -> ClipResult {
         match *self {
-            ClipItem::Rectangle(ref clip_rect, ClipMode::Clip) => {
+            ClipItem::Rectangle(size, ClipMode::Clip) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
+
                 if clip_rect.contains_rect(prim_rect) {
                     return ClipResult::Accept;
                 }
 
                 match clip_rect.intersection(prim_rect) {
                     Some(..) => {
                         ClipResult::Partial
                     }
                     None => {
                         ClipResult::Reject
                     }
                 }
             }
-            ClipItem::Rectangle(ref clip_rect, ClipMode::ClipOut) => {
+            ClipItem::Rectangle(size, ClipMode::ClipOut) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
+
                 if clip_rect.contains_rect(prim_rect) {
                     return ClipResult::Reject;
                 }
 
                 match clip_rect.intersection(prim_rect) {
                     Some(_) => {
                         ClipResult::Partial
                     }
                     None => {
                         ClipResult::Accept
                     }
                 }
             }
-            ClipItem::RoundedRectangle(ref clip_rect, ref radius, ClipMode::Clip) => {
+            ClipItem::RoundedRectangle(size, ref radius, ClipMode::Clip) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
+
                 // TODO(gw): Consider caching this in the ClipNode
                 //           if it ever shows in profiles.
                 // TODO(gw): extract_inner_rect_safe is overly
                 //           conservative for this code!
-                let inner_clip_rect = extract_inner_rect_safe(clip_rect, radius);
+                let inner_clip_rect = extract_inner_rect_safe(&clip_rect, radius);
                 if let Some(inner_clip_rect) = inner_clip_rect {
                     if inner_clip_rect.contains_rect(prim_rect) {
                         return ClipResult::Accept;
                     }
                 }
 
                 match clip_rect.intersection(prim_rect) {
                     Some(..) => {
                         ClipResult::Partial
                     }
                     None => {
                         ClipResult::Reject
                     }
                 }
             }
-            ClipItem::RoundedRectangle(ref clip_rect, ref radius, ClipMode::ClipOut) => {
+            ClipItem::RoundedRectangle(size, ref radius, ClipMode::ClipOut) => {
+                let clip_rect = LayoutRect::new(local_pos, size);
+
                 // TODO(gw): Consider caching this in the ClipNode
                 //           if it ever shows in profiles.
                 // TODO(gw): extract_inner_rect_safe is overly
                 //           conservative for this code!
-                let inner_clip_rect = extract_inner_rect_safe(clip_rect, radius);
+                let inner_clip_rect = extract_inner_rect_safe(&clip_rect, radius);
                 if let Some(inner_clip_rect) = inner_clip_rect {
                     if inner_clip_rect.contains_rect(prim_rect) {
                         return ClipResult::Reject;
                     }
                 }
 
                 match clip_rect.intersection(prim_rect) {
                     Some(_) => {
                         ClipResult::Partial
                     }
                     None => {
                         ClipResult::Accept
                     }
                 }
             }
-            ClipItem::Image { ref mask, .. } => {
-                if mask.repeat {
+            ClipItem::Image { size, repeat, .. } => {
+                if repeat {
                     ClipResult::Partial
                 } else {
-                    match mask.rect.intersection(prim_rect) {
+                    let mask_rect = LayoutRect::new(local_pos, size);
+                    match mask_rect.intersection(prim_rect) {
                         Some(..) => {
                             ClipResult::Partial
                         }
                         None => {
                             ClipResult::Reject
                         }
                     }
                 }
@@ -1298,16 +1353,17 @@ impl ClipNodeCollector {
 }
 
 // Add a clip node into the list of clips to be processed
 // for the current clip chain. Returns false if the clip
 // results in the entire primitive being culled out.
 fn add_clip_node_to_current_chain(
     handle: ClipDataHandle,
     clip_spatial_node_index: SpatialNodeIndex,
+    local_pos: LayoutPoint,
     spatial_node_index: SpatialNodeIndex,
     local_clip_rect: &mut LayoutRect,
     clip_node_info: &mut Vec<ClipNodeInfo>,
     clip_data_store: &ClipDataStore,
     clip_scroll_tree: &ClipScrollTree,
 ) -> bool {
     let clip_node = &clip_data_store[handle];
     let clip_spatial_node = &clip_scroll_tree.spatial_nodes[clip_spatial_node_index.0];
@@ -1331,17 +1387,17 @@ fn add_clip_node_to_current_chain(
         xf.map(|xf| {
             ClipSpaceConversion::Transform(xf.with_destination::<WorldPixel>())
         })
     };
 
     // If we can convert spaces, try to reduce the size of the region
     // requested, and cache the conversion information for the next step.
     if let Some(conversion) = conversion {
-        if let Some(clip_rect) = clip_node.item.get_local_clip_rect() {
+        if let Some(clip_rect) = clip_node.item.get_local_clip_rect(local_pos) {
             match conversion {
                 ClipSpaceConversion::Local => {
                     *local_clip_rect = match local_clip_rect.intersection(&clip_rect) {
                         Some(rect) => rect,
                         None => return false,
                     };
                 }
                 ClipSpaceConversion::ScaleOffset(ref scale_offset) => {
@@ -1361,15 +1417,16 @@ fn add_clip_node_to_current_chain(
                     //           I have left this for now until we
                     //           find some good test cases where this
                     //           would be a worthwhile perf win.
                 }
             }
         }
         clip_node_info.push(ClipNodeInfo {
             conversion,
+            local_pos,
             handle,
             spatial_node_index: clip_spatial_node_index,
         })
     }
 
     true
 }
--- a/gfx/wr/webrender/src/display_list_flattener.rs
+++ b/gfx/wr/webrender/src/display_list_flattener.rs
@@ -912,32 +912,33 @@ impl<'a> DisplayListFlattener<'a> {
                     // as a clip chain (one clip item per node), eventually parented
                     // to the parent clip node. For a user defined clip chain, we will
                     // need to walk the linked list of clip chain nodes for each clip
                     // node, accumulating them into one clip chain that is then
                     // parented to the clip chain parent.
 
                     for _ in 0 .. item_clip_node.count {
                         // Get the id of the clip sources entry for that clip chain node.
-                        let (handle, spatial_node_index) = {
+                        let (handle, spatial_node_index, local_pos) = {
                             let clip_chain = self
                                 .clip_store
                                 .get_clip_chain(clip_node_clip_chain_id);
 
                             clip_node_clip_chain_id = clip_chain.parent_clip_chain_id;
 
-                            (clip_chain.handle, clip_chain.spatial_node_index)
+                            (clip_chain.handle, clip_chain.spatial_node_index, clip_chain.local_pos)
                         };
 
                         // Add a new clip chain node, which references the same clip sources, and
                         // parent it to the current parent.
                         clip_chain_id = self
                             .clip_store
                             .add_clip_chain_node(
                                 handle,
+                                local_pos,
                                 spatial_node_index,
                                 clip_chain_id,
                             );
                     }
                 }
 
                 // Map the last entry in the clip chain to the supplied ClipId. This makes
                 // this ClipId available as a source to other user defined clip chains.
@@ -979,26 +980,26 @@ impl<'a> DisplayListFlattener<'a> {
     }
 
     // Given a list of clip sources, a positioning node and
     // a parent clip chain, return a new clip chain entry.
     // If the supplied list of clip sources is empty, then
     // just return the parent clip chain id directly.
     fn build_clip_chain(
         &mut self,
-        clip_items: Vec<ClipItemKey>,
+        clip_items: Vec<(LayoutPoint, ClipItemKey)>,
         spatial_node_index: SpatialNodeIndex,
         parent_clip_chain_id: ClipChainId,
     ) -> ClipChainId {
         if clip_items.is_empty() {
             parent_clip_chain_id
         } else {
             let mut clip_chain_id = parent_clip_chain_id;
 
-            for item in clip_items {
+            for (local_pos, item) in clip_items {
                 // Intern this clip item, and store the handle
                 // in the clip chain node.
                 let handle = self.resources
                     .clip_interner
                     .intern(&item, || {
                         ClipItemSceneData {
                             // The only type of clip items that exist in the per-primitive
                             // clip items are box shadows, and they don't contribute a
@@ -1007,16 +1008,17 @@ impl<'a> DisplayListFlattener<'a> {
                             // case the entire clip_items API on primitives can be removed.
                             clip_rect: LayoutRect::max_rect(),
                         }
                     });
 
                 clip_chain_id = self.clip_store
                                     .add_clip_chain_node(
                                         handle,
+                                        local_pos,
                                         spatial_node_index,
                                         clip_chain_id,
                                     );
             }
 
             clip_chain_id
         }
     }
@@ -1102,17 +1104,17 @@ impl<'a> DisplayListFlattener<'a> {
     }
 
     /// Convenience interface that creates a primitive entry and adds it
     /// to the draw list.
     pub fn add_primitive(
         &mut self,
         clip_and_scroll: ScrollNodeAndClipChain,
         info: &LayoutPrimitiveInfo,
-        clip_items: Vec<ClipItemKey>,
+        clip_items: Vec<(LayoutPoint, ClipItemKey)>,
         key_kind: PrimitiveKeyKind,
     ) {
         // If a shadow context is not active, then add the primitive
         // directly to the parent picture.
         if self.pending_shadow_items.is_empty() {
             if key_kind.is_visible() {
                 let clip_chain_id = self.build_clip_chain(
                     clip_items,
@@ -1582,26 +1584,27 @@ impl<'a> DisplayListFlattener<'a> {
         // handle to a clip chain node, parented to form a chain.
         // TODO(gw): We could re-structure this to share some of the
         //           interning and chaining code.
 
         // Build the clip sources from the supplied region.
         let handle = self
             .resources
             .clip_interner
-            .intern(&ClipItemKey::rectangle(clip_region.main, ClipMode::Clip), || {
+            .intern(&ClipItemKey::rectangle(clip_region.main.size, ClipMode::Clip), || {
                 ClipItemSceneData {
                     clip_rect: clip_region.main,
                 }
             });
 
         parent_clip_chain_index = self
             .clip_store
             .add_clip_chain_node(
                 handle,
+                clip_region.main.origin,
                 spatial_node,
                 parent_clip_chain_index,
             );
         clip_count += 1;
 
         if let Some(ref image_mask) = clip_region.image_mask {
             let handle = self
                 .resources
@@ -1611,36 +1614,38 @@ impl<'a> DisplayListFlattener<'a> {
                         clip_rect: image_mask.get_local_clip_rect().unwrap_or(LayoutRect::max_rect()),
                     }
                 });
 
             parent_clip_chain_index = self
                 .clip_store
                 .add_clip_chain_node(
                     handle,
+                    image_mask.rect.origin,
                     spatial_node,
                     parent_clip_chain_index,
                 );
             clip_count += 1;
         }
 
         for region in clip_region.complex_clips {
             let handle = self
                 .resources
                 .clip_interner
-                .intern(&ClipItemKey::rounded_rect(region.rect, region.radii, region.mode), || {
+                .intern(&ClipItemKey::rounded_rect(region.rect.size, region.radii, region.mode), || {
                     ClipItemSceneData {
                         clip_rect: region.get_local_clip_rect().unwrap_or(LayoutRect::max_rect()),
                     }
                 });
 
             parent_clip_chain_index = self
                 .clip_store
                 .add_clip_chain_node(
                     handle,
+                    region.rect.origin,
                     spatial_node,
                     parent_clip_chain_index,
                 );
             clip_count += 1;
         }
 
         // Map the supplied ClipId -> clip chain id.
         self.id_to_index_mapper.add_clip_chain(
--- a/gfx/wr/webrender/src/gpu_types.rs
+++ b/gfx/wr/webrender/src/gpu_types.rs
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use api::{
     DevicePoint, DeviceSize, DeviceRect, LayoutRect, LayoutToWorldTransform, LayoutTransform,
     PremultipliedColorF, LayoutToPictureTransform, PictureToLayoutTransform, PicturePixel,
-    WorldPixel, WorldToLayoutTransform,
+    WorldPixel, WorldToLayoutTransform, LayoutPoint,
 };
 use clip_scroll_tree::{ClipScrollTree, ROOT_SPATIAL_NODE_INDEX, SpatialNodeIndex};
 use gpu_cache::{GpuCacheAddress, GpuDataRequest};
 use internal_types::FastHashMap;
 use prim_store::EdgeAaSegmentMask;
 use render_task::RenderTaskAddress;
 use std::i32;
 use util::{TransformedRectKind, MatrixHelpers};
@@ -135,16 +135,18 @@ pub struct BorderInstance {
 #[repr(C)]
 pub struct ClipMaskInstance {
     pub render_task_address: RenderTaskAddress,
     pub clip_transform_id: TransformPaletteId,
     pub prim_transform_id: TransformPaletteId,
     pub segment: i32,
     pub clip_data_address: GpuCacheAddress,
     pub resource_address: GpuCacheAddress,
+    pub local_pos: LayoutPoint,
+    pub tile_rect: LayoutRect,
 }
 
 /// A border corner dot or dash drawn into the clipping mask.
 #[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 #[repr(C)]
 pub struct ClipMaskBorderCornerDotDash {
--- a/gfx/wr/webrender/src/hit_test.rs
+++ b/gfx/wr/webrender/src/hit_test.rs
@@ -29,23 +29,30 @@ pub struct HitTestSpatialNode {
 
 pub struct HitTestClipNode {
     /// A particular point must be inside all of these regions to be considered clipped in
     /// for the purposes of a hit test.
     region: HitTestRegion,
 }
 
 impl HitTestClipNode {
-    fn new(node: &ClipNode) -> Self {
+    fn new(local_pos: LayoutPoint, node: &ClipNode) -> Self {
         let region = match node.item {
-            ClipItem::Rectangle(ref rect, mode) => HitTestRegion::Rectangle(*rect, mode),
-            ClipItem::RoundedRectangle(ref rect, ref radii, ref mode) =>
-                HitTestRegion::RoundedRectangle(*rect, *radii, *mode),
-            ClipItem::Image { ref mask, .. } =>
-                HitTestRegion::Rectangle(mask.rect, ClipMode::Clip),
+            ClipItem::Rectangle(size, mode) => {
+                let rect = LayoutRect::new(local_pos, size);
+                HitTestRegion::Rectangle(rect, mode)
+            }
+            ClipItem::RoundedRectangle(size, radii, mode) => {
+                let rect = LayoutRect::new(local_pos, size);
+                HitTestRegion::RoundedRectangle(rect, radii, mode)
+            }
+            ClipItem::Image { size, .. } => {
+                let rect = LayoutRect::new(local_pos, size);
+                HitTestRegion::Rectangle(rect, ClipMode::Clip)
+            }
             ClipItem::BoxShadow(_) => HitTestRegion::Invalid,
         };
 
         HitTestClipNode {
             region,
         }
     }
 }
@@ -165,17 +172,17 @@ impl HitTester {
             });
         }
 
         // For each clip chain node, extract the clip node from the clip
         // data store, and store it inline with the clip chain node.
         for node in &clip_store.clip_chain_nodes {
             let clip_node = &clip_data_store[node.handle];
             self.clip_chains.push(HitTestClipChainNode {
-                region: HitTestClipNode::new(clip_node),
+                region: HitTestClipNode::new(node.local_pos, clip_node),
                 spatial_node_index: node.spatial_node_index,
                 parent_clip_chain_id: HitTestClipChainId(node.parent_clip_chain_id.0),
             });
         }
     }
 
     fn is_point_clipped_in_for_clip_chain(
         &self,
--- a/gfx/wr/webrender/src/prim_store.rs
+++ b/gfx/wr/webrender/src/prim_store.rs
@@ -1,13 +1,13 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use api::{AlphaType, BorderRadius, ClipMode, ColorF, PictureRect, ColorU};
+use api::{AlphaType, BorderRadius, ClipMode, ColorF, PictureRect, ColorU, LayoutVector2D};
 use api::{DeviceIntRect, DeviceIntSize, DevicePixelScale, ExtendMode, DeviceRect, LayoutSideOffsetsAu};
 use api::{FilterOp, GlyphInstance, GradientStop, ImageKey, ImageRendering, TileOffset, RepeatMode};
 use api::{RasterSpace, LayoutPoint, LayoutRect, LayoutSideOffsets, LayoutSize, LayoutToWorldTransform};
 use api::{PremultipliedColorF, PropertyBinding, Shadow, YuvColorSpace, YuvFormat};
 use api::{DeviceIntSideOffsets, WorldPixel, BoxShadowClipMode, NormalBorder, WorldRect, LayoutToWorldScale};
 use api::{PicturePixel, RasterPixel, ColorDepth, LineStyle, LineOrientation, LayoutSizeAu, AuHelpers, LayoutVector2DAu};
 use app_units::Au;
 use border::{get_max_scale_for_border, build_border_instances, create_border_segments};
@@ -828,17 +828,17 @@ impl PrimitiveKeyKind {
 
                 // FIXME(emilio): Is this the best place to do this?
                 border.normalize(&widths);
 
                 let mut brush_segments = Vec::new();
                 let mut border_segments = Vec::new();
 
                 create_border_segments(
-                    rect,
+                    rect.size,
                     &border,
                     &widths,
                     &mut border_segments,
                     &mut brush_segments,
                 );
 
                 PrimitiveTemplateKind::NormalBorder {
                     template: Box::new(NormalBorderTemplate {
@@ -849,17 +849,17 @@ impl PrimitiveKeyKind {
                     })
                 }
             }
             PrimitiveKeyKind::ImageBorder {
                 request,
                 ref nine_patch,
                 ..
             } => {
-                let brush_segments = nine_patch.create_segments(rect);
+                let brush_segments = nine_patch.create_segments(rect.size);
 
                 PrimitiveTemplateKind::ImageBorder {
                     request,
                     brush_segments,
                 }
             }
             PrimitiveKeyKind::Rectangle { color, .. } => {
                 PrimitiveTemplateKind::Rectangle {
@@ -916,17 +916,17 @@ impl PrimitiveKeyKind {
                         offset: stop.offset,
                         color,
                     }
                 }).collect();
 
                 let mut brush_segments = Vec::new();
 
                 if let Some(ref nine_patch) = nine_patch {
-                    brush_segments = nine_patch.create_segments(rect);
+                    brush_segments = nine_patch.create_segments(rect.size);
                 }
 
                 // Save opacity of the stops for use in
                 // selecting which pass this gradient
                 // should be drawn in.
                 let stops_opacity = PrimitiveOpacity::from_alpha(min_alpha);
 
                 PrimitiveTemplateKind::LinearGradient {
@@ -950,17 +950,17 @@ impl PrimitiveKeyKind {
                 nine_patch,
                 center,
                 stops,
                 ..
             } => {
                 let mut brush_segments = Vec::new();
 
                 if let Some(ref nine_patch) = nine_patch {
-                    brush_segments = nine_patch.create_segments(rect);
+                    brush_segments = nine_patch.create_segments(rect.size);
                 }
 
                 let stops = stops.iter().map(|stop| {
                     GradientStop {
                         offset: stop.offset,
                         color: stop.color.into(),
                     }
                 }).collect();
@@ -1523,17 +1523,17 @@ pub struct VisibleImageTile {
     pub local_clip_rect: LayoutRect,
 }
 
 #[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct VisibleMaskImageTile {
     pub tile_offset: TileOffset,
-    pub handle: GpuCacheHandle,
+    pub tile_rect: LayoutRect,
 }
 
 #[derive(Debug)]
 pub struct VisibleGradientTile {
     pub handle: GpuCacheHandle,
     pub local_rect: LayoutRect,
     pub local_clip_rect: LayoutRect,
 }
@@ -2052,43 +2052,54 @@ impl ClipCorner {
             inner_radius_y: inner_radius,
         }
     }
 }
 
 #[derive(Debug)]
 #[repr(C)]
 pub struct ImageMaskData {
-    /// The local rect of the whole masked area.
-    pub local_mask_rect: LayoutRect,
-    /// The local rect of an individual tile.
-    pub local_tile_rect: LayoutRect,
+    /// The local size of the whole masked area.
+    pub local_mask_size: LayoutSize,
 }
 
 impl ToGpuBlocks for ImageMaskData {
     fn write_gpu_blocks(&self, mut request: GpuDataRequest) {
-        request.push(self.local_mask_rect);
-        request.push(self.local_tile_rect);
+        request.push([
+            self.local_mask_size.width,
+            self.local_mask_size.height,
+            0.0,
+            0.0,
+        ]);
     }
 }
 
 #[derive(Debug)]
 pub struct ClipData {
     rect: ClipRect,
     top_left: ClipCorner,
     top_right: ClipCorner,
     bottom_left: ClipCorner,
     bottom_right: ClipCorner,
 }
 
 impl ClipData {
-    pub fn rounded_rect(rect: &LayoutRect, radii: &BorderRadius, mode: ClipMode) -> ClipData {
+    pub fn rounded_rect(size: LayoutSize, radii: &BorderRadius, mode: ClipMode) -> ClipData {
+        // TODO(gw): For simplicity, keep most of the clip GPU structs the
+        //           same as they were, even though the origin is now always
+        //           zero, since they are in the clip's local space. In future,
+        //           we could reduce the GPU cache size of ClipData.
+        let rect = LayoutRect::new(
+            LayoutPoint::zero(),
+            size,
+        );
+
         ClipData {
             rect: ClipRect {
-                rect: *rect,
+                rect,
                 mode: mode as u32 as f32,
             },
             top_left: ClipCorner {
                 rect: LayoutRect::new(
                     LayoutPoint::new(rect.origin.x, rect.origin.y),
                     LayoutSize::new(radii.top_left.width, radii.top_left.height),
                 ),
                 outer_radius_x: radii.top_left.width,
@@ -2133,17 +2144,26 @@ impl ClipData {
                 outer_radius_x: radii.bottom_right.width,
                 outer_radius_y: radii.bottom_right.height,
                 inner_radius_x: 0.0,
                 inner_radius_y: 0.0,
             },
         }
     }
 
-    pub fn uniform(rect: LayoutRect, radius: f32, mode: ClipMode) -> ClipData {
+    pub fn uniform(size: LayoutSize, radius: f32, mode: ClipMode) -> ClipData {
+        // TODO(gw): For simplicity, keep most of the clip GPU structs the
+        //           same as they were, even though the origin is now always
+        //           zero, since they are in the clip's local space. In future,
+        //           we could reduce the GPU cache size of ClipData.
+        let rect = LayoutRect::new(
+            LayoutPoint::zero(),
+            size,
+        );
+
         ClipData {
             rect: ClipRect {
                 rect,
                 mode: mode as u32 as f32,
             },
             top_left: ClipCorner::uniform(
                 LayoutRect::new(
                     LayoutPoint::new(rect.origin.x, rect.origin.y),
@@ -3469,17 +3489,16 @@ impl PrimitiveStore {
                                     frame_state.gpu_cache,
                                 );
 
                                 let mut handle = GpuCacheHandle::new();
                                 if let Some(mut request) = frame_state.gpu_cache.request(&mut handle) {
                                     request.push(PremultipliedColorF::WHITE);
                                     request.push(PremultipliedColorF::WHITE);
                                     request.push([tile.rect.size.width, tile.rect.size.height, 0.0, 0.0]);
-                                    request.write_segment(tile.rect, [0.0; 4]);
                                 }
 
                                 image_instance.visible_tiles.push(VisibleImageTile {
                                     tile_offset: tile.offset,
                                     handle,
                                     edge_flags: tile.edge_flags & edge_flags,
                                     local_rect: tile.rect,
                                     local_clip_rect: tight_clip_rect,
@@ -3509,30 +3528,29 @@ impl PrimitiveStore {
                         &prim_instance.combined_local_clip_rect,
                         &prim_data.prim_rect,
                         &stretch_size,
                         &tile_spacing,
                         prim_context,
                         frame_state,
                         &pic_context.dirty_world_rect,
                         &mut scratch.gradient_tiles,
-                        &mut |rect, mut request| {
+                        &mut |_, mut request| {
                             request.push([
                                 start_point.x,
                                 start_point.y,
                                 end_point.x,
                                 end_point.y,
                             ]);
                             request.push([
                                 pack_as_float(*extend_mode as u32),
                                 stretch_size.width,
                                 stretch_size.height,
                                 0.0,
                             ]);
-                            request.write_segment(*rect, [0.0; 4]);
                         }
                     );
 
                     if visible_tiles_range.is_empty() {
                         prim_instance.bounding_rect = None;
                     }
                 }
 
@@ -3549,30 +3567,29 @@ impl PrimitiveStore {
                         &prim_instance.combined_local_clip_rect,
                         &prim_data.prim_rect,
                         &stretch_size,
                         &tile_spacing,
                         prim_context,
                         frame_state,
                         &pic_context.dirty_world_rect,
                         &mut scratch.gradient_tiles,
-                        &mut |rect, mut request| {
+                        &mut |_, mut request| {
                             request.push([
                                 center.x,
                                 center.y,
                                 params.start_radius,
                                 params.end_radius,
                             ]);
                             request.push([
                                 params.ratio_xy,
                                 pack_as_float(*extend_mode as u32),
                                 stretch_size.width,
                                 stretch_size.height,
                             ]);
-                            request.write_segment(*rect, [0.0; 4]);
                         },
                     );
 
                     if visible_tiles_range.is_empty() {
                         prim_instance.bounding_rect = None;
                     }
                 }
 
@@ -3747,22 +3764,22 @@ impl<'a> GpuDataRequest<'a> {
             // when necessary while scrolling.
             if !clip_instance.flags.contains(ClipNodeFlags::SAME_SPATIAL_NODE) {
                 continue;
             }
 
             local_clip_count += 1;
 
             let (local_clip_rect, radius, mode) = match clip_node.item {
-                ClipItem::RoundedRectangle(rect, radii, clip_mode) => {
+                ClipItem::RoundedRectangle(size, radii, clip_mode) => {
                     rect_clips_only = false;
-                    (rect, Some(radii), clip_mode)
+                    (LayoutRect::new(clip_instance.local_pos, size), Some(radii), clip_mode)
                 }
-                ClipItem::Rectangle(rect, mode) => {
-                    (rect, None, mode)
+                ClipItem::Rectangle(size, mode) => {
+                    (LayoutRect::new(clip_instance.local_pos, size), None, mode)
                 }
                 ClipItem::BoxShadow(ref info) => {
                     rect_clips_only = false;
 
                     // For inset box shadows, we can clip out any
                     // pixels that are inside the shadow region
                     // and are beyond the inner rect, as they can't
                     // be affected by the blur radius.
@@ -3770,19 +3787,22 @@ impl<'a> GpuDataRequest<'a> {
                         BoxShadowClipMode::Outset => None,
                         BoxShadowClipMode::Inset => Some(ClipMode::ClipOut),
                     };
 
                     // Push a region into the segment builder where the
                     // box-shadow can have an effect on the result. This
                     // ensures clip-mask tasks get allocated for these
                     // pixel regions, even if no other clips affect them.
+                    let prim_shadow_rect = info.prim_shadow_rect.translate(
+                        &LayoutVector2D::new(clip_instance.local_pos.x, clip_instance.local_pos.y),
+                    );
                     segment_builder.push_mask_region(
-                        info.prim_shadow_rect,
-                        info.prim_shadow_rect.inflate(
+                        prim_shadow_rect,
+                        prim_shadow_rect.inflate(
                             -0.5 * info.original_alloc_size.width,
                             -0.5 * info.original_alloc_size.height,
                         ),
                         inner_clip_mode,
                     );
 
                     continue;
                 }
@@ -3891,17 +3911,17 @@ impl PrimitiveInstance {
                 prim_clip_chain,
                 &mut frame_state.segment_builder,
                 frame_state.clip_store,
                 resources,
             ) {
                 frame_state.segment_builder.build(|segment| {
                     segments.push(
                         BrushSegment::new(
-                            segment.rect,
+                            segment.rect.translate(&LayoutVector2D::new(-prim_local_rect.origin.x, -prim_local_rect.origin.y)),
                             segment.has_mask,
                             segment.edge_flags,
                             [0.0; 4],
                             BrushFlags::empty(),
                         ),
                     );
                 });
             }
@@ -3922,16 +3942,17 @@ impl PrimitiveInstance {
                     .segment_instances
                     .push(instance);
             };
         }
     }
 
     fn update_clip_task_for_brush(
         &mut self,
+        prim_origin: LayoutPoint,
         prim_local_clip_rect: LayoutRect,
         root_spatial_node_index: SpatialNodeIndex,
         prim_bounding_rect: WorldRect,
         prim_context: &PrimitiveContext,
         prim_clip_chain: &ClipChainInstance,
         pic_context: &PictureContext,
         pic_state: &mut PictureState,
         frame_context: &FrameBuildingContext,
@@ -4070,17 +4091,17 @@ impl PrimitiveInstance {
             for segment in segments {
                 // Build a clip chain for the smaller segment rect. This will
                 // often manage to eliminate most/all clips, and sometimes
                 // clip the segment completely.
                 let segment_clip_chain = frame_state
                     .clip_store
                     .build_clip_chain_instance(
                         self.clip_chain_id,
-                        segment.local_rect,
+                        segment.local_rect.translate(&LayoutVector2D::new(prim_origin.x, prim_origin.y)),
                         prim_local_clip_rect,
                         prim_context.spatial_node_index,
                         &pic_state.map_local_to_pic,
                         &pic_state.map_pic_to_world,
                         &frame_context.clip_scroll_tree,
                         frame_state.gpu_cache,
                         frame_state.resource_cache,
                         frame_context.device_pixel_scale,
@@ -4137,16 +4158,17 @@ impl PrimitiveInstance {
             frame_state,
             prim_store,
             resources,
             scratch,
         );
 
         // First try to  render this primitive's mask using optimized brush rendering.
         if self.update_clip_task_for_brush(
+            prim_local_rect.origin,
             prim_local_clip_rect,
             root_spatial_node_index,
             prim_bounding_rect,
             prim_context,
             &clip_chain,
             pic_context,
             pic_state,
             frame_context,
--- a/gfx/wr/webrender/src/render_task.rs
+++ b/gfx/wr/webrender/src/render_task.rs
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use api::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DeviceSize, DeviceIntSideOffsets};
-use api::{DevicePixelScale, ImageDescriptor, ImageFormat};
+use api::{DevicePixelScale, ImageDescriptor, ImageFormat, LayoutPoint};
 use api::{LineStyle, LineOrientation, LayoutSize, ColorF, DirtyRect};
 #[cfg(feature = "pathfinder")]
 use api::FontRenderMode;
 use border::BorderSegmentCacheKey;
 use box_shadow::{BoxShadowCacheKey};
 use clip::{ClipDataStore, ClipItem, ClipStore, ClipNodeRange};
 use clip_scroll_tree::SpatialNodeIndex;
 use device::TextureFilter;
@@ -248,16 +248,17 @@ pub struct CacheMaskTask {
     pub clip_node_range: ClipNodeRange,
 }
 
 #[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct ClipRegionTask {
     pub clip_data_address: GpuCacheAddress,
+    pub local_pos: LayoutPoint,
 }
 
 #[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct TileBlit {
     pub target: CacheItem,
     pub offset: DeviceIntPoint,
@@ -582,16 +583,17 @@ impl RenderTask {
                         render_tasks,
                         None,
                         false,
                         |render_tasks| {
                             // Draw the rounded rect.
                             let mask_task = RenderTask::new_rounded_rect_mask(
                                 cache_size,
                                 clip_data_address,
+                                info.minimal_shadow_rect.origin,
                             );
 
                             let mask_task_id = render_tasks.add(mask_task);
 
                             // Blur it
                             let blur_render_task = RenderTask::new_blur(
                                 blur_radius_dp,
                                 mask_task_id,
@@ -623,22 +625,24 @@ impl RenderTask {
             }),
             ClearMode::One,
         )
     }
 
     pub fn new_rounded_rect_mask(
         size: DeviceIntSize,
         clip_data_address: GpuCacheAddress,
+        local_pos: LayoutPoint,
     ) -> Self {
         RenderTask::with_dynamic_location(
             size,
             Vec::new(),
             RenderTaskKind::ClipRegion(ClipRegionTask {
                 clip_data_address,
+                local_pos,
             }),
             ClearMode::One,
         )
     }
 
     // Construct a render task to apply a blur to a primitive.
     // The render task chain that is constructed looks like:
     //
--- a/gfx/wr/webrender/src/renderer.rs
+++ b/gfx/wr/webrender/src/renderer.rs
@@ -529,16 +529,26 @@ pub(crate) mod desc {
                 count: 1,
                 kind: VertexAttributeKind::I32,
             },
             VertexAttribute {
                 name: "aClipDataResourceAddress",
                 count: 4,
                 kind: VertexAttributeKind::U16,
             },
+            VertexAttribute {
+                name: "aClipLocalPos",
+                count: 2,
+                kind: VertexAttributeKind::F32,
+            },
+            VertexAttribute {
+                name: "aClipTileRect",
+                count: 4,
+                kind: VertexAttributeKind::F32,
+            }
         ],
     };
 
     pub const GPU_CACHE_UPDATE: VertexDescriptor = VertexDescriptor {
         vertex_attributes: &[
             VertexAttribute {
                 name: "aPosition",
                 count: 2,
--- a/gfx/wr/webrender/src/tiling.rs
+++ b/gfx/wr/webrender/src/tiling.rs
@@ -647,16 +647,17 @@ impl RenderTarget for AlphaRenderTarget 
                     &ctx.resources.clip_data_store,
                 );
             }
             RenderTaskKind::ClipRegion(ref task) => {
                 let task_address = render_tasks.get_task_address(task_id);
                 self.clip_batcher.add_clip_region(
                     task_address,
                     task.clip_data_address,
+                    task.local_pos,
                 );
             }
             RenderTaskKind::Scaling(ref info) => {
                 info.add_instances(
                     &mut self.scalings,
                     render_tasks.get_task_address(task_id),
                     render_tasks.get_task_address(task.children[0]),
                 );
index c40699001cd93f31498fec59ee8fa1277213ed74..f10110eae371b4480aacd3fd25b453fc569aa64d
GIT binary patch
literal 16127
zc%1Eedsx!<`#0s9Wn0$LT;(C_TTWRTD>F6aJC|!M58F&k1ue;%;Sp3+LYid<%R_4h
zd0ee@rQi`2kDU}050wQfD3+orf{6!21fKVYw*7v8J%2s_J-e>_T;}_5pI-OtzV8oQ
z{lV+-rv_ULU@+LHN4`7s6AY$@2R{a@KL&q!R21(CgSoaHIrR0hggogWsr)_;)2FO`
zBU}=C7j7N@mRP7qd%A+P@xK{Dqm=F2_8dOB{(8#B?N@hQ|N8c`-?C|^iab2BD~f)?
z+WcyCJ1fh>)aN!LyZui@5O&{|Ju#oGx3fH?cV%VJ-R@cGU|DHZ{~)=ZH0`RMQY(+C
zC&~PP>4u+Alp&kv8>a&<Cr2FzD$y=w>4E3<f1m$8|9$@Z{P+3q^Z&1BLf!HbP2}X*
z;yC8ecJ8c)z&j(XC1Um}!m8G79SnA&w=CVdG$-Y3{`N_ulW`$Db(b{h+<0wpDScLe
zO_G|fc7(x(-}-%SjPm@k+AHSRC-mN!t}%_1ORZzRfV3~wcY1Jc+1-n?0tOq8Y}!}8
z-sVb<+n?6Aa<)&#R+(27^wuaQTylq6_)0P)Z{d%WKVdc()9x1i_iPe<&p?<#RgEMz
zyf;xYSKv7<!l9#~UAEOB4_4b;s?kUJ{FmNa;T(~h5#dxj(UjCP)G*Rld(jjI3%AKK
zxRdhd9-FM3lm`>@+rtL;OEhCO*xc@jq_UwZg)HuXA-L*1t5o#G@z3que|mh(l!^J~
zp>)B&aJp_m5T88lbIQJHor$BRKJ1aq=HmWuN{$B<Crr-o?Mez4NbkHRL_b>N2s?k_
z-3T`AkD?!JGIHKN$QsB)JsOBCoL}sYN-HfIKku@06sU`8MV&nMAA8&Z`_yAq-=YLX
z>MsADiRHWWFlH(HQ8m!_k@AaQ)95Q79I(mD+5V8vt2^63PHLX0>kdoG94ZU5IH3=e
zJ@9$j{kMM(+t6|f;P-gejDS_R2FE5|?74CKChy)^m<bI;)Yi83#TGREJ7dpP#~!~j
zLUnCHOXBl0CKihbq{5={6$@*CL3s^sCGXA(jJ!Qx96M&8imD>FV0qScPAxIoO^-GM
zvkrWh_9v>?pt$JDS%Z=yJ~3yWww-QWom3cXruS%-)hKK@#P>^j3C7)T1@mKHpA+`2
z#{^vy^BK~-ZmCOB*}@81L6+Y6!DGjO8a^9*J&b)@Uptxgma3YXy~blBr(fV;<$9L-
zj~=7;#a%riI8910_7N11I~PqXzAbq_Ngi1F$b2In)>%9p@W+EIHh<=<EO|bVmzf?W
zz<IuT9UC;RFok)1%UKcq#>lhP#}efc(Z=6`j>uie4VtbyonBU;e_qc6ET3*YHskx9
z@d=kmgNJu<s=0GzCc$Q+#8t-wVZ)7U9M7vuqXYCF{%*s_3Bl!OW`s3(ZP@h)Hhg#2
zC=|708+?CY2A?<fZ$-^89bNc1Pj<W){O5c<*p#!|x)XNQDZUq(yGsp9i{1r{@4yah
zI_X(PoZ50y3O4+gvtsJr6`Ln%4^d15deM8EM>%mV<GC4uJ@5{I^D9|;3&kmCF|TdP
z4d_owlx0|h^0*|%`?ChMZl$|nkKDiKtS~8CS@Qe9ClyahtlM&cWp>Y?MFKc&ZK*#+
z-(FH@Q<_FMcWC*lXnkPuceu2QxAe~?=6gYteIZM)yL2_2F~C5e&KYC7>P54->&8(b
zpTJIduXY5{Ee8&@sn1zisuUw4ato&WGT_5b`mpoYE@fTV%=`+4HV&YlXKqJbiRj*P
zs%a=@l|TFx4Cdj@dHj^#XVYoGNGXM>?67GSaRP!F-^PChe+C9KJ?^$H-lxL%lyPXQ
z-v-omdkgd4kpjEEfSvG;rL=P}*nzcf>%8tC-LRH^xAZ;mO-0uPD+qVL^gLl=I}B!W
zK5Jz7i;grpsw==4mpz4y>O4(j2Jm8Fu;>k+;X6ypn0DO;j3=e*;T+dkd=k2JJ^+52
zUb+JI$aULjU0tjrw&Wx|&G=+$KgG$h)ju=P9zGO+fsX--I==xw)zsXHO|L?=8&n2w
z@yWAyu^mXO$^gXVb(9k$<8h50MoN{fh*beSM1O1`;6DCpM^~R;cpb-Apt96Y+O3}(
zFbk&VGXQJa9<U^4#a<n$PeElFpFvXaY1J|$ZWSF110KAUC9qpsXhXHvKdbn!Ds!t(
zwQ*R}$2#YA{T_81y@UR`%Fvc8{{>-zuDMJ9PQrBq$MnADU_M#;mTgO%lD8RNR~ll6
zkf$-85<EKu;^Fmp6So#3@1cK5nEOCaex9LiVDPRG`%iT~jjXN4^FlLH2YL$f7D$XM
zK*PSBZnE&$2P67zMq%2>&K3)wQszS*H608+Xqa1M1FFY$Ptgw~QTxPK9F))%0rVR_
z86W)(BfA>K(@1HBTW0rSUH6Rb04Bj~LsZC7u>U)i12!4oNn)RiuBeAB!f7uG53{SE
zENsMTUeoSMwOeOr5a57{lV_>mVuzf^4zrgzw7YZ>2IzDEW~<3kJ)_yCFW*5R_l&XI
z&Yk!K%!MoBW>STAnG-KLT4JXnT{(d$+yb^gT4PAzki$C-GnEAhZ4d1UF!sDpQi2;p
zbXsMFZN_;}kFJEl-e+OzvQ#q&N>nG(wAU~koQ(Eb*gu+lvQuO}+l^4~0}8>$Bcj|G
zq#=!*rnnA5e!@>0$x)Beh}V@ZZD6_FD&B5X(@8@jfm!EWn9i1pR;=d5=U{0;sJtxX
zrz>wkhN0JwTi_43or?u}!%UtjFPk>JB~pm~OO&_A1R`ZVU45F+GBGnYH7BH~q5=h{
z2ZL+7>M0CCSN{a7i_%-)66tWJc>JaIWB*!z1wVqP&ad%|AJ`uzxEFD=E8=F2C-}X=
zYhZuB@Snedf0ygKz{#p!P5mlRZT~ZB``M~aCpGeAyvoSF%S)9zQ!R^%%<WR=kJVC0
zIMV)JM}de~%s#VM&~rqao7eFmNHC$iEEg`Y`!zzPYxlx<_uPT;S>Yr)SPxtnv+Wz%
zF>Sg-AreRclE}Gnl)=-3BH^Y}#knb`2N_lBnJxcyj<D!33XLG<_%!imoz-W;UHQpX
zEJ{)T!A+o#DAzN_ODMfkLAA)}Fxb?^@2+kkH*_zsJ$vlkj|$@UTNH-1NGDG3z0Onj
zM&!n6j{)yQK^r9D8t0zsmdLFDgOAsFaOm3I0>;f6iIHJ$m6~<;uGA?vldp~wl&T~P
zplRr>@mDz13eKn%5zWoA>FU8SFU3HA=a_1$S`?oz&CKm}(TBkf_WfeO>h0R{X|W(O
zIBeitBQVXSw{)8FaALlQGCo$*FBF9(k!M|Uy4Yu`S|W3Oq*2{tvufu724R2Z3fOsl
z=V(j6&%+~g7p`S=^<OVvAm+#naSh!|34{A{Rb6AM2$3jH+A}{bbX7M9_B%_XpgSBI
z<`Z<SMtnZFcK|42KK0*J^vUN_)xihyBMmA+h>~%CT_Y`<u87QyYl-kFx0h(@BbJD|
z;1_hwiE5=@gopg@1!b@2fNWn_18B1zT`;3%!4L2zT4DrU)_;O_Bch5Gd_6xhdDg+A
zF=D?Wcb+@|R8ya!`_wTp#q1J|v?PwA0@`>9b`=ZuI}X;g_eWOA%77;Ywa|r9ZkAx8
z<;M!1k$W!aN<z-&+n4hqe14PeGwWS&NXFuH;fVp^OpzYzZ7~Fi!vuM>4VPAsU$g4P
zgQ6b<%|P%qdK~Ftzxi1ZCV~KH;HmXj2i8XML82X(=4Qd;4eoYXUmDntJHQ-tbrHp$
zo9>NQ%`M$NJ=>Hc%_J2<S>mZ>73a7a{Uzaxv#Y}MrPTfVUHGM{TtOFYKp0#+&YM7%
zNWH4m%r3S>RSMu^$ICH~iu^}To9q08Q01sqZ4HzzAR1)|=H?$H$pRnGaVBOwHj|iC
zHqWZ@)J9bg<`w9DIE4$9@+s=x*{j~+5&VgniLqk{CQB4<UhA0KQ+Sp_sA-vAsso-D
zfs8L*@Z>P-7iKakW6P6ekr5OrzozI<D4KP{la#AnM?fcYJYP05mJBlH_O6KBQcy?E
zPXX09t_u}(<-5a3Lc_;{^&szST2VFHvY2{yuB!jsxrge!iJ15#!1UWxyGH8|R&Ij}
zb3hVq3im9Df<j|I3h{6}SX_GYt9{4*Gh~KwL(#Ax3=S5~`vVaYu2)*6EE@+kj(s>N
zS>h?nW#E+QN6@Jm>D|)b1;YJO2lb)H4{A{V98(M!RHj6Nyivu-d?FNVtpPyB*X1Ax
zg@#{@@%lA&{)Nyv;I7UP(M7a&cl|;9pbk_Zf7ilbd#;f|s|JJVr~W@3PdXDX3-3fZ
zRhu@CzQ@0Nen))cvN`LZd_yMMHu2d`ZfIs>IBWR^)y@x%Z^ge3_1n!y$9LhSV!o||
zY4b_e%=>h%r{7Su5dV623(_GtZWjO4*x^flaEv;^4`}NZ>gN{eU`%iylJbSkrVW}t
zyy8=$U8bX)CN9{a_%gFu_JSMXC)%F@YRrK;+xjf$n-bfWNS36&;TC&vu}-|E_TWk7
zR3MU+xZIT)oDoEfWyxQ{*&CqxCy2Eq+F*wI4Tf%-&)*You0>)K+st|nY)HVgtpVkx
z5P04>n-p1hCUHRO9VnyBsksDMQn&n-punkM6)>OQY{-%_nx`f=Qn9YuzFDe?IpvLf
zPEeTq7Ving&a^H|aD*C?tZ^x9S-!(wzO(TpKQsp_OK{6tPvp(_Qw;@8=U$97|D4#4
z4XQl2z`?Sspk+f#;>W2%6Ia<<s^6gM;YLM2$e)A4i$ec*3Tgea{HRRz>qZ4%$pTRr
zezR?~`vsF4Oxivfr0p+5#%$gN;E}q0H2(3Ye!}v`<*K0O#+mjgbWrrvs*%k=v8ElP
z@%{PyAy%X8YFXgW;ys6g#jgQA&JXSyU3k8CI$=ycR@|JJINYr7g-(N<vGt;G)pPGH
zMue!uw!mA(gA3I&P+P#-h&MTobk*?AG{+@Ay*aeU9O#+nVyW1}5<d*Q<=`^!$qg*f
z+}fyk4H<CEO}70x^^Znre^g*WlE8<(1IX+Jcib>Bqr8wWj5m{&%MD1%K@iWr+gS~(
zUDON3cEMU<S#S_}x<t2KA8fC%63Q=%w-%^AwX$vc2ynz2)*2zHw~1S*5h8cL1G_d}
z6do!_;BKTMRm(`puSWqshA#>)79_IwQjyvx$myd$LLKL4_>H7?7dwB=lWUrk!rf4h
z_bo@N7pxhz3)TqNYVs^LfreYpjU(OY7nCHHFZ3j;<mo-CwwcvH!=8&mSHkkr2se1C
zv8DQ8v`B9RAgkPB4U0V4s%T75!tIoBF4;lk0J%kVHA^tQ^z}^hdVrli<VE3%=$=m%
zUsC1`)vv{&nWX*%U`eMJ$81{}>8->I9hoTct<5+Lyj%+Q5=P!^^?oMYS}=DBl1;mj
z<@|fljDOkjX7$<@GHWEqxea*d#4a}(tl>@CRxhFRnK(dIW7|g$%;XY8npL7^VXW8_
zQZTw=BR(%$WnXJYQHN3n9RgRv9({Dt)KJdsSsD-r2FvMKP(|vFuW@vJ+8aq4kayc9
zkK;vMigZYs)^9l#e>|m{25AONmYHIBf!tVkDPjXYkLTwqhEt~#l*H>Uz`Y@sqX+)5
zLQb}GMTzqwe_7MS5TtuT-5N*pUvah#W6wI!NMC^WgN+wW&xp+wEm-B4N%CwTK()E8
zTSnD_yeCO1uWeq8+Reu#4?+$?|Lm4Qc&WxuCl0%CN1~FKb$|R0{E?R?YzR^_#A_{7
zsXC4Btaj`c)HcltZq>TZez0l%MbHdJ^dt-9yX`c$DnRL<vbSV2CW_Z+WVoTG#cNP<
z>>Ta$EhNnmsFe3Rwb2kurL5D9gINB&=Pi-Cp3-RAqN$_lfi860Xx~O+5NTYFDO1bD
z)|pB2gnb$>s9kONhEs7SvhM9Au{J?U+^s+^X+(ysI6%gE&X()~r*rLZ#M6{^<nf>-
z8da10j1J1suyD1b?UfeABhoF9_LCbo@J|hbR5){(6Z3eP?$?A%lx_?rZXf2ggC-MZ
zzQvNgYThA8*)5*;PI@Z8QXwj(xJW>!cVI7AQJ9r2cW)p>9o&HTq<rnk1L%%E>y~l3
zm3Tdy#ZS*>9nMgPF#NT@LM!Fq#M7~;=1B~fqIky7zrs45&e{dtm9Ph_OhzH!7l_4*
z<|J0^R2hO_O7Vr(7WaWQ*|b)nJ*8}9H_jdE#C%nhg<IkV=>N6Iu=tdspptv!d51+U
z=>6s<1k^aN^VLODlhmz@x|2#$)bcoYqs9EFSUywtJA7;l0vt8mHCp$xFh-is6{(+!
zT7+cvj5uwk?&$8^E*h>fas_O7+h=(6F<FyxhD*$#kzT#oN_{#K11GeisezjaT}vjl
z(5Bxv;L))K1Q1E>Jhvr^l{6LXc)ICTB~5_N=K>F&zi@~X^J7vg+3-usnEiARW3$RH
zec~r>2;(*DA3^K!=<1>6soLGaGjF5(8D=UVBcR5~uagOW>?Og&&_!x5aFOZ~6#(lc
zph8yURKu&!V6Ykx&Lk~YqM4Cbvy<Okr3KnC!{Z`Jo%S;(YhaI(tw!tKVTj5&Zt!x4
z1zOe&%$XmF`Cr$kqABSTkaWpAM`=$+BI}9DdI$A$yyQy#j*%Dye-e%0o7|a-6`?`K
zsBUCox7aO}Qtg7}_eD(MfrV=<)OZ?8mJ1)N2|mlxgfalc`s^;6`Y0<^qKbo(R8gaF
z-vXb8i;J9X278~Gf?IB9VV#0!bBK2AY0~haPI?KURhT3aF3@mq?Tmq?ZX85D$lcS*
z9Z{Ma;#;{gOr&|{+WM_+rJ}R`opBGur#t8U>euP03~`?gW&csl<-+5Un^ibqRBao$
z4X8~ffSLKc`Va>}w@c{ovsE-MJ0~N@azYrYF-T{@b)e7^4g=6|8W=wy3D!8=!U3|e
z0+_`zj_z)VicAOlHWEM%o492>Fate^{9)Nrh4^9av@^gwf`9)Ou5*6p7m!$f=q*nQ
z3rwe--*OO5D!^*^9zS)-#ua`XdQ}@*(Pc~^ulXKP%jmr7sFT=d(md=R++dp2UYq=F
z=X_nERo`_Mmwg3V-8I_h(7ebLH7&P|1jUE!WL#;8^AOmNEq(S|2qUW62&mNQ!KsKk
zIGH1$BHtg@bm5iR4${wcBKQsg3^-wMuhke}@$@WgFiYF4f6KdhY|sidydMi0ry7GI
zv3DbW%Gr)AcBUF4CqA`GiAZN1P6w;wylmF|S4TmfJo30`s_LExHC{M-n3AL%#L4;)
zV*}HU&{`>2ds&5)7;`VT%vt0wnz8K1(&~zS-}tw7<RQ3-wS3vC=?#doqSF}Pb-L3y
zNq}X51eQcX^u2wwuQtQ9IfkVy5j8CHd}|A?uu|xxQG+@+Mws>(g5QCr3_|d1b>mc&
zxhOy{k-XqL?X=-%^%n_`Q2;ymE-wVJ|8q#6*6%qL(=H0gYf~dZHE8>Vz}texPI(Q&
zxmCE-`;jE`lESZfovzI>RSo?SRd+_&XQ5?@(<)jv6X>1BF%qMAuyfTHt-|`R_-ef8
za;qNfee_1W>1w+KnZuVz&E1ywDg=mhD;gfN3fh#6+|uka7H}IrnzLA<4?3m)j2_ry
zu05=k%C9+yh}*{)=2e>s?m{mFKL*zscQv$1(^>|Sr0)4eQ~kDHS>lYmnNR7tdUWTt
zD%4mS^KQi6u^e;7xiTV}O&kIOg2^E94D~J9zsMcS5*6|?kTcH=0^tOVYkvn?(PkXw
zj`n#qUq_S7148lj>RbUd{tR#W1rb9zr|b!y)og_0TG276PNp2y8Rs8r$uC9l#Z-V>
zPhiHlg4(j~LwVC1U)7^666+Tz(yda$_l_-1{1U=A4-8vS#d87l(m{9wZcEB2W<dQP
zfco9p)F75=qNF8Q!(|c+j{Czq4XW+O3~E<`01r&FLKua%Uo1Nn(<Gm9ce#Qd5B&v@
zGQslJ$i<g~W*odr9~z%Z^+)*qX&jy!xPqvn0ReRQoI!I&gniliDVHUqeW0RPu6A5k
z%BH-|w9{&8iVLn(6xkssT<bz)ZHQL%hFXwXJ@aTquQ9=_r43zzCx5mDa1ahil7uN5
zPbshRwIZwSrM^ty-YSs$Z_-$A=~tlS2P}|`WsEqN&5{aTKLwdPwG+5`q1sMW%=H$k
zmEcr1^KL0=IITK_@iTnLfK^13<bHXrG01KSq>=YiCs5V=fFlOT#Dj!HQEu|+p#<X)
zPwLT4y66N_ed06GI)69CVlDyd%EVY6U%!9CWd-bn9k8nL3{>+jPm|}b!f*zaPr}my
z_-XKAAgDYL%fLF-5S(fi?|fc>1PEG>H%-WF5?|%^G>MDbhENynF*g3RdFgNT`Z(**
zH#M6HQsP9Y=v4oGS}VFFkv=(ZPW}pVMTFbBOXH28>>9ev#92YFkpcTrBrn@#m*Hde
z!Hn|_SPv-C5PV510A0|y31LDF8a;<Kj-Sh#Cx*o8V0H7x7q5*@wjTeH_kG|Eo*M5S
zID>iy#wJXR->5NxKFs`;pV)M`SG5B6DDpFW^iL&tWL<@g-^I9|K*$?|Yx$wS<tn&z
zkUP}FZLynAvo{g)1*Ewk$m^Rd^{rgSZdrYaRNN{wCyh)mjaJ+EWr2HZjL$k`SPOM*
zkj;1mK_i6W%j%Yrc`Lvuv2FCk(<-mz3*sfe!L)%bgh4Gp_?l4a@%SU+dK-QXO`^1Y
zJoQs2N}R^(o+ei|+kw`|&{BV^tVun=?P*l9+lCeeLo_$W7w|C<WctrIU&a;S`8r%H
zqYu6WPVF8`D*PA*>!xO1h$vVJ)y69MM2e<wD@9~gY|IQPJ^E!scqP}W!HU7PzQ%H9
z8-XbFhnB?wk2?NsAS6<7P`r5UR$;<Z<W^GP(%PuB3KZX<Y9-ybHihn6hZ>QY`ataP
z3t%1k5HpQ9LF={~dkOiI^%=hW0`k2tvU#}yjD-trqD7j~NzWfqc^La5D765Zf%f$}
z(#Sjd<qBAzr`x*t_jy*$k;=!QqnnDDC_9&*GW8OH3F%J@gh$aIK{Vj^960!u+2&pc
zOnf-Pk7InH$s173xEtrOwQ#{I`K0nW^M3y=&C6W3QqWaYeEG_t<_R6}fm2C2{JlX_
zN*N6f<I|2#gZg>qC^&Rbt08_VQay<>Cl&I7Nj}$&378Q7PPzzsSn}hWo>lTOA)qOV
z+<=cZaKOZI<#6rDW%f`pog$_GX^f?2I36rAu0;(6{DRvFC?wzxTozD)6Eoi7c9s!H
znL}kD=v9`Z!~0yvv!~G-F_;DyT<I-~MeA{K^gZw~17-?6`a}9itkys(`ZlhNPG`*}
z!(i`!SmSsgoh{N_7n7qjFDeu#)UO>{k0bayZ(^MKcm9U?zJF&nCcvM=1R+mW)gIr3
z*ZIRRJL|&UIz@@*wR~@_OT-j;V977|3UFOH^Cd6ye65^kfSy5d>_J6{qxZ#iW@913
zYl8538Mtz@Q2SdMTGPsH!A`jxrzpF&5a^Y3>hYliML<*8K}Sqvze{XtPzgRY7{O<K
z5Sa>zT&l#~`i3Gmp$0cJ9wL=%mU2T%Uo+p9ekb{?<8B1Omof1xcY7H>Fk7Oj?}mR&
z(!ul)=kYhuS`&2?w<TdRw{7SGouW=Xj_{)yLyQ#q8$iJKLJZb`wGj9~!fal=XWSU)
z%TREZ3INgCxUDl!QOUq)KIEY0^r<|^D|6hYeg!OB5<#z@Uu8vq5_eS$40y>5;7jO3
zaYs%g_)4A1#XClaE$hcKn~6$82W0XTxyW^uCmiSQUxIfJP&_q`pg%K?X+{6&Cj=me
z6a6wK^0t=)?0^}gcsn?nG&H{aK&*0|rU3ASsf~<6R{5Vq{ce1A6(G?~(Wz*kKI4Sc
zAnI`jaMX$E*MJZotaePe64|iOE&hh`)}(Eyd+9&>fCN+?(}utEH}^p5F|aoRxaTDo
z@OAxvW^Z7fS`=Y`*sR>vbw9Z&TI`_~9$ZMNP~2XZe#8<5_~tUZ`Yn%|TMCp0Y?vH;
z=_Ssrw<5on)#L|k1RY=WrUKPH2V3O(j%l>leeZ8{Ia?A=uVGH|CIt(=EOXJpB7R_#
zWU*VaJX8!YAiZdsmnta(V@RI>`PG6K-TROwulfnkq!5TwN7FmvD4;@A+wckW4vcdV
z*0~ta+jJAq(%Dk~%*5?7HIiyU7Mi3t<<DO|Ui_Mg>JP|<zgl{G6ZOWR?r>(9FQXji
zD_cT<o1!q|AkTnnc0ot`6)xq=&v8R8kWlyDj(`u`{Sd8aHIAY~fCXj-RS*-d`+|<s
z>oDiBfBl#oM-?RsF5mJF8gLSH^Ss@GUzj$2x<H7I`#&<qd!F<grbB35(Wlh81#YQ7
zKD-&4P1)v($_nCH@>e+_rC-3iAwoTBeXVwTB*^?axIC@tZrLJyrE`k{_yuGY;k{#_
zdPy9dJR>qE74wV#SWg<I*;2oJ4y7^IdMzOR-{DgM*%CQ7rR+T%=B$g}HW0kWH{ekL
zuJX8+g9~0|-iHCxgpzNx`(nL7=uPezCAJ2=IO7X?|NPaC2M!miFSk&X4-Siv(B|)e
zK|p=}^$9Ee`n*a&XR<B5wf+Iwdaz;8>*oD2?jpfar%CO#8BM*CjW3O`5QfQ~-veg_
zmOwy!HQ)Ep^aJ8e&79?Z;tQ0iGwh+;^VZhSa-NiC*SJNf9-;{<+R8FtRteiEdDV&W
z1y@i8^mDT=%tnV_6zU&-o`0n9*P_qi9ce7v{BU0eNnC%g@+f>QtEP3(6PwnA65E<#
zAq#+;X5X{y)HPyNp^{fYJWc*7C#5t?5aug;2g+7?pr6>lwFD1?g@dYVUJ&1NjcP$r
zE3P-~mE6?n9)r4<AL$#ZYQpCW=3HSgQ#A13)7Ml?)p9qVoS=NQ^FHtPe3(x4s-=&)
z{}3qr{eC}jK$k=a!Fc!txW2%AvS<B0@1s7~BN!dVI9&^1PfWL#r8S0>y$hVqmbid+
zV;unB_=FOA(J}<RXd(T)^vnpqs{cOLpxU<Z%f861K99`IdTW4y`sK=DoN*a!YI!aQ
zXm${2);khKX_GfQXy54$?t?lGYJpK0y<^a+C;{irupUcda6pv?iL!c1C(qnczhQWw
zOxq`);g)SB8G07xK%Y%y(?KH1tn`5upw07Rj0a{n;60%BM&bHFSo~w3q4zzv3J+-R
zRw$m&JqSyyuq~SkVxfdQU)Fr_YCw`CMxk|GQYYvoSWSoZV2>VeA3b4`Cne)2Zu(qz
z!F!a1V}klYMm=L1)Us^&HkcB8)6nGLeQX+Q=nu$k8}Q|83ljK*TZNi5isOQLy{n_A
zrQdJHKhryya$c?PCcL}w1!B;F{}4^}tFhr51dSV|Opsx)0|zdePNkICHY6#ZIV=zK
zk>2sVy%4D1jL!_}`IQcSRg@6;4dYLc`E3aD(@?5kkW<m>DKg}bb-*8^hUcJmSyoe=
z(R7*N?d_9ge45??CGne@OK8Cp2G@2isE+R?jc(-%FozAV$Cn><RooZVoYU?VIYD~5
zcp_>T9T=A)I~Tw)c215-_<`wPxjV4+A5~$mwRB5$&i@z^_CHM1?N#_YRHd5dM&Hw#
zU)_6MJAc$WV|QQ)p8j(FTuD680l#Ya&P~Xbpn0PnT)ITMRj3_7I_QoT(cqo+S`awf
zvhY>1Zp2}4FBSb2GlY+T4(8_$>4SORoAcP#NnV^Bs^q-+Y-(!G+NLe75+z=;PLZX;
z2kIRduj{Z}-Xvf*wN-3lXbCaD_w0~Pq{a$FkGx=^(TI!9$=W_=XL1_ICSTS{I@d}i
zt$RYxa&{_;ILQ}hgHq$SDLLP7^@2HQP$>W`FJ^<5sel+33Qb98ioJjIxz2pT`>S^l
z*p)TnJX)-Yr##rP;ks|OfXSd`jbopCPvR4*Epl;EOP<Paay`;|yaY$DWDWpO1Kom?
z@N=Nmg>Vx`A7Cc&ZGy(<%>h-Y099aO6`l&)Y3-yUy{U?C^}u=z>K9eR^%jh1+)i0v
zB`E1ZiCo&eyo1X&!snBI{^ak2i@!eQ-a*d8xmI?&%euRlj@Y!-AFDh7T7HO;8ye-{
zFy0+QMKh>=3!YR^;4XWCAy5UHTui*;_zjZw_-$tsa!$@&;2eB87p}tJl!C2wTsTSn
zo|X~i%b48?gDu#B=ui0@Hl9(wAq9iz2Nf0-WiufT1WKWX4eI{DX6!C(ZmhIBWW5;h
z7_^Rx=b!(5PT8Ys6O#(Hp4e%j=@#Hl8^65yTzqT5iyF1OLzYiS+zC*!1E9o3GUT@#
zx%>$EIcdDe`&jQ}fGDUx^d`oYm6#~52*t%Q*tTUK!44#Vl&NGx@9oEj<h|h9xvOUb
zz)%_x)^OSbYI}{N*|+GwOXMBRtMA(#iqQ$M1OhN5WgM5?qQQbQ^AA2aOVHR@dDJE|
z!?7k@N}NXD@SBPQk(GS_641&}xKyL9KDRi@>*@9^d|33F2|&vPK=LLg-nY=#|B%7I
zsD|dAa!J#R7a(;W=+xnH;ZdeO=9?g8CV-zN85Tb8jgwQ+<K|obzWm_0?{q-&`>TM^
z#u?ry1n>T@n6LUBeBu+ubZq@S`8yiGxF#tvREIa&9Rxrr(rw+sqgmikuEKSCD|?6~
zx%t{C6cEh-?_pp`6#a>r86mtsAisg^Q4$AuYZAjQgW84imer1ZdOhTqTd5WaVxsN%
zAKoa4Fu*kRXB-mnk~ws4U{kz9=7ei~N>o#${CPW=U@3sy^b2C=61go(`81}Rz0@A?
z4ddvphS<uZUo`v%d2e@MZ!#4f5605y#C{q|{#X1>EcHpleK**)7Ry+q^Fp_GA>;4f
zR^D+}3KE}fYT?6Seh)IS6=Y)MB{bw15Gq47rS(%Tdq{Jmf|$G%Yo7|z9GD`$iTO5B
zMFVil3=@plHZ;b2u;b2+n>m5bX37Hig%cO0eJ3yRt4@xWfn)Siki6dumiB&>8W<dl
z5AV-Gy<6J;n_E<qH-oS)AC&h6Ftd?H8D)uD`C7h(1!;WzIn92w-kZUNdlL)MV8CO?
zd;JwKpjW0)QDosiL}Kq{4=E=$@_^r=EO!#^#xB)#fLMvM>D_ciJM%1m5;I<^b2}2a
zeMe7%lxT-ssH3Jg&GuTAP9)dLND@u0?1Ch@&JEP~5$r%bD^$@lpY%Tl8A1jTptqG4
z2_1gdbq5ol(NKK>VYpU$b}ec+;Hq;?cvn&(8Xk`c^5?{Le}FBZ+{}YocS?+MXgpcn
z=S(4Y@UkRBwcF{WH}zHw(nv-o1b5_Fj}|N9Jk7RsDzDpR-^YM-zvetPPaLWO^+9y4
zC3Gsk#WfU~KqH2%_%_0dQ21CtJ}#T_y1s;6oy2#<1l|4y3xm-Lvo5&Eg;o@$T(4{~
z7dyQ?Z;dmkw53k{WuR2iK3}IAPih)*O2*v4{e40odZn0oZUVW5G+yTI?~?@uEAUSI
z2n{uyk>TiC6akN=zlzWlpjRZk8->C4AfZ^bvxCZ)N4IK0qisfh3G8wOz15T}OLmns
z2iyp%kfJ?q8m(wI#+wCl;&eIF35tn1OR-RFhnyX=*h*^n!#e;JS!PH4Yg!2Xb?sXz
zM6>Rg82(vI1sIVjA6RyFBfk9bKd(kAYMqzv+2c5ITERRPLWniMJs}qO(2o<R45gm@
z0AC@XgBuMDFvdUOH&Ujg8LnZTU-L|8M)=f#;P96wd8THBa~=Y7lZ2+BnAG48vF`MQ
z6r9fyPz|;1!COcTSoJ;TcD_L%JVHSEe0dR~0fWKa*nkRPt{Y=khuyJVAkL;Nd69TW
zu!4(?Qp|<nLg`STWxwdQsYX8p8UixL{`9A;4^d`;g0+K>iBZc-K(_P=T*w1y6?aPy
zz+VQ$Ndj%I)#|)hLTJT^&iYRolUsv7B!JGc61#@e%K50pMcug^kSkgs@~aNp;)6Be
zt!T^I<TppC!SS0<Tk;bfA!&(_G~Gv@?Zk5-Q_=$02rw~HGpt7$TdR`av;$O)W@Jpn
z^ppiByqw7=>LP6iMf&~D%T#Z*Hz>pn#omE`!-Llm2#<z{10uOQ4T&Ci_$CELcsl2U
zBad<(2Q5{N&(93}SXkGUB{8o9t&Ei}!+=qi{3Ze>slO=}lV%O%EL@&l$7<psWyH4S
zT14TN*%?I3S7X$+b0@G#!dVa>Gf|?l2~i$wbTSnUI#ilb*x|Oh-Py!+$7IkZvF3B(
z&NYM&Y&W)Z^u$;0$9vPzpj+JUUpnYC){S6$djYF#25%tzGOb6Q4s%xMuy`u192AnH
zpqyh|L1}kpn+Ddn={kM8gA=)6KFBb^>)^NN_V!Y1j;&d*!%qvTyT}zsM8^`t`wdtC
z4ko`F;mMZYD|-Lti_Rn9VuSLcZIYkb-5AETZj5MWr!g5KV%oHKHWdvgQZoR1bVq^o
zyP0)ijqypSS+74;ndSW2dwpzsC^d*-$=`Wf*CG%;!|%DXy)+AS;#mzzoi`AJ8;P-<
zGYC-1q8N>F9+rFuzXkCZZtGwtlHJzrI(8BC8UB`j_sll;_Ix@Qkq!3Ia9SRMTq1sr
z1vx6z@x%wQo^X7tza{@+pe2zHa9#Wj!?%71mSGMi@ExNcQ0)f%I2jPbQ%9wu6;B84
z$NDPgQ>~!XLn~e|ldPa^R=RCI9E?*@Rv;y17;<*^3j}#Z#}>SRk^+OBcU<F0`(Xpm
z=oB?$!fG`S>^drwftoW{C;AoiD3Jtr1}JZ?kpAcGA!h`HNowC3umJn)HeAOln4WiI
zj94JXbX5@AR{imDDyrrQio<*hQ1~YPFOMAEy_SWVGGNIbK;MiZfT%s#Ub;>22}_oW
zbBB;;HQtRNulXK;FBae)W~fVEQ2u{%@7sbWZw<8s4W%W&)_2GSGIaN?R5VCD4s*NJ
zU+w_=cC?jR0;=ADUE0k8<*zWWp-l)3mng=d?~^ZIH1&A68a|p<>BjiZ8T#PVUAEZH
z!g=%z?kU0=u-;DpV}tKSx}{&9aTwHp`EWqI5bnW$brzk6Igjt@kO`<mWWWk!3+=}i
z+Z~+%bCj@GJHpN@fk%%4kA{MJ95JX*l+YU50Cbz*-+Rpxw3%)u%mWB7lAh6Y;m*vu
zaK!jz*A|eQ#(45KVhq$Ju46T~%Q>{>{-6HJ1xR96Lu}`1&Y+`C8nDV?48S3(8~VmQ
z%hL>RfxabHV_oaQU1Z9j>AH;R#yRtHkr8zDWspM-nJhx*%uPaUCnRdk|I+gm^r8>r
z0Q3h5b3gkqv^m{+)YgJ9K|6e1M^8!*V|)vu=m&UTa#*K6Rs1Y8+X7wl&nGj}>A$G|
zTn(z(QFizxp&78iFz5ypW)-{IQc>8p%tlyz-dn?V5lPJWGx-V<_5{)?7H?4bq%^A`
z-s5r2C8%tUF7Y}Fpp;fUHL_GRV3SE6zbxRe8VSuXU8#h=8C+wrrS~tw$v0H}xPf;t
z#6!_&jOSms?hE(@RJK2`1Do)GeCkOMC>%UF%qOVd)l0O@>&hN%a!h9r)Db~nSccw7
zo$Jfwt(I`TY&R2HX(epofw3R4GSk_2h=?dNAI|)e80)0jfaQUa@Pw^TsxT_u`jzYc
zv6kz~=d@tc|FMRzEDtsgS=GN2Yir^2Ck9zmxUG)dX$D#q5xPh5#~U-h<+z}6J=mVY
zFo2lBWL#%)+wvq0C30;<{1d9~%j$>g;T(f1ZX4RM$nGGRGHDI-qt#o8Qd-cortV1@
z0n8X<d)+zqss1J5AQry0ccnY9$)TV~{uPEGJ(aH|&j`ON08G!5yve{B)N|%;832jI
zUAGK-bgpO(3&l^XLJ3^$i+)xu(pEAeGD*#RXXt~UUw{g@fNc2lfNbZ3ML##h>*zh`
z8K6#kfcx>ghO9ZmFFSKkf@A`iAPR-F50ZNm%SFc6RR7+G=n9bW)E^nWBeHb(f)iun
zAkcZACx_m9HV|6!X=Fwu0cnwDebWY&aRCu<UK*<?0VkLP_XwSUkg&9@qgqZ;cFpPZ
z8j-oq$+2iXefJ-E)h~HQ5xG8(=Fj!UfT3_U$7b|pjdfqnc1A?+tS4``=|?yk6N8P|
zJCswP`zisgcb_G7-lCp`(X$oQMrW1A)O`3Ah`~L~3Z!d?eInj$3;afUED!=qC?_Ik
z$-<E2(YOLO<=uPP6#C8|#I>+p|33eH{`>sDKWDXiKjuv2`zG5Pf&apexO*L9xSdG(
EKh3j2)&Kwi
index b801b193ab1d0304ccf5caca0695d9cd50c54ffc..0616288708474d539471d9bc6b4f9e84754634ea
GIT binary patch
literal 63665
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