diff --git a/lib/matplotlib/backends/backend_mixed.py b/lib/matplotlib/backends/backend_mixed.py index 5fadb96a0f73..941aea314cc9 100644 --- a/lib/matplotlib/backends/backend_mixed.py +++ b/lib/matplotlib/backends/backend_mixed.py @@ -1,8 +1,9 @@ import numpy as np from matplotlib import cbook -from .backend_agg import RendererAgg from matplotlib._tight_bbox import process_figure_for_rasterizing +from matplotlib.backends.backend_agg import RendererAgg +from matplotlib.transforms import Bbox, Affine2D, IdentityTransform class MixedModeRenderer: @@ -68,6 +69,71 @@ def __getattr__(self, attr): # to the underlying C implementation). return getattr(self._renderer, attr) + # need to wrap each drawing function that might be called on the rasterized + # version of the renderer to save what the "true" bbox is for scaling the + # output correctly + # the functions we might want to overwrite are: + # `draw_path`, `draw_image`, `draw_gouraud_triangle`, `draw_text`, + # `draw_markers`, `draw_path_collection`, `draw_quad_mesh` + + def _update_true_bbox(self, bbox, transform=None): + """Convert to real units and update""" + if transform is None: + transform = IdentityTransform() + bbox = bbox.transformed(transform + Affine2D().scale( + self._figdpi / self.dpi)) + if self._true_bbox is None: + self._true_bbox = bbox + else: + self._true_bbox = Bbox.union([self._true_bbox, bbox]) + + def draw_path(self, gc, path, transform, rgbFace=None): + if self._rasterizing > 0: + bbox = Bbox.null() + bbox.update_from_path(path, ignore=True) + self._update_true_bbox(bbox, transform) + return self._renderer.draw_path(gc, path, transform, rgbFace) + + def draw_path_collection(self, gc, master_transform, paths, all_transforms, + offsets, offsetTrans, facecolors, edgecolors, + linewidths, linestyles, antialiaseds, urls, + offset_position): + if self._rasterizing > 0: + bbox = Bbox.null() + # TODO probably faster to merge all coordinates from path using + # numpy for large lists of paths, such as the one produced by the + # test case tests/test_backed_pgf.py:test_mixed_mode + for path in paths: + bbox.update_from_path(path, ignore=False) + self._update_true_bbox(bbox, master_transform) + return self._renderer.draw_path_collection( + gc, master_transform, paths, all_transforms, offsets, + offsetTrans, facecolors, edgecolors, linewidths, linestyles, + antialiaseds, urls, offset_position) + + def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight, + coordinates, offsets, offsetTrans, facecolors, + antialiased, edgecolors): + if self._rasterizing > 0: + # TODO should check if this is always Bbox.unit for efficiency + bbox = Bbox.null() + cshape = coordinates.shape + flat_coords = coordinates.reshape((cshape[0]*cshape[1], cshape[2])) + bbox.update_from_data_xy(flat_coords, ignore=True) + self._update_true_bbox(bbox, master_transform) + + return self._renderer.draw_quad_mesh( + gc, master_transform, meshWidth, meshHeight, coordinates, + offsets, offsetTrans, facecolors, antialiased, edgecolors) + + def draw_gouraud_triangle(self, gc, points, colors, transform): + if self._rasterizing > 0: + bbox = Bbox.null() + bbox.update_from_data_xy(points, ignore=True) + self._update_true_bbox(bbox, transform) + return self._renderer.draw_gouraud_triangle( + gc, points, colors, transform) + def start_rasterizing(self): """ Enter "raster" mode. All subsequent drawing commands (until @@ -83,6 +149,7 @@ def start_rasterizing(self): self._raster_renderer = self._raster_renderer_class( self._width*self.dpi, self._height*self.dpi, self.dpi) self._renderer = self._raster_renderer + self._true_bbox = None def stop_rasterizing(self): """ @@ -92,21 +159,35 @@ def stop_rasterizing(self): """ self._renderer = self._vector_renderer - height = self._height * self.dpi - img = np.asarray(self._raster_renderer.buffer_rgba()) - slice_y, slice_x = cbook._get_nonzero_slices(img[..., 3]) - cropped_img = img[slice_y, slice_x] - if cropped_img.size: - gc = self._renderer.new_gc() - # TODO: If the mixedmode resolution differs from the figure's - # dpi, the image must be scaled (dpi->_figdpi). Not all - # backends support this. - self._renderer.draw_image( - gc, - slice_x.start * self._figdpi / self.dpi, - (height - slice_y.stop) * self._figdpi / self.dpi, - cropped_img[::-1]) + # these bounds are in pixels, relative to the figure when pixelated + # at the requested DPI. However, the vectorized backends draw at a + # fixed DPI of 72, and typically aren't snapped to the + # requested-DPI pixel grid, so we have to grab the actual bounds to + # put the image into some other way + if self._true_bbox is not None: + # raise NotImplementedError( + # "Something was drawn using a method not wrapped by " + # "MixedModeRenderer.") + img = np.asarray(self._raster_renderer.buffer_rgba()) + slice_y, slice_x = cbook._get_nonzero_slices(img[..., 3]) + cropped_img = img[slice_y, slice_x] + if cropped_img.size: + gc = self._renderer.new_gc() + # TODO: If the mixedmode resolution differs from the figure's + # dpi, the image must be scaled (dpi->_figdpi). Not all + # backends support this. + # because rasterizing will have rounded size to nearest + # pixel, we need to rescale our drawing to fit the original + # intended Bbox. This results in a slightly different DPI than + # requested, but that's better than the drawing not fitting + # into the space requested, see Issue #6827 + + self._renderer.draw_image( + gc, self._true_bbox.x0, self._true_bbox.y0, cropped_img[::-1], + true_size=(self._true_bbox.width, self._true_bbox.height) + ) + self._raster_renderer = None # restore the figure dpi. diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py index d71b8dc7aa43..642a6c5c60e3 100644 --- a/lib/matplotlib/backends/backend_pdf.py +++ b/lib/matplotlib/backends/backend_pdf.py @@ -1980,21 +1980,28 @@ def check_gc(self, gc, fillcolor=None): def get_image_magnification(self): return self.image_dpi/72.0 - def draw_image(self, gc, x, y, im, transform=None): + def option_true_bbox_image(self): + return True + + def draw_image(self, gc, x, y, im, transform=None, true_size=None): # docstring inherited h, w = im.shape[:2] if w == 0 or h == 0: return + if true_size is not None: + w, h = true_size + if transform is None: # If there's no transform, alpha has already been applied gc.set_alpha(1.0) self.check_gc(gc) - w = 72.0 * w / self.image_dpi - h = 72.0 * h / self.image_dpi + if true_size is None: + w = 72.0 * w / self.image_dpi + h = 72.0 * h / self.image_dpi imob = self.file.imageObject(im) diff --git a/lib/matplotlib/backends/backend_pgf.py b/lib/matplotlib/backends/backend_pgf.py index b5e3dcc5cd87..88a3f68e0f13 100644 --- a/lib/matplotlib/backends/backend_pgf.py +++ b/lib/matplotlib/backends/backend_pgf.py @@ -605,13 +605,19 @@ def option_image_nocomposite(self): # docstring inherited return not mpl.rcParams['image.composite_image'] - def draw_image(self, gc, x, y, im, transform=None): + def option_true_bbox_image(self): + return True + + def draw_image(self, gc, x, y, im, transform=None, true_size=None): # docstring inherited h, w = im.shape[:2] if w == 0 or h == 0: return + if true_size is not None: + w, h = true_size + if not os.path.exists(getattr(self.fh, "name", "")): raise ValueError( "streamed pgf-code does not support raster graphics, consider " diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py index 3231ed62da9c..360d3061234b 100644 --- a/lib/matplotlib/backends/backend_ps.py +++ b/lib/matplotlib/backends/backend_ps.py @@ -424,30 +424,41 @@ def _get_clip_cmd(self, gc): clip.append(f"{custom_clip_cmd}\n") return "".join(clip) + def option_true_bbox_image(self): + return True + @_log_if_debug_on - def draw_image(self, gc, x, y, im, transform=None): + def draw_image(self, gc, x, y, im, transform=None, true_size=None): # docstring inherited h, w = im.shape[:2] + + if h == 0 or w == 0: + return + imagecmd = "false 3 colorimage" data = im[::-1, :, :3] # Vertically flipped rgb values. hexdata = data.tobytes().hex("\n", -64) # Linewrap to 128 chars. if transform is None: matrix = "1 0 0 1 0 0" - xscale = w / self.image_magnification - yscale = h / self.image_magnification + if true_size is None: + xscale = w / self.image_magnification + yscale = h / self.image_magnification + else: + xscale = true_size[0] + yscale = true_size[1] else: - matrix = " ".join(map(str, transform.frozen().to_values())) xscale = 1.0 yscale = 1.0 + matrix = " ".join(map(str, transform.frozen().to_values())) self._pswriter.write(f"""\ gsave {self._get_clip_cmd(gc)} -{x:g} {y:g} translate +{x:.2f} {y:.2f} translate [{matrix}] concat -{xscale:g} {yscale:g} scale +{xscale:.2f} {yscale:.2f} scale /DataString {w:d} string def {w:d} {h:d} 8 [ {w:d} 0 0 -{h:d} 0 {h:d} ] {{ diff --git a/lib/matplotlib/backends/backend_svg.py b/lib/matplotlib/backends/backend_svg.py index 6e016b0d1e0c..0c889dcf51bc 100644 --- a/lib/matplotlib/backends/backend_svg.py +++ b/lib/matplotlib/backends/backend_svg.py @@ -915,10 +915,13 @@ def option_scale_image(self): # docstring inherited return True + def option_true_bbox_image(self): + return True + def get_image_magnification(self): return self.image_dpi / 72.0 - def draw_image(self, gc, x, y, im, transform=None): + def draw_image(self, gc, x, y, im, transform=None, true_size=None): # docstring inherited h, w = im.shape[:2] @@ -960,12 +963,28 @@ def draw_image(self, gc, x, y, im, transform=None): w = 72.0 * w / self.image_dpi h = 72.0 * h / self.image_dpi + if true_size is not None: + width, height = true_size + # because rasterization happens only for integer pixels, the + # round-trip width w = # int(width/72*image_dpi)*72/image_dpi + # need not match the "real" width + scale_x = width/w + scale_y = height/h + real_h = height + else: + scale_x = 1 + scale_y = 1 + real_h = h + self.writer.element( 'image', transform=_generate_transform([ - ('scale', (1, -1)), ('translate', (0, -h))]), + ('translate', + (x*(1 - scale_x), y*(1 - scale_y) + real_h)), + ('scale', (scale_x, -scale_y)) + ]), x=_short_float_fmt(x), - y=_short_float_fmt(-(self.height - y - h)), + y=_short_float_fmt(-(self.height - y - real_h)), width=_short_float_fmt(w), height=_short_float_fmt(h), attrib=attrib) else: diff --git a/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf b/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf index 8343cc2efd97..1a0834b02f88 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf and b/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_axes/hist2d.svg b/lib/matplotlib/tests/baseline_images/test_axes/hist2d.svg index 025441b800db..d734ce2347e3 100644 --- a/lib/matplotlib/tests/baseline_images/test_axes/hist2d.svg +++ b/lib/matplotlib/tests/baseline_images/test_axes/hist2d.svg @@ -26,46 +26,46 @@ L 57.6 41.472 z " style="fill:#ffffff;"/> - + +" id="mcf74baa445" style="stroke:#000000;stroke-width:0.8;"/> - + - + - + - + - + @@ -76,38 +76,38 @@ L 0 3.5 +" id="mec4d43d1b1" style="stroke:#000000;stroke-width:0.8;"/> - + - + - + - + - + diff --git a/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.pdf b/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.pdf index d7a58f772a40..22dbdf01e12d 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.pdf and b/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.svg b/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.svg index 8111cb56486a..ec558ac6523f 100644 --- a/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.svg +++ b/lib/matplotlib/tests/baseline_images/test_axes/hist2d_transpose.svg @@ -26,46 +26,46 @@ L 57.6 41.472 z " style="fill:#ffffff;"/> - + +" id="mee8b74cdb8" style="stroke:#000000;stroke-width:0.8;"/> - + - + - + - + - + @@ -76,38 +76,38 @@ L 0 3.5 +" id="m01ea264b27" style="stroke:#000000;stroke-width:0.8;"/> - + - + - + - + - + diff --git a/lib/matplotlib/tests/baseline_images/test_backend_pgf/pgf_mixedmode.pdf b/lib/matplotlib/tests/baseline_images/test_backend_pgf/pgf_mixedmode.pdf index fd7cf7a5c0d1..137f74997810 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_backend_pgf/pgf_mixedmode.pdf and b/lib/matplotlib/tests/baseline_images/test_backend_pgf/pgf_mixedmode.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_backend_ps/colorbar_raster.eps b/lib/matplotlib/tests/baseline_images/test_backend_ps/colorbar_raster.eps new file mode 100644 index 000000000000..a251f6e5f1d9 --- /dev/null +++ b/lib/matplotlib/tests/baseline_images/test_backend_ps/colorbar_raster.eps @@ -0,0 +1,1242 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%Title: colorbar_raster.eps +%%Creator: Matplotlib v3.8.0.dev928+g4bf6bf123a.d20230423, https://matplotlib.org/ +%%CreationDate: Sun Apr 23 07:47:42 2023 +%%Orientation: portrait +%%BoundingBox: 75 223 537 569 +%%HiResBoundingBox: 75.600000 223.200000 536.400000 568.800000 +%%EndComments +%%BeginProlog +/mpldict 11 dict def +mpldict begin +/_d { bind def } bind def +/m { moveto } _d +/l { lineto } _d +/r { rlineto } _d +/c { curveto } _d +/cl { closepath } _d +/ce { closepath eofill } _d +/box { + m + 1 index 0 r + 0 exch r + neg 0 r + cl + } _d +/clipbox { + box + clip + newpath + } _d +/sc { setcachedevice } _d +%!PS-Adobe-3.0 Resource-Font +%%Creator: Converted from TrueType to Type 3 by Matplotlib. +10 dict begin +/FontName /DejaVuSans def +/PaintType 0 def +/FontMatrix [0.00048828125 0 0 0.00048828125 0 0] def +/FontBBox [-2090 -948 3673 2524] def +/FontType 3 def +/Encoding [/zero /one /two /three /minus /five /four] def +/CharStrings 8 dict dup begin +/.notdef 0 def +/zero{1303 0 135 -29 1167 1520 sc +651 1360 m +547 1360 469 1309 416 1206 c +364 1104 338 950 338 745 c +338 540 364 387 416 284 c +469 182 547 131 651 131 c +756 131 834 182 886 284 c +939 387 965 540 965 745 c +965 950 939 1104 886 1206 c +834 1309 756 1360 651 1360 c + +651 1520 m +818 1520 946 1454 1034 1321 c +1123 1189 1167 997 1167 745 c +1167 494 1123 302 1034 169 c +946 37 818 -29 651 -29 c +484 -29 356 37 267 169 c +179 302 135 494 135 745 c +135 997 179 1189 267 1321 c +356 1454 484 1520 651 1520 c + +ce} _d +/one{1303 0 225 0 1114 1493 sc +254 170 m +584 170 l +584 1309 l +225 1237 l +225 1421 l +582 1493 l +784 1493 l +784 170 l +1114 170 l +1114 0 l +254 0 l +254 170 l + +ce} _d +/two{1303 0 150 0 1098 1520 sc +393 170 m +1098 170 l +1098 0 l +150 0 l +150 170 l +227 249 331 356 463 489 c +596 623 679 709 713 748 c +778 821 823 882 848 932 c +874 983 887 1032 887 1081 c +887 1160 859 1225 803 1275 c +748 1325 675 1350 586 1350 c +523 1350 456 1339 385 1317 c +315 1295 240 1262 160 1217 c +160 1421 l +241 1454 317 1478 388 1495 c +459 1512 523 1520 582 1520 c +737 1520 860 1481 952 1404 c +1044 1327 1090 1223 1090 1094 c +1090 1033 1078 974 1055 919 c +1032 864 991 800 930 725 c +913 706 860 650 771 557 c +682 465 556 336 393 170 c + +ce} _d +/three{1303 0 156 -29 1139 1520 sc +831 805 m +928 784 1003 741 1057 676 c +1112 611 1139 530 1139 434 c +1139 287 1088 173 987 92 c +886 11 742 -29 555 -29 c +492 -29 428 -23 361 -10 c +295 2 227 20 156 45 c +156 240 l +212 207 273 183 340 166 c +407 149 476 141 549 141 c +676 141 772 166 838 216 c +905 266 938 339 938 434 c +938 522 907 591 845 640 c +784 690 698 715 588 715 c +414 715 l +414 881 l +596 881 l +695 881 771 901 824 940 c +877 980 903 1037 903 1112 c +903 1189 876 1247 821 1288 c +767 1329 689 1350 588 1350 c +533 1350 473 1344 410 1332 c +347 1320 277 1301 201 1276 c +201 1456 l +278 1477 349 1493 416 1504 c +483 1515 547 1520 606 1520 c +759 1520 881 1485 970 1415 c +1059 1346 1104 1252 1104 1133 c +1104 1050 1080 980 1033 923 c +986 866 918 827 831 805 c + +ce} _d +/minus{1716 0 217 557 1499 727 sc +217 727 m +1499 727 l +1499 557 l +217 557 l +217 727 l + +ce} _d +/five{1303 0 158 -29 1124 1493 sc +221 1493 m +1014 1493 l +1014 1323 l +406 1323 l +406 957 l +435 967 465 974 494 979 c +523 984 553 987 582 987 c +749 987 881 941 978 850 c +1075 759 1124 635 1124 479 c +1124 318 1074 193 974 104 c +874 15 733 -29 551 -29 c +488 -29 424 -24 359 -13 c +294 -2 227 14 158 35 c +158 238 l +218 205 280 181 344 165 c +408 149 476 141 547 141 c +662 141 754 171 821 232 c +888 293 922 375 922 479 c +922 583 888 665 821 726 c +754 787 662 817 547 817 c +493 817 439 811 385 799 c +332 787 277 768 221 743 c +221 1493 l + +ce} _d +/four{1303 0 100 0 1188 1493 sc +774 1317 m +264 520 l +774 520 l +774 1317 l + +721 1493 m +975 1493 l +975 520 l +1188 520 l +1188 352 l +975 352 l +975 0 l +774 0 l +774 352 l +100 352 l +100 547 l +721 1493 l + +ce} _d +end readonly def + +/BuildGlyph { + exch begin + CharStrings exch + 2 copy known not {pop /.notdef} if + true 3 1 roll get exec + end +} _d + +/BuildChar { + 1 index /Encoding get exch get + 1 index /BuildGlyph get exec +} _d + +FontName currentdict end definefont pop +end +%%EndProlog +mpldict begin +75.6 223.2 translate +460.8 345.6 0 0 clipbox +gsave +0 0 m +460.8 0 l +460.8 345.6 l +0 345.6 l +cl +1.000 setgray +fill +grestore +gsave +57.6 38.016 m +343.296 38.016 l +343.296 304.128 l +57.6 304.128 l +cl +1.000 setgray +fill +grestore +gsave + +57.60 38.02 translate +[1 0 0 1 0 0] concat +285.70 266.11 scale +/DataString 79 string def +79 73 8 [ 79 0 0 -73 0 73 ] +{ +currentfile DataString readhexstring pop +} bind false 3 colorimage +23898e23898e23898e25838e25838e4401544401544401542db27d2db27d2db27d24aa8324aa8325848e25848e25848e25848e25848e25848e2f6c8e2f6c8e31 +668e31668e31668e2f6b8e2f6b8e3dbc743dbc743dbc7440458840458840458823898e23898e37b87837b87837b878297b8e297b8e297b8e28ae8028ae803a53 +8b3a538b3a538b287c8e287c8e287c8e1f968b1f968b20928c20928c20928c2a788e2a788e2a788e1f968b1f968b34618d34618d34618d2ab07f2ab07f29798e +29798e29798e3d4d8a3d4d8a3d4d8a2c738e2c738e277f8e277f8e277f8e1e9d891e9d891e9d893e4a893e4a8923898e23898e23898e25838e25838e44015444 +01544401542db27d2db27d2db27d24aa8324aa8325848e25848e25848e25848e25848e25848e2f6c8e2f6c8e31668e31668e31668e2f6b8e2f6b8e3dbc743dbc +743dbc7440458840458840458823898e23898e37b87837b87837b878297b8e297b8e297b8e28ae8028ae803a538b3a538b3a538b287c8e287c8e287c8e1f968b +1f968b20928c20928c20928c2a788e2a788e2a788e1f968b1f968b34618d34618d34618d2ab07f2ab07f29798e29798e29798e3d4d8a3d4d8a3d4d8a2c738e2c +738e277f8e277f8e277f8e1e9d891e9d891e9d893e4a893e4a8938598c38598c38598c35b77935b7793dbc743dbc743dbc7438598c38598c38598c46337f4633 +7f218f8d218f8d218f8d228c8d228c8d228c8d1f978b1f978b20928c20928c20928c44bf7044bf7046c06f46c06f46c06f2a778e2a778e2a778e5ec9625ec962 +2d718e2d718e2d718e277e8e277e8e277e8e287d8e287d8e29798e29798e29798e24aa8324aa8324aa8320a38620a3862b758e2b758e2b758e2ab07f2ab07f2a +b07f1f9e891f9e8928ae8028ae8028ae80375b8d375b8d365d8d365d8d365d8d2e6e8e2e6e8e2e6e8e2a788e2a788e65cb5e65cb5e65cb5e365d8d365d8d365d +8d4ac16d4ac16d38598c38598c38598c35b77935b7793dbc743dbc743dbc7438598c38598c38598c46337f46337f218f8d218f8d218f8d228c8d228c8d228c8d +1f978b1f978b20928c20928c20928c44bf7044bf7046c06f46c06f46c06f2a778e2a778e2a778e5ec9625ec9622d718e2d718e2d718e277e8e277e8e277e8e28 +7d8e287d8e29798e29798e29798e24aa8324aa8324aa8320a38620a3862b758e2b758e2b758e2ab07f2ab07f2ab07f1f9e891f9e8928ae8028ae8028ae80375b +8d375b8d365d8d365d8d365d8d2e6e8e2e6e8e2e6e8e2a788e2a788e65cb5e65cb5e65cb5e365d8d365d8d365d8d4ac16d4ac16d21918c21918c21918c2a788e +2a788e2a788e2a788e2a788e1e9c891e9c891e9c8934608d34608d20928c20928c20928c5cc8635cc8635cc86323898e23898e34b67934b67934b67937b87837 +b8781f9a8a1f9a8a1f9a8a2d708e2d708e2d708e26828e26828e287d8e287d8e287d8e1f978b1f978b1f978b277f8e277f8e27ad8127ad8127ad8131668e3166 +8e31668e27ad8127ad8124aa8324aa8324aa8333628d33628d33628d228b8d228b8d1fa0881fa0881fa0882e6e8e2e6e8e24878e24878e24878e1f948c1f948c +1f948c2fb47c2fb47c32658e32658e32658e2eb37c2eb37c2eb37c20a48620a48621918c21918c21918c2a788e2a788e2a788e2a788e2a788e1e9c891e9c891e +9c8934608d34608d20928c20928c20928c5cc8635cc8635cc86323898e23898e34b67934b67934b67937b87837b8781f9a8a1f9a8a1f9a8a2d708e2d708e2d70 +8e26828e26828e287d8e287d8e287d8e1f978b1f978b1f978b277f8e277f8e27ad8127ad8127ad8131668e31668e31668e27ad8127ad8124aa8324aa8324aa83 +33628d33628d33628d228b8d228b8d1fa0881fa0881fa0882e6e8e2e6e8e24878e24878e24878e1f948c1f948c1f948c2fb47c2fb47c32658e32658e32658e2e +b37c2eb37c2eb37c20a48620a48621918c21918c21918c2a788e2a788e2a788e2a788e2a788e1e9c891e9c891e9c8934608d34608d20928c20928c20928c5cc8 +635cc8635cc86323898e23898e34b67934b67934b67937b87837b8781f9a8a1f9a8a1f9a8a2d708e2d708e2d708e26828e26828e287d8e287d8e287d8e1f978b +1f978b1f978b277f8e277f8e27ad8127ad8127ad8131668e31668e31668e27ad8127ad8124aa8324aa8324aa8333628d33628d33628d228b8d228b8d1fa0881f +a0881fa0882e6e8e2e6e8e24878e24878e24878e1f948c1f948c1f948c2fb47c2fb47c32658e32658e32658e2eb37c2eb37c2eb37c20a48620a48625838e2583 +8e25838e2b758e2b758e2a768e2a768e2a768e20a38620a38620a3862e6e8e2e6e8e21a68521a68521a6852a768e2a768e2a768e277e8e277e8e228d8d228d8d +228d8d38588c38588c2b758e2b758e2b758e1f998a1f998a1f998a44bf7044bf7028ae8028ae8028ae801f9f881f9f881f9f8825ac8225ac8246307e46307e46 +307e54c56854c56854c56824868e24868e31b57b31b57b31b57b2eb37c2eb37c2eb37c27808e27808e218e8d218e8d218e8d2b748e2b748e2a778e2a778e2a77 +8e32648e32648e32648e2a778e2a778e2a778e2a778e2a778e287c8e287c8e287c8e34b67934b67925838e25838e25838e2b758e2b758e2a768e2a768e2a768e +20a38620a38620a3862e6e8e2e6e8e21a68521a68521a6852a768e2a768e2a768e277e8e277e8e228d8d228d8d228d8d38588c38588c2b758e2b758e2b758e1f +998a1f998a1f998a44bf7044bf7028ae8028ae8028ae801f9f881f9f881f9f8825ac8225ac8246307e46307e46307e54c56854c56854c56824868e24868e31b5 +7b31b57b31b57b2eb37c2eb37c2eb37c27808e27808e218e8d218e8d218e8d2b748e2b748e2a778e2a778e2a778e32648e32648e32648e2a778e2a778e2a778e +2a778e2a778e287c8e287c8e287c8e34b67934b679218f8d218f8d218f8d42be7142be71228d8d228d8d228d8d25838e25838e25838e1f948c1f948c21a58521 +a58521a5851fa1881fa1881fa18820938c20938c2a788e2a788e2a788e433d84433d841fa2871fa2871fa28726ad8126ad8126ad811e9b8a1e9b8a1f958b1f95 +8b1f958b1f998a1f998a1f998a1fa1881fa18821a58521a58521a585306a8e306a8e306a8ec0df25c0df253d4e8a3d4e8a3d4e8a21908d21908d21908d23a983 +23a9831fa1871fa1871fa18726ad8126ad81277f8e277f8e277f8e26818e26818e26818e277e8e277e8e1e9c891e9c891e9c8920a48620a48620a48628ae8028 +ae80218f8d218f8d218f8d42be7142be71228d8d228d8d228d8d25838e25838e25838e1f948c1f948c21a58521a58521a5851fa1881fa1881fa18820938c2093 +8c2a788e2a788e2a788e433d84433d841fa2871fa2871fa28726ad8126ad8126ad811e9b8a1e9b8a1f958b1f958b1f958b1f998a1f998a1f998a1fa1881fa188 +21a58521a58521a585306a8e306a8e306a8ec0df25c0df253d4e8a3d4e8a3d4e8a21908d21908d21908d23a98323a9831fa1871fa1871fa18726ad8126ad8127 +7f8e277f8e277f8e26818e26818e26818e277e8e277e8e1e9c891e9c891e9c8920a48620a48620a48628ae8028ae80218f8d218f8d218f8d42be7142be71228d +8d228d8d228d8d25838e25838e25838e1f948c1f948c21a58521a58521a5851fa1881fa1881fa18820938c20938c2a788e2a788e2a788e433d84433d841fa287 +1fa2871fa28726ad8126ad8126ad811e9b8a1e9b8a1f958b1f958b1f958b1f998a1f998a1f998a1fa1881fa18821a58521a58521a585306a8e306a8e306a8ec0 +df25c0df253d4e8a3d4e8a3d4e8a21908d21908d21908d23a98323a9831fa1871fa1871fa18726ad8126ad81277f8e277f8e277f8e26818e26818e26818e277e +8e277e8e1e9c891e9c891e9c8920a48620a48620a48628ae8028ae801e9d891e9d891e9d8929af7f29af7f35b77935b77935b77932648e32648e32648e2d718e +2d718e25848e25848e25848e34608d34608d34608d25ac8225ac822a768e2a768e2a768e28ae8028ae8031678e31678e31678e2a788e2a788e2a788e297b8e29 +7b8e23a98323a98323a983306a8e306a8e306a8e44398344398326ad8126ad8126ad8124868e24868e24868e26828e26828e1f9a8a1f9a8a1f9a8a238a8d238a +8d238a8d25848e25848e20928c20928c20928c24aa8324aa8332658e32658e32658e31688e31688e31688e26828e26828e25848e25848e25848e1e9d891e9d89 +1e9d892d708e2d708e1e9d891e9d891e9d8929af7f29af7f35b77935b77935b77932648e32648e32648e2d718e2d718e25848e25848e25848e34608d34608d34 +608d25ac8225ac822a768e2a768e2a768e28ae8028ae8031678e31678e31678e2a788e2a788e2a788e297b8e297b8e23a98323a98323a983306a8e306a8e306a +8e44398344398326ad8126ad8126ad8124868e24868e24868e26828e26828e1f9a8a1f9a8a1f9a8a238a8d238a8d238a8d25848e25848e20928c20928c20928c +24aa8324aa8332658e32658e32658e31688e31688e31688e26828e26828e25848e25848e25848e1e9d891e9d891e9d892d708e2d708e23888e23888e23888e27 +7f8e277f8e2ab07f2ab07f2ab07f2d708e2d708e2d708efde725fde7251fa2871fa2871fa2873a538b3a538b3a538b29798e29798e1fa0881fa0881fa0883168 +8e31688e26818e26818e26818e2f6b8e2f6b8e2f6b8e22a88422a88424878e24878e24878e218f8d218f8d218f8d38b97738b977443b84443b84443b842a768e +2a768e2a768e23898e23898e2e6e8e2e6e8e2e6e8e86d54986d54986d5491f968b1f968b23888e23888e23888e1fa2871fa28738598c38598c38598c26818e26 +818e26818e228d8d228d8d1f948c1f948c1f948c2c728e2c728e2c728e25ac8225ac8223888e23888e23888e277f8e277f8e2ab07f2ab07f2ab07f2d708e2d70 +8e2d708efde725fde7251fa2871fa2871fa2873a538b3a538b3a538b29798e29798e1fa0881fa0881fa08831688e31688e26818e26818e26818e2f6b8e2f6b8e +2f6b8e22a88422a88424878e24878e24878e218f8d218f8d218f8d38b97738b977443b84443b84443b842a768e2a768e2a768e23898e23898e2e6e8e2e6e8e2e +6e8e86d54986d54986d5491f968b1f968b23888e23888e23888e1fa2871fa28738598c38598c38598c26818e26818e26818e228d8d228d8d1f948c1f948c1f94 +8c2c728e2c728e2c728e25ac8225ac8223888e23888e23888e277f8e277f8e2ab07f2ab07f2ab07f2d708e2d708e2d708efde725fde7251fa2871fa2871fa287 +3a538b3a538b3a538b29798e29798e1fa0881fa0881fa08831688e31688e26818e26818e26818e2f6b8e2f6b8e2f6b8e22a88422a88424878e24878e24878e21 +8f8d218f8d218f8d38b97738b977443b84443b84443b842a768e2a768e2a768e23898e23898e2e6e8e2e6e8e2e6e8e86d54986d54986d5491f968b1f968b2388 +8e23888e23888e1fa2871fa28738598c38598c38598c26818e26818e26818e228d8d228d8d1f948c1f948c1f948c2c728e2c728e2c728e25ac8225ac8225858e +25858e25858e2d708e2d708e27ad8127ad8127ad8121908d21908d21908d287c8e287c8e50c46a50c46a50c46a26828e26828e26828e25ac8225ac8234b67934 +b67934b6791fa1871fa1871f9f881f9f881f9f881e9d891e9d891e9d89218e8d218e8d32b67a32b67a32b67a24868e24868e24868e2c728e2c728e238a8d238a +8d238a8d2a768e2a768e2a768e24aa8324aa831e9b8a1e9b8a1e9b8a2c718e2c718e2c718e2c728e2c728e34618d34618d34618d26ad8126ad811e9d891e9d89 +1e9d897ad1517ad1517ad15120928c20928c23888e23888e23888e2a768e2a768e2a768e34b67934b67925858e25858e25858e2d708e2d708e27ad8127ad8127 +ad8121908d21908d21908d287c8e287c8e50c46a50c46a50c46a26828e26828e26828e25ac8225ac8234b67934b67934b6791fa1871fa1871f9f881f9f881f9f +881e9d891e9d891e9d89218e8d218e8d32b67a32b67a32b67a24868e24868e24868e2c728e2c728e238a8d238a8d238a8d2a768e2a768e2a768e24aa8324aa83 +1e9b8a1e9b8a1e9b8a2c718e2c718e2c718e2c728e2c728e34618d34618d34618d26ad8126ad811e9d891e9d891e9d897ad1517ad1517ad15120928c20928c23 +888e23888e23888e2a768e2a768e2a768e34b67934b67920928c20928c20928c3dbc743dbc7431668e31668e31668e25838e25838e25838e2d718e2d718e2486 +8e24868e24868e2d718e2d718e2d718e3a538b3a538b3e4a893e4a893e4a8929798e29798e1f978b1f978b1f978b32658e32658e32658e1fa1881fa188365c8d +365c8d365c8d20928c20928c20928c26828e26828e1fa1871fa1871fa18721918c21918c21918c355f8d355f8d297b8e297b8e297b8e31668e31668e31668e24 +868e24868e297b8e297b8e297b8e34608d34608d1f958b1f958b1f958b1f968b1f968b1f968b20a38620a386228b8d228b8d228b8d1e9b8a1e9b8a1e9b8a1f9a +8a1f9a8a20928c20928c20928c3dbc743dbc7431668e31668e31668e25838e25838e25838e2d718e2d718e24868e24868e24868e2d718e2d718e2d718e3a538b +3a538b3e4a893e4a893e4a8929798e29798e1f978b1f978b1f978b32658e32658e32658e1fa1881fa188365c8d365c8d365c8d20928c20928c20928c26828e26 +828e1fa1871fa1871fa18721918c21918c21918c355f8d355f8d297b8e297b8e297b8e31668e31668e31668e24868e24868e297b8e297b8e297b8e34608d3460 +8d1f958b1f958b1f958b1f968b1f968b1f968b20a38620a386228b8d228b8d228b8d1e9b8a1e9b8a1e9b8a1f9a8a1f9a8a20928c20928c20928c3dbc743dbc74 +31668e31668e31668e25838e25838e25838e2d718e2d718e24868e24868e24868e2d718e2d718e2d718e3a538b3a538b3e4a893e4a893e4a8929798e29798e1f +978b1f978b1f978b32658e32658e32658e1fa1881fa188365c8d365c8d365c8d20928c20928c20928c26828e26828e1fa1871fa1871fa18721918c21918c2191 +8c355f8d355f8d297b8e297b8e297b8e31668e31668e31668e24868e24868e297b8e297b8e297b8e34608d34608d1f958b1f958b1f958b1f968b1f968b1f968b +20a38620a386228b8d228b8d228b8d1e9b8a1e9b8a1e9b8a1f9a8a1f9a8a31b57b31b57b31b57b4cc26c4cc26c238a8d238a8d238a8d277e8e277e8e277e8e32 +b67a32b67a2a788e2a788e2a788e1fa1871fa1871fa18725858e25858e24878e24878e24878e22a88422a884365d8d365d8d365d8d1fa1881fa1881fa18821a5 +8521a5851f9f881f9f881f9f8848c16e48c16e48c16e218f8d218f8d2a778e2a778e2a778e1e9c891e9c891e9c892d708e2d708e33638d33638d33638d29798e +29798e29798e1e9c891e9c891e9c891e9c891e9c892e6e8e2e6e8e1fa0881fa0881fa088238a8d238a8d238a8d26828e26828e2d708e2d708e2d708e21a68521 +a68521a68530698e30698e31b57b31b57b31b57b4cc26c4cc26c238a8d238a8d238a8d277e8e277e8e277e8e32b67a32b67a2a788e2a788e2a788e1fa1871fa1 +871fa18725858e25858e24878e24878e24878e22a88422a884365d8d365d8d365d8d1fa1881fa1881fa18821a58521a5851f9f881f9f881f9f8848c16e48c16e +48c16e218f8d218f8d2a778e2a778e2a778e1e9c891e9c891e9c892d708e2d708e33638d33638d33638d29798e29798e29798e1e9c891e9c891e9c891e9c891e +9c892e6e8e2e6e8e1fa0881fa0881fa088238a8d238a8d238a8d26828e26828e2d708e2d708e2d708e21a68521a68521a68530698e30698e277f8e277f8e277f +8e2c738e2c738e32648e32648e32648e32b67a32b67a32b67a25858e25858e1fa2871fa2871fa2872db27d2db27d2db27d3aba763aba768bd6468bd6468bd646 +1f958b1f958b2c728e2c728e2c728e26818e26818e26818e29798e29798e1f948c1f948c1f948c24878e24878e24878e1e9b8a1e9b8a70cf5770cf5770cf5737 +5b8d375b8d375b8d228d8d228d8d20a38620a38620a386306a8e306a8e306a8e2e6d8e2e6d8e297b8e297b8e297b8e277e8e277e8e25838e25838e25838e297b +8e297b8e297b8e25858e25858e26818e26818e26818e2e6d8e2e6d8e2e6d8e5cc8635cc863277f8e277f8e277f8e2c738e2c738e32648e32648e32648e32b67a +32b67a32b67a25858e25858e1fa2871fa2871fa2872db27d2db27d2db27d3aba763aba768bd6468bd6468bd6461f958b1f958b2c728e2c728e2c728e26818e26 +818e26818e29798e29798e1f948c1f948c1f948c24878e24878e24878e1e9b8a1e9b8a70cf5770cf5770cf57375b8d375b8d375b8d228d8d228d8d20a38620a3 +8620a386306a8e306a8e306a8e2e6d8e2e6d8e297b8e297b8e297b8e277e8e277e8e25838e25838e25838e297b8e297b8e297b8e25858e25858e26818e26818e +26818e2e6d8e2e6d8e2e6d8e5cc8635cc863277f8e277f8e277f8e2c738e2c738e32648e32648e32648e32b67a32b67a32b67a25858e25858e1fa2871fa2871f +a2872db27d2db27d2db27d3aba763aba768bd6468bd6468bd6461f958b1f958b2c728e2c728e2c728e26818e26818e26818e29798e29798e1f948c1f948c1f94 +8c24878e24878e24878e1e9b8a1e9b8a70cf5770cf5770cf57375b8d375b8d375b8d228d8d228d8d20a38620a38620a386306a8e306a8e306a8e2e6d8e2e6d8e +297b8e297b8e297b8e277e8e277e8e25838e25838e25838e297b8e297b8e297b8e25858e25858e26818e26818e26818e2e6d8e2e6d8e2e6d8e5cc8635cc86329 +af7f29af7f29af7f1f978b1f978b35b77935b77935b77926828e26828e26828e27808e27808e2eb37c2eb37c2eb37c22a88422a88422a88422a78522a785238a +8d238a8d238a8d287c8e287c8e26828e26828e26828e50c46a50c46a50c46a2c728e2c728e1f988b1f988b1f988b218f8d218f8d218f8d34618d34618d20938c +20938c20938c1fa1871fa1871fa187218e8d218e8d27808e27808e27808e23a98323a98323a9831e9b8a1e9b8a29af7f29af7f29af7f218f8d218f8d1f948c1f +948c1f948c1e9b8a1e9b8a1e9b8a2f6c8e2f6c8e1fa1871fa1871fa1871e9d891e9d891e9d8923898e23898e29af7f29af7f29af7f1f978b1f978b35b77935b7 +7935b77926828e26828e26828e27808e27808e2eb37c2eb37c2eb37c22a88422a88422a88422a78522a785238a8d238a8d238a8d287c8e287c8e26828e26828e +26828e50c46a50c46a50c46a2c728e2c728e1f988b1f988b1f988b218f8d218f8d218f8d34618d34618d20938c20938c20938c1fa1871fa1871fa187218e8d21 +8e8d27808e27808e27808e23a98323a98323a9831e9b8a1e9b8a29af7f29af7f29af7f218f8d218f8d1f948c1f948c1f948c1e9b8a1e9b8a1e9b8a2f6c8e2f6c +8e1fa1871fa1871fa1871e9d891e9d891e9d8923898e23898e1fa1871fa1871fa187218f8d218f8d277e8e277e8e277e8e25ab8225ab8225ab8221908d21908d +2e6d8e2e6d8e2e6d8e21908d21908d21908d218e8d218e8d35b77935b77935b7791fa2871fa28732658e32658e32658e1f9a8a1f9a8a1f9a8a23888e23888e2e +6d8e2e6d8e2e6d8e23a98323a98323a9832b758e2b758e433d84433d84433d845ac8645ac8645ac8641fa0881fa08825ab8225ab8225ab8235b77935b77935b7 +795ec9625ec96224878e24878e24878e1f978b1f978b21918c21918c21918c44015444015444015434608d34608d29798e29798e29798e1f988b1f988b1f988b +1f998a1f998a1fa1871fa1871fa187218f8d218f8d277e8e277e8e277e8e25ab8225ab8225ab8221908d21908d2e6d8e2e6d8e2e6d8e21908d21908d21908d21 +8e8d218e8d35b77935b77935b7791fa2871fa28732658e32658e32658e1f9a8a1f9a8a1f9a8a23888e23888e2e6d8e2e6d8e2e6d8e23a98323a98323a9832b75 +8e2b758e433d84433d84433d845ac8645ac8645ac8641fa0881fa08825ab8225ab8225ab8235b77935b77935b7795ec9625ec96224878e24878e24878e1f978b +1f978b21918c21918c21918c44015444015444015434608d34608d29798e29798e29798e1f988b1f988b1f988b1f998a1f998a1fa1871fa1871fa187218f8d21 +8f8d277e8e277e8e277e8e25ab8225ab8225ab8221908d21908d2e6d8e2e6d8e2e6d8e21908d21908d21908d218e8d218e8d35b77935b77935b7791fa2871fa2 +8732658e32658e32658e1f9a8a1f9a8a1f9a8a23888e23888e2e6d8e2e6d8e2e6d8e23a98323a98323a9832b758e2b758e433d84433d84433d845ac8645ac864 +5ac8641fa0881fa08825ab8225ab8225ab8235b77935b77935b7795ec9625ec96224878e24878e24878e1f978b1f978b21918c21918c21918c44015444015444 +015434608d34608d29798e29798e29798e1f988b1f988b1f988b1f998a1f998a3bbb753bbb753bbb752a768e2a768e1f978b1f978b1f978b1f998a1f998a1f99 +8a2e6e8e2e6e8e218e8d218e8d218e8d26818e26818e26818e4ec36b4ec36b30698e30698e30698e31b57b31b57b21908d21908d21908d2cb17e2cb17e2cb17e +297a8e297a8e277e8e277e8e277e8e2c738e2c738e2c738e1e9c891e9c89218e8d218e8d218e8d27808e27808e27808e1fa1881fa1881f948c1f948c1f948c24 +aa8324aa8324aa8322a88422a8841f988b1f988b1f988b3dbc743dbc741f9e891f9e891f9e89355e8d355e8d355e8d23a98323a98320938c20938c20938c1e9b +8a1e9b8a1e9b8a1fa1871fa1873bbb753bbb753bbb752a768e2a768e1f978b1f978b1f978b1f998a1f998a1f998a2e6e8e2e6e8e218e8d218e8d218e8d26818e +26818e26818e4ec36b4ec36b30698e30698e30698e31b57b31b57b21908d21908d21908d2cb17e2cb17e2cb17e297a8e297a8e277e8e277e8e277e8e2c738e2c +738e2c738e1e9c891e9c89218e8d218e8d218e8d27808e27808e27808e1fa1881fa1881f948c1f948c1f948c24aa8324aa8324aa8322a88422a8841f988b1f98 +8b1f988b3dbc743dbc741f9e891f9e891f9e89355e8d355e8d355e8d23a98323a98320938c20938c20938c1e9b8a1e9b8a1e9b8a1fa1871fa18724868e24868e +24868e1e9b8a1e9b8a228d8d228d8d228d8d2b758e2b758e2b758e306a8e306a8e20938c20938c20938c355e8d355e8d355e8d20a38620a38630698e30698e30 +698e38b97738b9771e9b8a1e9b8a1e9b8a2c738e2c738e2c738e22a78522a7851f988b1f988b1f988b2b748e2b748e2b748e2b748e2b748e42be7142be7142be +71375a8c375a8c375a8c20928c20928c33628d33628d33628d27808e27808e27808e29798e29798e2e6f8e2e6f8e2e6f8e228b8d228b8d56c66756c66756c667 +1f988b1f988b1f988b1f9e891f9e8944bf7044bf7044bf702a768e2a768e2a768e1fa1871fa18724868e24868e24868e1e9b8a1e9b8a228d8d228d8d228d8d2b +758e2b758e2b758e306a8e306a8e20938c20938c20938c355e8d355e8d355e8d20a38620a38630698e30698e30698e38b97738b9771e9b8a1e9b8a1e9b8a2c73 +8e2c738e2c738e22a78522a7851f988b1f988b1f988b2b748e2b748e2b748e2b748e2b748e42be7142be7142be71375a8c375a8c375a8c20928c20928c33628d +33628d33628d27808e27808e27808e29798e29798e2e6f8e2e6f8e2e6f8e228b8d228b8d56c66756c66756c6671f988b1f988b1f988b1f9e891f9e8944bf7044 +bf7044bf702a768e2a768e2a768e1fa1871fa18731678e31678e31678e93d74193d7412f6b8e2f6b8e2f6b8e2a788e2a788e2a788e4ec36b4ec36b1e9c891e9c +891e9c8925838e25838e25838e297a8e297a8e218e8d218e8d218e8d1f988b1f988b25838e25838e25838e277e8e277e8e277e8e3a548c3a548c287d8e287d8e +287d8e2cb17e2cb17e2cb17e228b8d228b8d32658e32658e32658e2e6e8e2e6e8e2e6e8e3e49893e4989218e8d218e8d218e8d1f978b1f978b1f978b2a788e2a +788e48c16e48c16e48c16e25858e25858e38598c38598c38598c3d4e8a3d4e8a3d4e8a2c738e2c738e25838e25838e25838e32b67a32b67a32b67a4828784828 +7831678e31678e31678e93d74193d7412f6b8e2f6b8e2f6b8e2a788e2a788e2a788e4ec36b4ec36b1e9c891e9c891e9c8925838e25838e25838e297a8e297a8e +218e8d218e8d218e8d1f988b1f988b25838e25838e25838e277e8e277e8e277e8e3a548c3a548c287d8e287d8e287d8e2cb17e2cb17e2cb17e228b8d228b8d32 +658e32658e32658e2e6e8e2e6e8e2e6e8e3e49893e4989218e8d218e8d218e8d1f978b1f978b1f978b2a788e2a788e48c16e48c16e48c16e25858e25858e3859 +8c38598c38598c3d4e8a3d4e8a3d4e8a2c738e2c738e25838e25838e25838e32b67a32b67a32b67a48287848287831678e31678e31678e93d74193d7412f6b8e +2f6b8e2f6b8e2a788e2a788e2a788e4ec36b4ec36b1e9c891e9c891e9c8925838e25838e25838e297a8e297a8e218e8d218e8d218e8d1f988b1f988b25838e25 +838e25838e277e8e277e8e277e8e3a548c3a548c287d8e287d8e287d8e2cb17e2cb17e2cb17e228b8d228b8d32658e32658e32658e2e6e8e2e6e8e2e6e8e3e49 +893e4989218e8d218e8d218e8d1f978b1f978b1f978b2a788e2a788e48c16e48c16e48c16e25858e25858e38598c38598c38598c3d4e8a3d4e8a3d4e8a2c738e +2c738e25838e25838e25838e32b67a32b67a32b67a48287848287825848e25848e25848e1fa1871fa1873c508b3c508b3c508b30698e30698e30698e20938c20 +938c1fa1871fa1871fa1874ec36b4ec36b4ec36b238a8d238a8d24868e24868e24868e2d718e2d718e228d8d228d8d228d8d24aa8324aa8324aa83218e8d218e +8d27ad8127ad8127ad8120938c20938c20938c32658e32658e24878e24878e24878e27808e27808e27808e2d718e2d718e25858e25858e25858e2a768e2a768e +2a768e228b8d228b8d31668e31668e31668e1fa2871fa2871f948c1f948c1f948c1e9b8a1e9b8a1e9b8a22a88422a8842d708e2d708e2d708e1f978b1f978b1f +978b228c8d228c8d25848e25848e25848e1fa1871fa1873c508b3c508b3c508b30698e30698e30698e20938c20938c1fa1871fa1871fa1874ec36b4ec36b4ec3 +6b238a8d238a8d24868e24868e24868e2d718e2d718e228d8d228d8d228d8d24aa8324aa8324aa83218e8d218e8d27ad8127ad8127ad8120938c20938c20938c +32658e32658e24878e24878e24878e27808e27808e27808e2d718e2d718e25858e25858e25858e2a768e2a768e2a768e228b8d228b8d31668e31668e31668e1f +a2871fa2871f948c1f948c1f948c1e9b8a1e9b8a1e9b8a22a88422a8842d708e2d708e2d708e1f978b1f978b1f978b228c8d228c8d25848e25848e25848e20a4 +8620a48626828e26828e26828e26ad8126ad8126ad812a788e2a788e25838e25838e25838e23888e23888e23888e2b758e2b758e24878e24878e24878e228b8d +228b8d1f9a8a1f9a8a1f9a8a38b97738b97738b9772c738e2c738e24878e24878e24878e40bd7240bd7240bd722d708e2d708e2e6d8e2e6d8e2e6d8e228c8d22 +8c8d228c8d29798e29798e7cd2507cd2507cd250277f8e277f8e277f8e20928c20928c25ac8225ac8225ac822a778e2a778e29af7f29af7f29af7f2f6c8e2f6c +8e2f6c8e39558c39558c1fa1881fa1881fa1882e6e8e2e6e8e2e6e8e39568c39568c25848e25848e25848e20a48620a48626828e26828e26828e26ad8126ad81 +26ad812a788e2a788e25838e25838e25838e23888e23888e23888e2b758e2b758e24878e24878e24878e228b8d228b8d1f9a8a1f9a8a1f9a8a38b97738b97738 +b9772c738e2c738e24878e24878e24878e40bd7240bd7240bd722d708e2d708e2e6d8e2e6d8e2e6d8e228c8d228c8d228c8d29798e29798e7cd2507cd2507cd2 +50277f8e277f8e277f8e20928c20928c25ac8225ac8225ac822a778e2a778e29af7f29af7f29af7f2f6c8e2f6c8e2f6c8e39558c39558c1fa1881fa1881fa188 +2e6e8e2e6e8e2e6e8e39568c39568c25848e25848e25848e20a48620a48626828e26828e26828e26ad8126ad8126ad812a788e2a788e25838e25838e25838e23 +888e23888e23888e2b758e2b758e24878e24878e24878e228b8d228b8d1f9a8a1f9a8a1f9a8a38b97738b97738b9772c738e2c738e24878e24878e24878e40bd +7240bd7240bd722d708e2d708e2e6d8e2e6d8e2e6d8e228c8d228c8d228c8d29798e29798e7cd2507cd2507cd250277f8e277f8e277f8e20928c20928c25ac82 +25ac8225ac822a778e2a778e29af7f29af7f29af7f2f6c8e2f6c8e2f6c8e39558c39558c1fa1881fa1881fa1882e6e8e2e6e8e2e6e8e39568c39568c32b67a32 +b67a32b67a2c738e2c738e24868e24868e24868e25858e25858e25858e21a68521a6851fa1881fa1881fa1883e49893e49893e498933638d33638d1f968b1f96 +8b1f968b375b8d375b8d26ad8126ad8126ad8125ab8225ab8225ab822d708e2d708e31b57b31b57b31b57b2f6c8e2f6c8e2f6c8e1f968b1f968b73d05673d056 +73d05638598c38598c38598c365d8d365d8d1f948c1f948c1f948c2c718e2c718e2c718e1f958b1f958b4828784828784828781f9a8a1f9a8a24aa8324aa8324 +aa8324aa8324aa8324aa83287d8e287d8e1f9f881f9f881f9f88218f8d218f8d218f8d21a58521a58532b67a32b67a32b67a2c738e2c738e24868e24868e2486 +8e25858e25858e25858e21a68521a6851fa1881fa1881fa1883e49893e49893e498933638d33638d1f968b1f968b1f968b375b8d375b8d26ad8126ad8126ad81 +25ab8225ab8225ab822d708e2d708e31b57b31b57b31b57b2f6c8e2f6c8e2f6c8e1f968b1f968b73d05673d05673d05638598c38598c38598c365d8d365d8d1f +948c1f948c1f948c2c718e2c718e2c718e1f958b1f958b4828784828784828781f9a8a1f9a8a24aa8324aa8324aa8324aa8324aa8324aa83287d8e287d8e1f9f +881f9f881f9f88218f8d218f8d218f8d21a58521a58520928c20928c20928c24878e24878e23888e23888e23888e433d84433d84433d84375a8c375a8c287c8e +287c8e287c8e23898e23898e23898e2e6d8e2e6d8e24aa8324aa8324aa8320928c20928c30698e30698e30698e26828e26828e26828e21a68521a685375a8c37 +5a8c375a8c287c8e287c8e287c8e3bbb753bbb7530698e30698e30698e2f6b8e2f6b8e2f6b8e1fa1881fa1883fbc733fbc733fbc733e4a893e4a893e4a89218e +8d218e8d218e8d218e8d218e8d20a48620a4861f9f881f9f881f9f8821908d21908d21908d26818e26818e29af7f29af7f29af7f26818e26818e26818e29af7f +29af7f20928c20928c20928c24878e24878e23888e23888e23888e433d84433d84433d84375a8c375a8c287c8e287c8e287c8e23898e23898e23898e2e6d8e2e +6d8e24aa8324aa8324aa8320928c20928c30698e30698e30698e26828e26828e26828e21a68521a685375a8c375a8c375a8c287c8e287c8e287c8e3bbb753bbb +7530698e30698e30698e2f6b8e2f6b8e2f6b8e1fa1881fa1883fbc733fbc733fbc733e4a893e4a893e4a89218e8d218e8d218e8d218e8d218e8d20a48620a486 +1f9f881f9f881f9f8821908d21908d21908d26818e26818e29af7f29af7f29af7f26818e26818e26818e29af7f29af7f20928c20928c20928c24878e24878e23 +888e23888e23888e433d84433d84433d84375a8c375a8c287c8e287c8e287c8e23898e23898e23898e2e6d8e2e6d8e24aa8324aa8324aa8320928c20928c3069 +8e30698e30698e26828e26828e26828e21a68521a685375a8c375a8c375a8c287c8e287c8e287c8e3bbb753bbb7530698e30698e30698e2f6b8e2f6b8e2f6b8e +1fa1881fa1883fbc733fbc733fbc733e4a893e4a893e4a89218e8d218e8d218e8d218e8d218e8d20a48620a4861f9f881f9f881f9f8821908d21908d21908d26 +818e26818e29af7f29af7f29af7f26818e26818e26818e29af7f29af7f1f968b1f968b1f968b26828e26828e1fa1881fa1881fa188238a8d238a8d238a8d48c1 +6e48c16e3a538b3a538b3a538b228d8d228d8d228d8d25848e25848e1e9b8a1e9b8a1e9b8a1f978b1f978b2d708e2d708e2d708e34618d34618d34618d1fa287 +1fa28731668e31668e31668e2e6f8e2e6f8e2e6f8e21918c21918c21908d21908d21908d228b8d228b8d228b8d26828e26828e2a778e2a778e2a778e238a8d23 +8a8d238a8d26828e26828e287c8e287c8e287c8e1e9b8a1e9b8a1e9d891e9d891e9d89287c8e287c8e287c8e3dbc743dbc7420a48620a48620a4861f998a1f99 +8a1f998a228c8d228c8d1f968b1f968b1f968b26828e26828e1fa1881fa1881fa188238a8d238a8d238a8d48c16e48c16e3a538b3a538b3a538b228d8d228d8d +228d8d25848e25848e1e9b8a1e9b8a1e9b8a1f978b1f978b2d708e2d708e2d708e34618d34618d34618d1fa2871fa28731668e31668e31668e2e6f8e2e6f8e2e +6f8e21918c21918c21908d21908d21908d228b8d228b8d228b8d26828e26828e2a778e2a778e2a778e238a8d238a8d238a8d26828e26828e287c8e287c8e287c +8e1e9b8a1e9b8a1e9d891e9d891e9d89287c8e287c8e287c8e3dbc743dbc7420a48620a48620a4861f998a1f998a1f998a228c8d228c8d25ac8225ac8225ac82 +365d8d365d8d21918c21918c21918c423f85423f85423f8521a68521a68550c46a50c46a50c46a22a88422a88422a88421908d21908d287d8e287d8e287d8e2d +718e2d718e27808e27808e27808e238a8d238a8d238a8d1e9b8a1e9b8a34b67934b67934b6792eb37c2eb37c2eb37c277e8e277e8e25858e25858e25858e2cb1 +7e2cb17e2cb17e1f958b1f958b39568c39568c39568c1f998a1f998a1f998a355e8d355e8d2ab07f2ab07f2ab07f30698e30698e21918c21918c21918c25848e +25848e25848e4046884046883fbc733fbc733fbc7322a78522a78522a785472f7d472f7d25ac8225ac8225ac82365d8d365d8d21918c21918c21918c423f8542 +3f85423f8521a68521a68550c46a50c46a50c46a22a88422a88422a88421908d21908d287d8e287d8e287d8e2d718e2d718e27808e27808e27808e238a8d238a +8d238a8d1e9b8a1e9b8a34b67934b67934b6792eb37c2eb37c2eb37c277e8e277e8e25858e25858e25858e2cb17e2cb17e2cb17e1f958b1f958b39568c39568c +39568c1f998a1f998a1f998a355e8d355e8d2ab07f2ab07f2ab07f30698e30698e21918c21918c21918c25848e25848e25848e4046884046883fbc733fbc733f +bc7322a78522a78522a785472f7d472f7d25ac8225ac8225ac82365d8d365d8d21918c21918c21918c423f85423f85423f8521a68521a68550c46a50c46a50c4 +6a22a88422a88422a88421908d21908d287d8e287d8e287d8e2d718e2d718e27808e27808e27808e238a8d238a8d238a8d1e9b8a1e9b8a34b67934b67934b679 +2eb37c2eb37c2eb37c277e8e277e8e25858e25858e25858e2cb17e2cb17e2cb17e1f958b1f958b39568c39568c39568c1f998a1f998a1f998a355e8d355e8d2a +b07f2ab07f2ab07f30698e30698e21918c21918c21918c25848e25848e25848e4046884046883fbc733fbc733fbc7322a78522a78522a785472f7d472f7d2979 +8e29798e29798e25858e25858e218f8d218f8d218f8d2b758e2b758e2b758e24868e24868e3dbc743dbc743dbc741fa1881fa1881fa1881f958b1f958b218e8d +218e8d218e8d218f8d218f8d24868e24868e24868e2c728e2c728e2c728e2ab07f2ab07f1fa0881fa0881fa08832648e32648e32648e1f978b1f978b29798e29 +798e29798e1f978b1f978b1f978b20a38620a3865cc8635cc8635cc8631f998a1f998a1f998a5ec9625ec9622a768e2a768e2a768e58c76558c76523898e2389 +8e23898e40bd7240bd7240bd7226ad8126ad8122a78522a78522a785287c8e287c8e287c8e297b8e297b8e29798e29798e29798e25858e25858e218f8d218f8d +218f8d2b758e2b758e2b758e24868e24868e3dbc743dbc743dbc741fa1881fa1881fa1881f958b1f958b218e8d218e8d218e8d218f8d218f8d24868e24868e24 +868e2c728e2c728e2c728e2ab07f2ab07f1fa0881fa0881fa08832648e32648e32648e1f978b1f978b29798e29798e29798e1f978b1f978b1f978b20a38620a3 +865cc8635cc8635cc8631f998a1f998a1f998a5ec9625ec9622a768e2a768e2a768e58c76558c76523898e23898e23898e40bd7240bd7240bd7226ad8126ad81 +22a78522a78522a785287c8e287c8e287c8e297b8e297b8e23888e23888e23888e238a8d238a8d2e6f8e2e6f8e2e6f8e306a8e306a8e306a8e21908d21908d39 +568c39568c39568c228c8d228c8d228c8d21918c21918c27ad8127ad8127ad81238a8d238a8d32658e32658e32658e2c738e2c738e2c738e34608d34608d3069 +8e30698e30698e20a48620a48620a48632658e32658e1f978b1f978b1f978b23a98323a98323a983481769481769297a8e297a8e297a8e3bbb753bbb753bbb75 +1f988b1f988b443a83443a83443a83297b8e297b8e2e6f8e2e6f8e2e6f8e26828e26828e26828e26828e26828e228d8d228d8d228d8d277f8e277f8e277f8e32 +658e32658e23888e23888e23888e238a8d238a8d2e6f8e2e6f8e2e6f8e306a8e306a8e306a8e21908d21908d39568c39568c39568c228c8d228c8d228c8d2191 +8c21918c27ad8127ad8127ad81238a8d238a8d32658e32658e32658e2c738e2c738e2c738e34608d34608d30698e30698e30698e20a48620a48620a48632658e +32658e1f978b1f978b1f978b23a98323a98323a983481769481769297a8e297a8e297a8e3bbb753bbb753bbb751f988b1f988b443a83443a83443a83297b8e29 +7b8e2e6f8e2e6f8e2e6f8e26828e26828e26828e26828e26828e228d8d228d8d228d8d277f8e277f8e277f8e32658e32658e23888e23888e23888e238a8d238a +8d2e6f8e2e6f8e2e6f8e306a8e306a8e306a8e21908d21908d39568c39568c39568c228c8d228c8d228c8d21918c21918c27ad8127ad8127ad81238a8d238a8d +32658e32658e32658e2c738e2c738e2c738e34608d34608d30698e30698e30698e20a48620a48620a48632658e32658e1f978b1f978b1f978b23a98323a98323 +a983481769481769297a8e297a8e297a8e3bbb753bbb753bbb751f988b1f988b443a83443a83443a83297b8e297b8e2e6f8e2e6f8e2e6f8e26828e26828e2682 +8e26828e26828e228d8d228d8d228d8d277f8e277f8e277f8e32658e32658e228c8d228c8d228c8d297b8e297b8e297b8e297b8e297b8e2b758e2b758e2b758e +1f9e891f9e893e4c8a3e4c8a3e4c8a20a48620a48620a48625ac8225ac821f988b1f988b1f988b20928c20928c3e49893e49893e4989218f8d218f8d218f8d21 +a68521a6852b748e2b748e2b748e23888e23888e23888e2a768e2a768e277e8e277e8e277e8e1f9a8a1f9a8a1f9a8a1f9a8a1f9a8a23898e23898e23898e2486 +8e24868e24868e1f9f881f9f8835b77935b77935b77921a68521a6853dbc743dbc743dbc74228b8d228b8d228b8d3b528b3b528b27808e27808e27808e25848e +25848e25848e26ad8126ad81228c8d228c8d228c8d297b8e297b8e297b8e297b8e297b8e2b758e2b758e2b758e1f9e891f9e893e4c8a3e4c8a3e4c8a20a48620 +a48620a48625ac8225ac821f988b1f988b1f988b20928c20928c3e49893e49893e4989218f8d218f8d218f8d21a68521a6852b748e2b748e2b748e23888e2388 +8e23888e2a768e2a768e277e8e277e8e277e8e1f9a8a1f9a8a1f9a8a1f9a8a1f9a8a23898e23898e23898e24868e24868e24868e1f9f881f9f8835b77935b779 +35b77921a68521a6853dbc743dbc743dbc74228b8d228b8d228b8d3b528b3b528b27808e27808e27808e25848e25848e25848e26ad8126ad813fbc733fbc733f +bc731f9f881f9f8824868e24868e24868e3a538b3a538b3a538b1f9e891f9e892e6d8e2e6d8e2e6d8e1f948c1f948c1f948c228d8d228d8d21a68521a68521a6 +851f968b1f968b1f9f881f9f881f9f8823888e23888e23888e1e9b8a1e9b8a23898e23898e23898e355e8d355e8d355e8d27808e27808e443983443983443983 +21a58521a58521a5852c738e2c738e33638d33638d33638d33628d33628d33628d2e6f8e2e6f8e1f9f881f9f881f9f881f9e891f9e8920a38620a38620a38621 +8f8d218f8d218f8d2ab07f2ab07f306a8e306a8e306a8e2d708e2d708e2d708e4ac16d4ac16d3fbc733fbc733fbc731f9f881f9f8824868e24868e24868e3a53 +8b3a538b3a538b1f9e891f9e892e6d8e2e6d8e2e6d8e1f948c1f948c1f948c228d8d228d8d21a68521a68521a6851f968b1f968b1f9f881f9f881f9f8823888e +23888e23888e1e9b8a1e9b8a23898e23898e23898e355e8d355e8d355e8d27808e27808e44398344398344398321a58521a58521a5852c738e2c738e33638d33 +638d33638d33628d33628d33628d2e6f8e2e6f8e1f9f881f9f881f9f881f9e891f9e8920a38620a38620a386218f8d218f8d218f8d2ab07f2ab07f306a8e306a +8e306a8e2d708e2d708e2d708e4ac16d4ac16d3fbc733fbc733fbc731f9f881f9f8824868e24868e24868e3a538b3a538b3a538b1f9e891f9e892e6d8e2e6d8e +2e6d8e1f948c1f948c1f948c228d8d228d8d21a68521a68521a6851f968b1f968b1f9f881f9f881f9f8823888e23888e23888e1e9b8a1e9b8a23898e23898e23 +898e355e8d355e8d355e8d27808e27808e44398344398344398321a58521a58521a5852c738e2c738e33638d33638d33638d33628d33628d33628d2e6f8e2e6f +8e1f9f881f9f881f9f881f9e891f9e8920a38620a38620a386218f8d218f8d218f8d2ab07f2ab07f306a8e306a8e306a8e2d708e2d708e2d708e4ac16d4ac16d +2a768e2a768e2a768e238a8d238a8d2a768e2a768e2a768e1fa1881fa1881fa1881f988b1f988b20a38620a38620a386228c8d228c8d228c8d443b84443b8423 +a98323a98323a98334618d34618d365d8d365d8d365d8d218f8d218f8d218f8d228c8d228c8d24aa8324aa8324aa832b748e2b748e2b748e2a768e2a768e2583 +8e25838e25838e2a788e2a788e2a788e3dbc743dbc7424868e24868e24868e375b8d375b8d375b8d21a58521a58525848e25848e25848e277e8e277e8e238a8d +238a8d238a8d24878e24878e24878e25ac8225ac821f9a8a1f9a8a1f9a8a44bf7044bf7044bf702a788e2a788e2a768e2a768e2a768e238a8d238a8d2a768e2a +768e2a768e1fa1881fa1881fa1881f988b1f988b20a38620a38620a386228c8d228c8d228c8d443b84443b8423a98323a98323a98334618d34618d365d8d365d +8d365d8d218f8d218f8d218f8d228c8d228c8d24aa8324aa8324aa832b748e2b748e2b748e2a768e2a768e25838e25838e25838e2a788e2a788e2a788e3dbc74 +3dbc7424868e24868e24868e375b8d375b8d375b8d21a58521a58525848e25848e25848e277e8e277e8e238a8d238a8d238a8d24878e24878e24878e25ac8225 +ac821f9a8a1f9a8a1f9a8a44bf7044bf7044bf702a788e2a788e2a768e2a768e2a768e3bbb753bbb7526828e26828e26828e38588c38588c38588c25858e2585 +8e1f998a1f998a1f998a2c738e2c738e2c738e1f968b1f968b31668e31668e31668e3b518b3b518b26818e26818e26818e228c8d228c8d228c8d31678e31678e +228d8d228d8d228d8d2f6b8e2f6b8e2f6b8e228b8d228b8d297a8e297a8e297a8e2eb37c2eb37c2eb37c1f988b1f988b2c718e2c718e2c718e355f8d355f8d35 +5f8d20938c20938c26818e26818e26818e1f9e891f9e8931668e31668e31668e20928c20928c20928c228c8d228c8d33638d33638d33638d2e6d8e2e6d8e2e6d +8e23888e23888e2a768e2a768e2a768e3bbb753bbb7526828e26828e26828e38588c38588c38588c25858e25858e1f998a1f998a1f998a2c738e2c738e2c738e +1f968b1f968b31668e31668e31668e3b518b3b518b26818e26818e26818e228c8d228c8d228c8d31678e31678e228d8d228d8d228d8d2f6b8e2f6b8e2f6b8e22 +8b8d228b8d297a8e297a8e297a8e2eb37c2eb37c2eb37c1f988b1f988b2c718e2c718e2c718e355f8d355f8d355f8d20938c20938c26818e26818e26818e1f9e +891f9e8931668e31668e31668e20928c20928c20928c228c8d228c8d33638d33638d33638d2e6d8e2e6d8e2e6d8e23888e23888e2a768e2a768e2a768e3bbb75 +3bbb7526828e26828e26828e38588c38588c38588c25858e25858e1f998a1f998a1f998a2c738e2c738e2c738e1f968b1f968b31668e31668e31668e3b518b3b +518b26818e26818e26818e228c8d228c8d228c8d31678e31678e228d8d228d8d228d8d2f6b8e2f6b8e2f6b8e228b8d228b8d297a8e297a8e297a8e2eb37c2eb3 +7c2eb37c1f988b1f988b2c718e2c718e2c718e355f8d355f8d355f8d20938c20938c26818e26818e26818e1f9e891f9e8931668e31668e31668e20928c20928c +20928c228c8d228c8d33638d33638d33638d2e6d8e2e6d8e2e6d8e23888e23888e23898e23898e23898e1f988b1f988b1fa1871fa1871fa1873e4a893e4a893e +4a8925858e25858e29798e29798e29798e1fa1881fa1881fa1882eb37c2eb37c1e9b8a1e9b8a1e9b8a26828e26828e1f9e891f9e891f9e892a788e2a788e2a78 +8e297a8e297a8e20938c20938c20938c48186a48186a48186a355e8d355e8d25858e25858e25858e26828e26828e26828e23888e23888e4ac16d4ac16d4ac16d +1f948c1f948c1f948c21918c21918c35b77935b77935b77938b97738b97731668e31668e31668e20a38620a38620a3861f9f881f9f881fa0881fa0881fa08833 +628d33628d33628d5cc8635cc86323898e23898e23898e1f988b1f988b1fa1871fa1871fa1873e4a893e4a893e4a8925858e25858e29798e29798e29798e1fa1 +881fa1881fa1882eb37c2eb37c1e9b8a1e9b8a1e9b8a26828e26828e1f9e891f9e891f9e892a788e2a788e2a788e297a8e297a8e20938c20938c20938c48186a +48186a48186a355e8d355e8d25858e25858e25858e26828e26828e26828e23888e23888e4ac16d4ac16d4ac16d1f948c1f948c1f948c21918c21918c35b77935 +b77935b77938b97738b97731668e31668e31668e20a38620a38620a3861f9f881f9f881fa0881fa0881fa08833628d33628d33628d5cc8635cc86325ab8225ab +8225ab8220a48620a4861e9b8a1e9b8a1e9b8a42be7142be7142be712b758e2b758e297a8e297a8e297a8e25ab8225ab8225ab8222a88422a8842d708e2d708e +2d708e33628d33628d4cc26c4cc26c4cc26c27808e27808e27808e1fa2871fa287238a8d238a8d238a8d1fa0881fa0881fa08831b57b31b57b31668e31668e31 +668e3fbc733fbc733fbc7331b57b31b57b21908d21908d21908d2f6b8e2f6b8e2f6b8e24aa8324aa83287c8e287c8e287c8e297a8e297a8e24878e24878e2487 +8e31668e31668e31668e33628d33628d365c8d365c8d365c8d2db27d2db27d2db27d29798e29798e25ab8225ab8225ab8220a48620a4861e9b8a1e9b8a1e9b8a +42be7142be7142be712b758e2b758e297a8e297a8e297a8e25ab8225ab8225ab8222a88422a8842d708e2d708e2d708e33628d33628d4cc26c4cc26c4cc26c27 +808e27808e27808e1fa2871fa287238a8d238a8d238a8d1fa0881fa0881fa08831b57b31b57b31668e31668e31668e3fbc733fbc733fbc7331b57b31b57b2190 +8d21908d21908d2f6b8e2f6b8e2f6b8e24aa8324aa83287c8e287c8e287c8e297a8e297a8e24878e24878e24878e31668e31668e31668e33628d33628d365c8d +365c8d365c8d2db27d2db27d2db27d29798e29798e +grestore +0.800 setlinewidth +1 setlinejoin +0 setlinecap +[] 0 setdash +0.000 setgray +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +54.4203 23.4222 translate +0 rotate +0 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +105.216 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +102.036 23.4222 translate +0 rotate +0 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +152.832 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +146.473 23.4222 translate +0 rotate +0 0 m /one glyphshow +6.3623 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +200.448 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +194.089 23.4222 translate +0 rotate +0 0 m /one glyphshow +6.3623 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +248.064 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +241.705 23.4222 translate +0 rotate +0 0 m /two glyphshow +6.3623 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +295.68 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +289.321 23.4222 translate +0 rotate +0 0 m /two glyphshow +6.3623 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +0 -3.5 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +343.296 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +336.937 23.4222 translate +0 rotate +0 0 m /three glyphshow +6.3623 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 38.016 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +44.2406 34.2191 translate +0 rotate +0 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 82.368 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +44.2406 78.5711 translate +0 rotate +0 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 126.72 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +37.8813 122.923 translate +0 rotate +0 0 m /one glyphshow +6.3623 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 171.072 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +37.8813 167.275 translate +0 rotate +0 0 m /one glyphshow +6.3623 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 215.424 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +37.8813 211.627 translate +0 rotate +0 0 m /two glyphshow +6.3623 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 259.776 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +37.8813 255.979 translate +0 rotate +0 0 m /two glyphshow +6.3623 0 m /five glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +-0 0 m +-3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +57.6 304.128 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +37.8813 300.331 translate +0 rotate +0 0 m /three glyphshow +6.3623 0 m /zero glyphshow +grestore +0 setlinejoin +2 setlinecap +gsave +57.6 38.016 m +57.6 304.128 l +stroke +grestore +gsave +343.296 38.016 m +343.296 304.128 l +stroke +grestore +gsave +57.6 38.016 m +343.296 38.016 l +stroke +grestore +gsave +57.6 304.128 m +343.296 304.128 l +stroke +grestore +gsave +361.152 38.016 m +374.4576 38.016 l +374.4576 304.128 l +361.152 304.128 l +cl +1.000 setgray +fill +grestore +gsave + +361.15 38.02 translate +[1 0 0 1 0 0] concat +13.31 266.11 scale +/DataString 4 string def +4 73 8 [ 4 0 0 -73 0 73 ] +{ +currentfile DataString readhexstring pop +} bind false 3 colorimage +f6e620f6e620f6e620f6e620efe51cefe51cefe51cefe51ce5e419e5e419e5e419e5e419dde318dde318dde318dde318d2e21bd2e21bd2e21bd2e21bcae11fca +e11fcae11fcae11fc0df25c0df25c0df25c0df25b8de29b8de29b8de29b8de29addc30addc30addc30addc30a5db36a5db36a5db36a5db369bd93c9bd93c9bd9 +3c9bd93c93d74193d74193d74193d7418bd6468bd6468bd6468bd64681d34d81d34d81d34d81d34d7ad1517ad1517ad1517ad15170cf5770cf5770cf5770cf57 +69cd5b69cd5b69cd5b69cd5b60ca6060ca6060ca6060ca605ac8645ac8645ac8645ac86452c56952c56952c56952c5694cc26c4cc26c4cc26c4cc26c44bf7044 +bf7044bf7044bf703fbc733fbc733fbc733fbc7338b97738b97738b97738b97734b67934b67934b67934b6792fb47c2fb47c2fb47c2fb47c2ab07f2ab07f2ab0 +7f2ab07f27ad8127ad8127ad8127ad8124aa8324aa8324aa8324aa8322a78522a78522a78522a78520a38620a38620a38620a3861fa1881fa1881fa1881fa188 +1e9d891e9d891e9d891e9d891f9a8a1f9a8a1f9a8a1f9a8a1f968b1f968b1f968b1f968b20938c20938c20938c20938c21908d21908d21908d21908d228d8d22 +8d8d228d8d228d8d238a8d238a8d238a8d238a8d24868e24868e24868e24868e25838e25838e25838e25838e27808e27808e27808e27808e287d8e287d8e287d +8e287d8e29798e29798e29798e29798e2a768e2a768e2a768e2a768e2c728e2c728e2c728e2c728e2d708e2d708e2d708e2d708e2f6c8e2f6c8e2f6c8e2f6c8e +30698e30698e30698e30698e32658e32658e32658e32658e33628d33628d33628d33628d355e8d355e8d355e8d355e8d375b8d375b8d375b8d375b8d38588c38 +588c38588c38588c3a538b3a538b3a538b3a538b3c508b3c508b3c508b3c508b3e4c8a3e4c8a3e4c8a3e4c8a3f48893f48893f48893f48894144874144874144 +87414487424086424086424086424086443b84443b84443b84443b8445388245388245388245388246337f46337f46337f46337f472f7d472f7d472f7d472f7d +472a7a472a7a472a7a472a7a482677482677482677482677482374482374482374482374481d6f481d6f481d6f481d6f481a6c481a6c481a6c481a6c48146748 +1467481467481467471063471063471063471063460a5d460a5d460a5d460a5d450559450559450559450559 +grestore +1 setlinejoin +0 setlinecap +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 59.0459 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 55.249 translate +0 rotate +0 0 m /minus glyphshow +8.37891 0 m /three glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 93.9024 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 90.1056 translate +0 rotate +0 0 m /minus glyphshow +8.37891 0 m /two glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 128.759 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 124.962 translate +0 rotate +0 0 m /minus glyphshow +8.37891 0 m /one glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 163.616 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 159.819 translate +0 rotate +0 0 m /zero glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 198.472 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 194.675 translate +0 rotate +0 0 m /one glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 233.329 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 229.532 translate +0 rotate +0 0 m /two glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 268.185 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 264.388 translate +0 rotate +0 0 m /three glyphshow +grestore +gsave +/o { +gsave +newpath +translate +0.8 setlinewidth +1 setlinejoin + +0 setlinecap + +0 0 m +3.5 0 l + +gsave +0.000 setgray +fill +grestore +stroke +grestore +} bind def +374.458 303.042 o +grestore +/DejaVuSans 10.000 selectfont +gsave + +381.458 299.245 translate +0 rotate +0 0 m /four glyphshow +grestore +0 setlinejoin +2 setlinecap +gsave +361.152 38.016 m +367.8048 38.016 l +374.4576 38.016 l +374.4576 304.128 l +367.8048 304.128 l +361.152 304.128 l +361.152 38.016 l +cl +stroke +grestore + +end +showpage diff --git a/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.pdf b/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.pdf index 5e3b389b1dea..82b2e6b8be56 100644 Binary files a/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.pdf and b/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.pdf differ diff --git a/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.svg b/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.svg index 505ea417de02..5d48ad02e998 100644 --- a/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.svg +++ b/lib/matplotlib/tests/baseline_images/test_bbox_tight/bbox_inches_tight_raster.svg @@ -1,7 +1,7 @@ - + - + +" id="mc63e59a608" style="stroke:#000000;stroke-width:0.5;"/> - + - + - + - + - + - + - + - + - + - + - + @@ -138,80 +138,80 @@ L 0 4 +" id="m556f96d829" style="stroke:#000000;stroke-width:0.5;"/> - + +" id="m27e32ca04a" style="stroke:#000000;stroke-width:0.5;"/> - + - + - + - + - + - + - + - + - + - + - + diff --git a/lib/matplotlib/tests/baseline_images/test_constrainedlayout/constrained_layout4.svg b/lib/matplotlib/tests/baseline_images/test_constrainedlayout/constrained_layout4.svg index 1f194eb09342..cd58ba633d3f 100644 --- a/lib/matplotlib/tests/baseline_images/test_constrainedlayout/constrained_layout4.svg +++ b/lib/matplotlib/tests/baseline_images/test_constrainedlayout/constrained_layout4.svg @@ -1,7 +1,7 @@ - +