diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_01.js new file mode 100644 index 0000000000000000000000000000000000000000..379af4f3eda7877d59dc2225acad481d4e28d436 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_01.js @@ -0,0 +1,622 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_01", + "required_fields": ["x", "y"], + "required_fields_type": [["temporal"], ["numerical"]], + "required_fields_range": [[15, 50], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_title": true, + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = Math.max(835, Math.round(width * 1.39)); + const navy = "#092b55"; + const deepNavy = "#06254a"; + const red = colorResolver.other("primary", { fallback: "#b70812" }).value; + const red2 = d3.color(red)?.brighter(1.2).formatHex() || "#ef3f39"; + const paleBlue = "#d9f4fb"; + const panelFill = "#fbffff"; + + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const xDescription = xChannel.description || xField; + const yDescription = yChannel.description || yField; + + function parseTemporal(value) { + const parsed = chartUtils.format.parseDate(value); + if (parsed instanceof Date && !isNaN(parsed)) return parsed; + if (typeof value === "number") return new Date(value, 0, 1); + const numeric = Number(String(value).match(/\d{4}/)?.[0]); + if (Number.isFinite(numeric)) return new Date(numeric, 0, 1); + return new Date(2000, 0, 1); + } + + const processedData = chartData + .map((d, i) => ({ + raw: d, + time: parseTemporal(d[xField]), + xRaw: d[xField], + value: Number(d[yField]), + originalIndex: i + })) + .filter(d => Number.isFinite(d.value)) + .sort((a, b) => a.time - b.time || a.originalIndex - b.originalIndex); + + processedData.forEach((d, i) => { + d.order = i; + }); + + const titles = jsonData.titles || {}; + const metadata = jsonData.metadata || {}; + const mainTitle = String(titles.main_title || metadata.title || "Rising Values Over Time").trim(); + const subtitle = String(titles.sub_title || metadata.main_insight || metadata.description || "").trim(); + const first = processedData[0]; + const last = processedData[processedData.length - 1] || first; + const delta = first && last ? last.value - first.value : 0; + + function yearLabel(d) { + if (!d) return ""; + const year = d.time instanceof Date && !isNaN(d.time) ? d.time.getFullYear() : d.xRaw; + return String(year); + } + + function valueText(v) { + if (!Number.isFinite(v)) return ""; + const abs = Math.abs(v); + const digits = Number.isInteger(v) || abs >= 10 ? 0 : 1; + return d3.format(`,.${digits}f`)(v).replace(/\.0$/, ""); + } + + function shortValue(v) { + if (!Number.isFinite(v)) return ""; + const abs = Math.abs(v); + if (abs >= 1000) { + return d3.format(".3s")(v).replace("G", "B"); + } + return valueText(v); + } + + function titleParts(title) { + const lower = title.toLowerCase(); + const inIdx = lower.lastIndexOf(" in "); + const overIdx = lower.lastIndexOf(" over "); + const idx = Math.max(inIdx, overIdx); + if (idx > 8) { + return [title.slice(0, idx).trim(), title.slice(idx).trim()]; + } + const words = title.split(/\s+/); + if (words.length <= 4) return [title, ""]; + const split = Math.ceil(words.length / 2); + return [words.slice(0, split).join(" "), words.slice(split).join(" ")]; + } + + function wrapWords(text, maxChars, maxLines) { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let line = ""; + words.forEach(word => { + const test = line ? `${line} ${word}` : word; + if (test.length <= maxChars || !line) { + line = test; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = lines.slice(maxLines - 1).join(" "); + return kept; + } + return lines; + } + + function addWrappedText(parent, lines, x, y, lineHeight, attrs = {}) { + const text = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", attrs.anchor || "middle") + .attr("font-family", attrs.family || "Arial, Helvetica, sans-serif") + .attr("font-size", attrs.size || 16) + .attr("font-weight", attrs.weight || 600) + .attr("fill", attrs.fill || navy) + .attr("letter-spacing", 0); + lines.forEach((line, i) => { + text.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : lineHeight) + .text(line); + }); + return text; + } + + const [titleLine1, titleLine2] = titleParts(mainTitle); + const titleLine1Parts = wrapWords(titleLine1.toUpperCase(), 28, 2); + const titleLine2Parts = titleLine2 ? wrapWords(titleLine2, 27, 2) : []; + const maxTitleLineChars = Math.max( + 0, + ...titleLine1Parts.map(d => d.length), + ...titleLine2Parts.map(d => d.length) + ); + const titleFont1 = maxTitleLineChars > 26 || titleLine1Parts.length > 1 ? 28 : 34; + const titleFont2 = maxTitleLineChars > 24 || titleLine2Parts.length > 1 ? 34 : 43; + const subtitleLines = wrapWords( + subtitle || `${yDescription} ${delta >= 0 ? "increased" : "changed"} from ${yearLabel(first)} to ${yearLabel(last)}.`, + 43, + 3 + ); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", "histogram01-bg") + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "0%").attr("y2", "100%") + .selectAll("stop") + .data([ + { offset: "0%", color: "#fffdf8" }, + { offset: "58%", color: "#f8fdff" }, + { offset: "100%", color: "#c8eff8" } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + defs.append("linearGradient") + .attr("id", "histogram01-bar") + .attr("x1", "0%").attr("y1", "100%") + .attr("x2", "0%").attr("y2", "0%") + .selectAll("stop") + .data([ + { offset: "0%", color: d3.color(red)?.darker(0.8).formatHex() || "#9f0710" }, + { offset: "100%", color: red2 } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + defs.append("clipPath") + .attr("id", "histogram01-topic-slot-clip") + .append("circle") + .attr("cx", 0) + .attr("cy", 0) + .attr("r", 128); + + defs.append("filter") + .attr("id", "histogram01-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "140%") + .append("feDropShadow") + .attr("dx", 0) + .attr("dy", 6) + .attr("stdDeviation", 7) + .attr("flood-color", "#557b8a") + .attr("flood-opacity", 0.18); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#histogram01-bg)"); + + svg.append("path") + .attr("d", `M0 ${height - 142} C ${width * 0.18} ${height - 174}, ${width * 0.33} ${height - 118}, ${width * 0.52} ${height - 150} S ${width * 0.82} ${height - 179}, ${width} ${height - 124} L ${width} ${height} L 0 ${height} Z`) + .attr("fill", "#bfeefa") + .attr("opacity", 0.72); + + svg.append("path") + .attr("d", `M0 ${height - 99} C ${width * 0.20} ${height - 130}, ${width * 0.39} ${height - 92}, ${width * 0.58} ${height - 118} S ${width * 0.83} ${height - 134}, ${width} ${height - 72} L ${width} ${height} L 0 ${height} Z`) + .attr("fill", "#87d7eb") + .attr("opacity", 0.58); + + const header = svg.append("g").attr("class", "histogram01-header"); + header.append("line") + .attr("x1", width * 0.20) + .attr("x2", width * 0.28) + .attr("y1", 38) + .attr("y2", 38) + .attr("stroke", "#d4a56c") + .attr("stroke-width", 2); + header.append("line") + .attr("x1", width * 0.72) + .attr("x2", width * 0.80) + .attr("y1", 38) + .attr("y2", 38) + .attr("stroke", "#d4a56c") + .attr("stroke-width", 2); + + let titleCursorY = 76; + titleLine1Parts.forEach((line, i) => { + header.append("text") + .attr("x", width / 2) + .attr("y", titleCursorY + i * (titleFont1 + 7)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleFont1) + .attr("font-weight", 900) + .attr("letter-spacing", 0) + .attr("fill", deepNavy) + .text(line); + }); + titleCursorY += titleLine1Parts.length * (titleFont1 + 7); + + titleLine2Parts.forEach((line, i) => { + header.append("text") + .attr("x", width / 2) + .attr("y", titleCursorY + i * (titleFont2 + 3)) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, 'Times New Roman', serif") + .attr("font-size", titleFont2) + .attr("font-weight", 800) + .attr("letter-spacing", 0) + .attr("fill", red) + .text(line); + }); + titleCursorY += titleLine2Parts.length * (titleFont2 + 3); + + const pillX = width * 0.14; + const pillY = Math.max(128, titleCursorY + 22); + const pillW = width * 0.72; + const pillH = subtitleLines.length > 2 ? 78 : (subtitleLines.length > 1 ? 64 : 52); + header.append("rect") + .attr("x", pillX) + .attr("y", pillY) + .attr("width", pillW) + .attr("height", pillH) + .attr("rx", 13) + .attr("fill", "#fbffff") + .attr("stroke", "#a7d4e5") + .attr("stroke-width", 1.5); + + const trendCx = pillX + 34; + const trendCy = pillY + pillH / 2; + const trendSlot = header.append("g") + .attr("class", "reserved-asset-slot histogram01-trend-mark-slot") + .attr("data-asset-slot", "histogram-trend-mark") + .attr("data-slot-policy", "neutral_placeholder") + .attr("data-anchor", "insight-pill-left-inset") + .attr("data-collision-rule", "avoid-insight-pill-text") + .attr("transform", `translate(${trendCx},${trendCy})`); + trendSlot.append("circle") + .attr("r", 22) + .attr("fill", red) + .attr("opacity", 0.94); + const direction = delta >= 0 ? -1 : 1; + trendSlot.append("polyline") + .attr("points", direction < 0 ? "-11,7 -2,-3 5,1 12,-10" : "-11,-7 -2,3 5,-1 12,10") + .attr("fill", "none") + .attr("stroke", "#ffffff") + .attr("stroke-width", 4) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + + addWrappedText(header, subtitleLines, pillX + 72, pillY + 24, 21, { + anchor: "start", + size: subtitleLines.length > 2 ? 12 : (subtitleLines.length > 1 ? 14 : 16), + weight: 700, + fill: deepNavy + }); + + const panelY = Math.min(300, Math.max(268, pillY + pillH + 32)); + const panel = { + x: 42, + y: panelY, + w: width - 84, + h: 430 + }; + const plot = { + x: panel.x + 30, + y: panel.y + 61, + w: panel.w - 60, + h: panel.h - 104 + }; + + svg.append("rect") + .attr("class", "histogram01-plot-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 18) + .attr("fill", panelFill) + .attr("stroke", "#d6eef5") + .attr("stroke-width", 1.6) + .attr("opacity", 0.94); + + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value) || 1]) + .nice(5) + .range([plot.y + plot.h, plot.y]) + .nice(); + + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.order)) + .range([plot.x, plot.x + plot.w]) + .paddingInner(processedData.length > 18 ? 0.26 : 0.31) + .paddingOuter(0.05); + + const gridTicks = yScale.ticks(5); + const grid = svg.append("g").attr("class", "histogram01-grid"); + grid.selectAll("line") + .data(gridTicks) + .enter() + .append("line") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", d => yScale(d)) + .attr("y2", d => yScale(d)) + .attr("stroke", "#a8d2df") + .attr("stroke-dasharray", "3 4") + .attr("stroke-width", 1) + .attr("opacity", d => d === 0 ? 0 : 0.8); + + svg.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x) + .attr("y1", plot.y) + .attr("y2", plot.y + plot.h) + .attr("stroke", navy) + .attr("stroke-width", 2); + svg.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", plot.y + plot.h) + .attr("y2", plot.y + plot.h) + .attr("stroke", navy) + .attr("stroke-width", 2); + + const axisTitleLines = wrapWords( + `${String(yField).replace(/([a-z])([A-Z])/g, "$1 $2")}${yUnit ? ` (${yUnit})` : ""}`, + 15, + 4 + ); + svg.append("text") + .attr("x", panel.x + 12) + .attr("y", plot.y - 44) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 13) + .attr("font-weight", 900) + .attr("fill", deepNavy) + .selectAll("tspan") + .data(axisTitleLines) + .enter() + .append("tspan") + .attr("x", panel.x + 12) + .attr("dy", (d, i) => i === 0 ? 0 : 15) + .text(d => d); + + svg.selectAll(".histogram01-y-tick") + .data(gridTicks) + .enter() + .append("text") + .attr("class", "histogram01-y-tick") + .attr("x", plot.x - 10) + .attr("y", d => yScale(d) + 5) + .attr("text-anchor", "end") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 15) + .attr("font-weight", 800) + .attr("fill", "#0b5070") + .text(d => valueText(d)); + + const tickEvery = processedData.length > 20 ? 4 : (processedData.length > 15 ? 3 : 2); + let tickData = processedData.filter((d, i) => i === 0 || i === processedData.length - 1 || i % tickEvery === 0); + if (tickData.length > 2) { + const lastTick = tickData[tickData.length - 1]; + const prevTick = tickData[tickData.length - 2]; + if (lastTick.order - prevTick.order <= 1) { + tickData.splice(tickData.length - 2, 1); + } + } + svg.selectAll(".histogram01-x-tick") + .data(tickData) + .enter() + .append("text") + .attr("class", "histogram01-x-tick") + .attr("x", d => xScale(d.order) + xScale.bandwidth() / 2) + .attr("y", plot.y + plot.h + 27) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", processedData.length > 20 ? 12 : 14) + .attr("font-weight", 800) + .attr("fill", "#0b5070") + .text(d => yearLabel(d)); + + const slotCx = plot.x + plot.w * 0.33; + const slotCy = plot.y + plot.h * 0.31; + const slotR = Math.min(132, Math.max(105, plot.w * 0.27)); + const topicSlot = svg.append("g") + .attr("class", "reserved-asset-slot histogram01-topic-image-slot") + .attr("data-asset-slot", "histogram-topic-image") + .attr("data-slot-policy", "image2_asset") + .attr("data-slot-source-policy", "image2-generated-or-input-provided") + .attr("data-anchor", "left-upper-plot-panel") + .attr("data-collision-rule", "avoid-title-insight-pill-y-axis-labels-x-axis-labels-late-bars-value-labels-latest-callout") + .attr("transform", `translate(${slotCx},${slotCy})`) + .attr("opacity", 0.58); + topicSlot.append("circle") + .attr("class", "neutral-asset-placeholder") + .attr("r", slotR) + .attr("fill", "#eef9fc") + .attr("stroke", "#e9fbff") + .attr("stroke-width", 8) + .attr("filter", "url(#histogram01-soft-shadow)"); + topicSlot.append("circle") + .attr("class", "neutral-asset-placeholder") + .attr("r", slotR - 10) + .attr("fill", "none") + .attr("stroke", "#7ccfe3") + .attr("stroke-width", 2.2) + .attr("stroke-dasharray", "9 8") + .attr("opacity", 0.62); + topicSlot.append("line") + .attr("class", "neutral-asset-placeholder") + .attr("x1", -slotR * 0.48) + .attr("y1", -slotR * 0.48) + .attr("x2", slotR * 0.48) + .attr("y2", slotR * 0.48) + .attr("stroke", "#8ed7e8") + .attr("stroke-width", 2) + .attr("stroke-linecap", "round") + .attr("opacity", 0.38); + topicSlot.append("line") + .attr("class", "neutral-asset-placeholder") + .attr("x1", -slotR * 0.48) + .attr("y1", slotR * 0.48) + .attr("x2", slotR * 0.48) + .attr("y2", -slotR * 0.48) + .attr("stroke", "#8ed7e8") + .attr("stroke-width", 2) + .attr("stroke-linecap", "round") + .attr("opacity", 0.30); + topicSlot.append("circle") + .attr("class", "neutral-asset-placeholder") + .attr("r", Math.max(10, slotR * 0.09)) + .attr("fill", "none") + .attr("stroke", "#69bfd6") + .attr("stroke-width", 2) + .attr("opacity", 0.50); + + const barLayer = svg.append("g").attr("class", "histogram01-bars"); + barLayer.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar histogram01-bar") + .attr("data-x-value", d => d.xRaw) + .attr("data-y-value", d => d.value) + .attr("data-temporal-order", d => d.order) + .attr("x", d => xScale(d.order)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.max(1, plot.y + plot.h - yScale(d.value))) + .attr("rx", Math.min(7, xScale.bandwidth() * 0.32)) + .attr("ry", Math.min(7, xScale.bandwidth() * 0.32)) + .attr("fill", "url(#histogram01-bar)") + .attr("stroke", "#97050e") + .attr("stroke-width", 0.8); + + const labelEvery = processedData.length > 20 ? 2 : 1; + svg.selectAll(".histogram01-value-label") + .data(processedData.filter((d, i) => labelEvery === 1 || i % labelEvery === 0 || i === processedData.length - 1)) + .enter() + .append("text") + .attr("class", "histogram01-value-label") + .attr("data-anchor", "bar-top") + .attr("x", d => xScale(d.order) + xScale.bandwidth() / 2) + .attr("y", d => Math.max(plot.y + 13, yScale(d.value) - 7)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", processedData.length > 18 ? 10 : 12) + .attr("font-weight", 900) + .attr("fill", red) + .text(d => shortValue(d.value)); + + if (last) { + const lastX = xScale(last.order) + xScale.bandwidth() / 2; + const lastY = yScale(last.value); + const calloutW = 88; + const calloutH = 80; + const calloutX = Math.min(width - calloutW - 34, Math.max(panel.x + panel.w - calloutW - 14, lastX - calloutW + 8)); + const calloutY = Math.max(pillY + pillH + 18, plot.y - 104); + const callout = svg.append("g") + .attr("class", "histogram01-latest-callout") + .attr("data-annotation", "latest-value") + .attr("data-anchor", "last-chronological-bar") + .attr("data-collision-rule", "clamp-inside-right-safe-area-and-avoid-title-pill-panel-edge-value-labels"); + callout.append("rect") + .attr("x", calloutX) + .attr("y", calloutY) + .attr("width", calloutW) + .attr("height", calloutH) + .attr("rx", 13) + .attr("fill", "#fff8ef") + .attr("stroke", "#e7aa86") + .attr("stroke-width", 1.6) + .attr("filter", "url(#histogram01-soft-shadow)"); + callout.append("path") + .attr("d", `M${calloutX + calloutW * 0.70},${calloutY + calloutH} L${calloutX + calloutW * 0.76},${calloutY + calloutH + 18} L${calloutX + calloutW * 0.83},${calloutY + calloutH}`) + .attr("fill", "#fff8ef") + .attr("stroke", "#e7aa86") + .attr("stroke-width", 1.4) + .attr("stroke-linejoin", "round"); + callout.append("line") + .attr("x1", calloutX + calloutW * 0.76) + .attr("y1", calloutY + calloutH + 18) + .attr("x2", Math.min(plot.x + plot.w - 4, lastX)) + .attr("y2", Math.max(plot.y + 8, lastY - 8)) + .attr("stroke", "#e7aa86") + .attr("stroke-width", 1.1) + .attr("stroke-dasharray", "3 4") + .attr("opacity", 0.75); + callout.append("text") + .attr("x", calloutX + calloutW / 2) + .attr("y", calloutY + 34) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 29) + .attr("font-weight", 900) + .attr("fill", red) + .text(shortValue(last.value)); + callout.append("text") + .attr("x", calloutX + calloutW / 2) + .attr("y", calloutY + 56) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 12) + .attr("font-weight", 800) + .attr("fill", deepNavy) + .text(yearLabel(last)); + callout.append("text") + .attr("x", calloutX + calloutW / 2) + .attr("y", calloutY + 71) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 9.5) + .attr("font-weight", 700) + .attr("fill", "#7a5b50") + .text("latest value"); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_02.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_02.js new file mode 100644 index 0000000000000000000000000000000000000000..6f76591034e139b796ddef14e77ec66bf784bfeb --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_02.js @@ -0,0 +1,660 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_02", + "required_fields": ["x", "y"], + "required_fields_type": [["temporal"], ["numerical"]], + "required_fields_range": [[15, 50], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_title": true, + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const titles = jsonData.titles || {}; + const metadata = jsonData.metadata || {}; + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = Math.max(790, Math.round(width * 1.34)); + const bgTop = "#071925"; + const bgBottom = "#031018"; + const panelFill = "#0b2a36"; + const panelStroke = "#1e6a74"; + const mint = colorResolver.other("primary", { fallback: "#8fdd75" }).value; + const mintBright = d3.color(mint)?.brighter(0.8).formatHex() || "#b6f288"; + const mintDark = d3.color(mint)?.darker(1.05).formatHex() || "#5a9d4f"; + const amber = colorResolver.other("secondary", { fallback: "#ffd45a" }).value; + const textMain = "#f5fff7"; + const textMuted = "#8fb9bd"; + + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const xField = xChannel.key || "period"; + const yField = yChannel.key || "value"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const yDescription = yChannel.description || yField; + + function parseTemporal(value) { + const parsed = chartUtils.format.parseDate(value); + if (parsed instanceof Date && !isNaN(parsed)) return parsed; + if (typeof value === "number" && Number.isFinite(value)) return new Date(value, 0, 1); + const year = Number(String(value).match(/\d{4}/)?.[0]); + if (Number.isFinite(year)) return new Date(year, 0, 1); + return new Date(2000, 0, 1); + } + + const processedData = chartData + .map((d, i) => ({ + raw: d, + sourceIndex: i, + xRaw: d[xField], + time: parseTemporal(d[xField]), + value: Number(d[yField]) + })) + .filter(d => Number.isFinite(d.value)) + .sort((a, b) => a.time - b.time || a.sourceIndex - b.sourceIndex); + + processedData.forEach((d, i) => { + d.order = i; + }); + + const first = processedData[0]; + const last = processedData[processedData.length - 1] || first; + const maxDatum = processedData.reduce((best, d) => !best || d.value > best.value ? d : best, null); + const delta = first && last ? last.value - first.value : 0; + const growthPct = first && first.value ? (delta / Math.abs(first.value)) * 100 : 0; + + function yearLabel(d) { + if (!d) return ""; + if (d.time instanceof Date && !isNaN(d.time)) return String(d.time.getFullYear()); + return String(d.xRaw); + } + + function fieldLabel(text) { + return String(text || "") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/_/g, " "); + } + + function yAxisTitleText() { + const base = fieldLabel(yField).toUpperCase(); + if (!yUnit) return base; + return base.includes(`(${yUnit})`) ? base : `${base} (${yUnit})`; + } + + function valueText(v, compact = false) { + if (!Number.isFinite(v)) return ""; + if (compact && Math.abs(v) >= 1000) return d3.format(".3s")(v).replace("G", "B"); + const abs = Math.abs(v); + const digits = Number.isInteger(v) || abs >= 10 ? 0 : 1; + return d3.format(`,.${digits}f`)(v).replace(/\.0$/, ""); + } + + function wrapWords(text, maxChars, maxLines) { + const words = String(text || "").replace(/^"+|"+$/g, "").split(/\s+/).filter(Boolean); + const lines = []; + let line = ""; + words.forEach(word => { + const test = line ? `${line} ${word}` : word; + if (test.length <= maxChars || !line) { + line = test; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = lines.slice(maxLines - 1).join(" "); + return kept; + } + return lines; + } + + function addWrappedText(parent, lines, x, y, lineHeight, attrs = {}) { + const text = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", attrs.anchor || "middle") + .attr("font-family", attrs.family || "Arial, Helvetica, sans-serif") + .attr("font-size", attrs.size || 16) + .attr("font-weight", attrs.weight || 700) + .attr("fill", attrs.fill || textMain) + .attr("letter-spacing", 0); + lines.forEach((line, i) => { + text.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : lineHeight) + .text(line); + }); + return text; + } + + const title = String(titles.main_title || metadata.title || "Distribution Over Time").trim(); + const subtitle = String(titles.sub_title || metadata.main_insight || metadata.description || "").trim(); + function titleSegments(rawTitle) { + const match = String(rawTitle).match(/^(.*?)(US Automotive)(.*)$/i); + if (match) { + return { + top: match[1].trim() || "Revival of", + accent: match[2].trim(), + bottom: match[3].trim() || "Part Imports from Mexico" + }; + } + const words = String(rawTitle).split(/\s+/).filter(Boolean); + if (words.length <= 3) return { top: "", accent: rawTitle, bottom: "" }; + const accentStart = Math.max(1, Math.floor(words.length * 0.34)); + const accentEnd = Math.min(words.length, accentStart + Math.max(1, Math.ceil(words.length * 0.30))); + return { + top: words.slice(0, accentStart).join(" "), + accent: words.slice(accentStart, accentEnd).join(" "), + bottom: words.slice(accentEnd).join(" ") + }; + } + + const segmentedTitle = titleSegments(title); + const titleTopLines = wrapWords(segmentedTitle.top, 19, 1); + const titleAccentLines = wrapWords(segmentedTitle.accent, 18, 1); + const titleBottomLines = wrapWords(segmentedTitle.bottom, 30, 2); + const titleTopFont = Math.max(31, Math.min(45, 54 - Math.max(...titleTopLines.map(d => d.length), 0) * 0.8)); + const titleAccentFont = Math.max(40, Math.min(55, 70 - Math.max(...titleAccentLines.map(d => d.length), 0) * 1.25)); + const titleBottomFont = titleBottomLines.length > 1 ? 24 : 30; + const subtitleLines = wrapWords(subtitle, 43, 3); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", "histogram02-bg") + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "0%").attr("y2", "100%") + .selectAll("stop") + .data([ + { offset: "0%", color: bgTop }, + { offset: "64%", color: "#061722" }, + { offset: "100%", color: bgBottom } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + defs.append("linearGradient") + .attr("id", "histogram02-bar") + .attr("x1", "0%").attr("y1", "100%") + .attr("x2", "0%").attr("y2", "0%") + .selectAll("stop") + .data([ + { offset: "0%", color: mintDark }, + { offset: "56%", color: mint }, + { offset: "100%", color: mintBright } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + const shadow = defs.append("filter") + .attr("id", "histogram02-soft-shadow") + .attr("x", "-18%") + .attr("y", "-18%") + .attr("width", "136%") + .attr("height", "136%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 8) + .attr("flood-color", "#000000") + .attr("flood-opacity", 0.28); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#histogram02-bg)"); + + const header = svg.append("g").attr("class", "histogram02-header"); + header.append("line") + .attr("x1", width * 0.12) + .attr("x2", width * 0.30) + .attr("y1", 42) + .attr("y2", 42) + .attr("stroke", "#1e7475") + .attr("stroke-width", 1.4) + .attr("opacity", 0.85); + header.append("line") + .attr("x1", width * 0.70) + .attr("x2", width * 0.88) + .attr("y1", 42) + .attr("y2", 42) + .attr("stroke", "#1e7475") + .attr("stroke-width", 1.4) + .attr("opacity", 0.85); + + let titleY = 78; + titleTopLines.forEach((line, i) => { + header.append("text") + .attr("x", width / 2) + .attr("y", titleY + i * (titleTopFont + 4)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleTopFont) + .attr("font-weight", 900) + .attr("fill", textMain) + .attr("letter-spacing", 0) + .text(line); + }); + titleY += titleTopLines.length * (titleTopFont + 4); + + titleAccentLines.forEach((line, i) => { + header.append("text") + .attr("x", width / 2) + .attr("y", titleY + i * (titleAccentFont + 2)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleAccentFont) + .attr("font-weight", 900) + .attr("fill", mintBright) + .attr("letter-spacing", 0) + .text(line); + }); + titleY += titleAccentLines.length * (titleAccentFont + 2); + + titleBottomLines.forEach((line, i) => { + header.append("text") + .attr("x", width / 2) + .attr("y", titleY + i * (titleBottomFont + 4)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleBottomFont) + .attr("font-weight", 900) + .attr("fill", textMain) + .attr("letter-spacing", 0) + .text(line); + }); + titleY += Math.max(1, titleBottomLines.length) * (titleBottomFont + 4); + + const cardTop = Math.max(242, titleY + 22); + const introX = 78; + const introY = cardTop; + const introW = width - introX * 2; + const introH = subtitleLines.length > 2 ? 112 : 96; + const calloutW = 86; + const calloutH = 72; + const panelY = introY + introH + 24; + const panel = { + x: 32, + y: panelY, + w: width - 64, + h: Math.min(410, height - panelY - 34) + }; + const plot = { + x: panel.x + 52, + y: panel.y + 108, + w: panel.w - 88, + h: panel.h - 150 + }; + + const intro = svg.append("g") + .attr("class", "histogram02-intro-card") + .attr("data-chart-element", "intro-topic-card") + .attr("data-anchor", "below-title-above-chart-panel") + .attr("data-collision-rule", "avoid-title-chart-panel-latest-callout"); + intro.append("rect") + .attr("x", introX) + .attr("y", introY) + .attr("width", introW) + .attr("height", introH) + .attr("rx", 15) + .attr("fill", "#082735") + .attr("stroke", "#1e6a74") + .attr("stroke-width", 1.4) + .attr("filter", "url(#histogram02-soft-shadow)"); + + const iconCx = introX + 58; + const iconCy = introY + introH / 2; + const iconSlot = intro.append("g") + .attr("class", "reserved-asset-slot histogram02-topic-icon-slot") + .attr("data-asset-slot", "histogram-topic-icon") + .attr("data-slot-policy", "neutral_placeholder") + .attr("data-slot-source-policy", "image2-generated-or-input-provided") + .attr("data-anchor", "intro-card-left-inset") + .attr("data-bbox", `${iconCx - 34},${iconCy - 34},68,68`) + .attr("data-collision-rule", "contained-in-intro-card-avoid-intro-text-title-plot-panel") + .attr("transform", `translate(${iconCx},${iconCy})`); + iconSlot.append("circle") + .attr("class", "neutral-asset-placeholder") + .attr("r", 33) + .attr("fill", "#0d3a43") + .attr("stroke", mintBright) + .attr("stroke-width", 1.6) + .attr("opacity", 0.72); + iconSlot.append("line") + .attr("class", "neutral-asset-placeholder") + .attr("x1", -14) + .attr("x2", 14) + .attr("y1", -5) + .attr("y2", -5) + .attr("stroke", "#dffbf0") + .attr("stroke-width", 3) + .attr("stroke-linecap", "round") + .attr("opacity", 0.82); + iconSlot.append("line") + .attr("class", "neutral-asset-placeholder") + .attr("x1", -14) + .attr("x2", 14) + .attr("y1", 7) + .attr("y2", 7) + .attr("stroke", "#dffbf0") + .attr("stroke-width", 3) + .attr("stroke-linecap", "round") + .attr("opacity", 0.68); + + intro.append("line") + .attr("x1", introX + 116) + .attr("x2", introX + 116) + .attr("y1", introY + 24) + .attr("y2", introY + introH - 24) + .attr("stroke", "#476e79") + .attr("stroke-width", 1.3) + .attr("opacity", 0.9); + + if (subtitleLines.length) { + addWrappedText(intro, subtitleLines, introX + 138, introY + 39, 21, { + anchor: "start", + size: subtitleLines.length > 2 ? 14 : 15.5, + weight: 700, + fill: textMain + }); + } + + svg.append("rect") + .attr("class", "histogram02-plot-panel") + .attr("data-chart-element", "histogram-plot-area") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 18) + .attr("fill", panelFill) + .attr("stroke", panelStroke) + .attr("stroke-width", 1.5) + .attr("opacity", 0.96) + .attr("filter", "url(#histogram02-soft-shadow)"); + + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value) || 1]) + .nice(5) + .range([plot.y + plot.h, plot.y]); + + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.order)) + .range([plot.x, plot.x + plot.w]) + .paddingInner(processedData.length > 22 ? 0.24 : 0.29) + .paddingOuter(0.06); + + const gridTicks = yScale.ticks(5); + const grid = svg.append("g").attr("class", "histogram02-grid"); + grid.selectAll("line") + .data(gridTicks) + .enter() + .append("line") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", d => yScale(d)) + .attr("y2", d => yScale(d)) + .attr("stroke", "#315d65") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 5") + .attr("opacity", d => d === 0 ? 0 : 0.8); + + svg.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", plot.y + plot.h) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#67a982") + .attr("stroke-width", 1.7); + svg.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x) + .attr("y1", plot.y) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#3e7774") + .attr("stroke-width", 1.3) + .attr("opacity", 0.9); + + svg.selectAll(".histogram02-y-tick") + .data(gridTicks) + .enter() + .append("text") + .attr("class", "histogram02-y-tick") + .attr("x", plot.x - 12) + .attr("y", d => yScale(d) + 4) + .attr("text-anchor", "end") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 11) + .attr("font-weight", 800) + .attr("fill", "#9fc8c9") + .text(d => valueText(d, true)); + + addWrappedText(svg, wrapWords(yAxisTitleText(), 21, 2), plot.x, panel.y + 28, 13, { + anchor: "start", + size: 10.5, + weight: 900, + fill: "#b7dfd4" + }).attr("class", "histogram02-y-axis-title"); + + if (first && last) { + const annW = Math.min(250, plot.w * 0.45); + const annH = 62; + const annX = plot.x + plot.w * 0.39; + const annY = panel.y + 34; + const trendPoints = delta >= 0 + ? `${annX + 23},${annY + 42} ${annX + 42},${annY + 24} ${annX + 56},${annY + 34} ${annX + 72},${annY + 16}` + : `${annX + 23},${annY + 20} ${annX + 42},${annY + 38} ${annX + 56},${annY + 28} ${annX + 72},${annY + 46}`; + const ann = svg.append("g") + .attr("class", "histogram02-growth-annotation") + .attr("data-annotation", "growth-from-first-to-last") + .attr("data-anchor", "plot-upper-middle") + .attr("data-collision-rule", "float-above-bars-and-below-intro-card-within-panel"); + ann.append("rect") + .attr("x", annX) + .attr("y", annY) + .attr("width", annW) + .attr("height", annH) + .attr("rx", 13) + .attr("fill", "#0b3344") + .attr("stroke", "#2b7e87") + .attr("stroke-width", 1.3) + .attr("opacity", 0.96); + ann.append("polyline") + .attr("points", trendPoints) + .attr("fill", "none") + .attr("stroke", delta >= 0 ? mintBright : amber) + .attr("stroke-width", 6) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + ann.append("text") + .attr("x", annX + 90) + .attr("y", annY + 25) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 13.5) + .attr("font-weight", 900) + .attr("fill", textMain) + .attr("letter-spacing", 0) + .text(delta >= 0 ? "Net increase from start" : "Net decline from start"); + ann.append("text") + .attr("x", annX + 90) + .attr("y", annY + 49) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 21) + .attr("font-weight", 900) + .attr("fill", delta >= 0 ? mintBright : amber) + .attr("letter-spacing", 0) + .text(`${growthPct >= 0 ? "+" : ""}${valueText(growthPct)}%`); + ann.append("text") + .attr("x", annX + 170) + .attr("y", annY + 49) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 12) + .attr("font-weight", 700) + .attr("fill", "#b7d1d4") + .attr("letter-spacing", 0) + .text(`${yearLabel(first)}-${yearLabel(last)}`); + } + + const tickEvery = processedData.length > 24 ? 5 : (processedData.length > 17 ? 4 : 2); + let tickData = processedData.filter((d, i) => i === 0 || i === processedData.length - 1 || i % tickEvery === 0); + if (tickData.length > 2) { + const lastTick = tickData[tickData.length - 1]; + const prevTick = tickData[tickData.length - 2]; + if (lastTick.order - prevTick.order <= 1) tickData.splice(tickData.length - 2, 1); + } + + svg.selectAll(".histogram02-x-tick") + .data(tickData) + .enter() + .append("text") + .attr("class", "histogram02-x-tick") + .attr("x", d => xScale(d.order) + xScale.bandwidth() / 2) + .attr("y", plot.y + plot.h + 27) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", processedData.length > 22 ? 9.5 : 11) + .attr("font-weight", 800) + .attr("fill", "#9fc8c9") + .text(d => yearLabel(d)); + + const bars = svg.append("g").attr("class", "histogram02-bars"); + bars.selectAll(".histogram-bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar histogram-bar histogram02-bar") + .attr("data-source-index", d => d.sourceIndex) + .attr("data-x", d => d.xRaw) + .attr("data-value", d => d.value) + .attr("data-display-value", d => valueText(d.value, true)) + .attr("data-temporal-order", d => d.order) + .attr("x", d => xScale(d.order)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.max(1, plot.y + plot.h - yScale(d.value))) + .attr("rx", Math.min(7, xScale.bandwidth() * 0.34)) + .attr("ry", Math.min(7, xScale.bandwidth() * 0.34)) + .attr("fill", "url(#histogram02-bar)") + .attr("stroke", "#b7f58d") + .attr("stroke-width", 0.55) + .attr("opacity", 0.96); + + const labelCandidates = new Set(); + svg.selectAll(".histogram02-value-label") + .data(processedData.filter(d => labelCandidates.has(d.order))) + .enter() + .append("text") + .attr("class", "histogram02-value-label") + .attr("data-anchor", "bar-top") + .attr("x", d => xScale(d.order) + xScale.bandwidth() / 2) + .attr("y", d => Math.max(plot.y + 13, yScale(d.value) - 7)) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 10.5) + .attr("font-weight", 900) + .attr("fill", "#e8ffd6") + .text(d => valueText(d.value, true)); + + function drawEndpointCallout(datum, side) { + if (!datum) return; + const barX = xScale(datum.order) + xScale.bandwidth() / 2; + const barY = yScale(datum.value); + const w = side === "left" ? 76 : 80; + const h = 58; + const x = side === "left" + ? Math.max(panel.x + 62, barX - w * 0.22) + : Math.min(panel.x + panel.w - w - 10, barX - w + 34); + const y = Math.max(plot.y + 26, barY - h - 76); + const group = svg.append("g") + .attr("class", `histogram02-${side}-endpoint-callout`) + .attr("data-annotation", `${side}-endpoint-value`) + .attr("data-anchor", side === "left" ? "first-chronological-bar" : "last-chronological-bar") + .attr("data-collision-rule", "leader-connected-to-bar-top-clamped-inside-plot-panel"); + const leaderX = side === "left" ? x + 15 : x + w - 15; + group.append("line") + .attr("x1", leaderX) + .attr("y1", y + h) + .attr("x2", barX) + .attr("y2", Math.max(plot.y + 8, barY - 8)) + .attr("stroke", "#dffbf0") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "4 5") + .attr("opacity", 0.86); + group.append("circle") + .attr("cx", barX) + .attr("cy", Math.max(plot.y + 8, barY - 8)) + .attr("r", 5) + .attr("fill", textMain) + .attr("stroke", "#6fd982") + .attr("stroke-width", 1.4); + group.append("rect") + .attr("x", x) + .attr("y", y) + .attr("width", w) + .attr("height", h) + .attr("rx", 10) + .attr("fill", "#0f3a43") + .attr("stroke", "#2a8580") + .attr("stroke-width", 1.4) + .attr("filter", "url(#histogram02-soft-shadow)"); + group.append("text") + .attr("x", x + w / 2) + .attr("y", y + 22) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 15) + .attr("font-weight", 900) + .attr("fill", mintBright) + .text(yearLabel(datum)); + group.append("text") + .attr("x", x + w / 2) + .attr("y", y + 45) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 20) + .attr("font-weight", 900) + .attr("fill", textMain) + .text(valueText(datum.value, true)); + } + + drawEndpointCallout(first, "left"); + drawEndpointCallout(last, "right"); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_03.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_03.js new file mode 100644 index 0000000000000000000000000000000000000000..45ed7678c5910fb5af7f58e7803400c672196550 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_03.js @@ -0,0 +1,1192 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_03", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["temporal"], ["numerical"], ["categorical"]], + "required_fields_range": [[10, 50], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const dataColumns = chartUtils.schema.columns(jsonData); + const xField = chartUtils.schema.channel(jsonData, "x").key || dataColumns[0]?.name || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || dataColumns[1]?.name || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || dataColumns[2]?.name || "group"; + const titleText = jsonData.titles?.main_title || jsonData.metadata?.title || "Grouped Histogram"; + const subtitleText = jsonData.titles?.sub_title || jsonData.metadata?.description || ""; + const yUnitRaw = chartUtils.schema.channel(jsonData, "y").unit; + const yUnit = yUnitRaw && yUnitRaw !== "none" ? yUnitRaw : ""; + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = variables.height || 600; + const scale = Math.min(width, height) / 600; + const fontFamily = typography.title?.font_family || "Arial"; + const labelFamily = typography.label?.font_family || fontFamily; + + const palette = { + navy: colorResolver.text({ fallback: "#0B2C66" }).value, + muted: "#6884A8", + softText: "#8AA0BD", + bg: colorResolver.background?.({ fallback: "#ECF7FF" }).value || "#ECF7FF", + panel: "#FFFFFF", + panelStroke: "#D7E9F8", + grid: "#D9E8F4", + green: "#5EC75C", + blue: colorResolver.field(null, 0, { fallbackKey: "primary", fallback: "#1D79E8" }).value || "#1D79E8", + blueStrong: "#1266D8", + badge: "#EAF5FF" + }; + + function parseTimeValue(value) { + const parsed = chartUtils.format.parseDate(value); + if (parsed instanceof Date && !isNaN(parsed)) return parsed; + const numeric = +value; + if (Number.isFinite(numeric)) return new Date(numeric, 0, 1); + return new Date(String(value)); + } + + function formatYear(date) { + return chartUtils.format.date(date, { output: "%Y" }).text; + } + + function shortNumber(value) { + const abs = Math.abs(value); + if (abs >= 1000000) return `${d3.format(".1f")(value / 1000000)}M`; + if (abs >= 1000) return `${d3.format(abs >= 10000 ? ".0f" : ".1f")(value / 1000)}K`; + return d3.format(",.0f")(value); + } + + function plainNumber(value) { + const abs = Math.abs(value); + if (abs >= 1000000) return `${d3.format(".1f")(value / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".1f")(value / 1000)}K`; + return d3.format(",.0f")(value); + } + + function labelFromField(field) { + if (/^jobcreation$/i.test(field)) return "Manufacturing Jobs Created"; + return String(field) + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\b\w/g, c => c.toUpperCase()); + } + + function wrapText(textSelection, maxWidth, maxLines, lineHeight) { + textSelection.each(function () { + const text = d3.select(this); + const words = String(text.text()).split(/\s+/).filter(Boolean); + const x = +text.attr("x"); + const y = +text.attr("y"); + const anchor = text.attr("text-anchor") || "start"; + text.text(null); + let line = []; + let lineNumber = 0; + let tspan = text.append("tspan") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", anchor); + for (let i = 0; i < words.length; i += 1) { + line.push(words[i]); + tspan.text(line.join(" ")); + if (tspan.node().getComputedTextLength() > maxWidth && line.length > 1) { + line.pop(); + tspan.text(line.join(" ")); + line = [words[i]]; + lineNumber += 1; + if (lineNumber >= maxLines) { + const current = tspan.text(); + tspan.text(`${current.replace(/[,.]$/, "")}...`); + return; + } + tspan = text.append("tspan") + .attr("x", x) + .attr("y", y + lineNumber * lineHeight) + .attr("text-anchor", anchor) + .text(words[i]); + } + } + }); + } + + function roundedTopRectPath(x, y, w, h, r) { + const radius = Math.max(0, Math.min(r, w / 2, h)); + const bottom = y + h; + return [ + `M${x},${bottom}`, + `L${x},${y + radius}`, + `Q${x},${y} ${x + radius},${y}`, + `L${x + w - radius},${y}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `L${x + w},${bottom}`, + "Z" + ].join(" "); + } + + function measureText(svg, value, fontSize, weight) { + const probe = svg.append("text") + .attr("x", -1000) + .attr("y", -1000) + .style("font-family", labelFamily) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight || 500) + .text(value); + const width = probe.node().getComputedTextLength(); + probe.remove(); + return width; + } + + const processedData = chartData.map((d, i) => ({ + time: parseTimeValue(d[xField]), + rawX: d[xField], + value: +d[yField], + group: String(d[groupField]), + originalRow: d, + originalIndex: i + })).filter(d => Number.isFinite(d.value) && d.time instanceof Date && !isNaN(d.time)); + + processedData.sort((a, b) => d3.ascending(a.time, b.time) || d3.ascending(a.group, b.group)); + + const uniqueTimes = Array.from(new Map(processedData.map(d => [d.time.getTime(), d.time])).values()) + .sort((a, b) => a - b); + const groups = Array.from(new Set(processedData.map(d => d.group))).slice(0, 2); + const groupTotals = groups.map(group => ({ + group, + total: d3.sum(processedData.filter(d => d.group === group), d => d.value), + first: processedData.find(d => d.group === group), + last: [...processedData].reverse().find(d => d.group === group) + })); + const primaryGroup = groupTotals.slice().sort((a, b) => d3.descending(a.total, b.total))[0]?.group || groups[1] || groups[0]; + const groupColors = {}; + groups.forEach((group, i) => { + groupColors[group] = i === 0 ? palette.green : palette.blue; + }); + if (primaryGroup && groups.length === 2) { + groupColors[primaryGroup] = palette.blue; + groups.filter(g => g !== primaryGroup).forEach(g => { groupColors[g] = palette.green; }); + } + + const timeIndex = new Map(uniqueTimes.map((time, index) => [time.getTime(), index])); + const byTime = uniqueTimes.map(time => { + const rows = processedData.filter(d => d.time.getTime() === time.getTime() && groups.includes(d.group)); + const byGroup = new Map(rows.map(d => [d.group, d])); + return { time, rows, byGroup }; + }); + processedData.forEach(d => { d.order = timeIndex.get(d.time.getTime()); }); + + const maxValue = d3.max(processedData, d => d.value) || 1; + const gapRows = byTime.map(t => { + if (groups.length < 2) return null; + const a = t.byGroup.get(groups[0]); + const b = t.byGroup.get(groups[1]); + if (!a || !b) return null; + return { time: t.time, order: timeIndex.get(t.time.getTime()), gap: Math.abs(a.value - b.value), high: a.value >= b.value ? a : b, low: a.value >= b.value ? b : a }; + }).filter(Boolean); + const annotationDatum = gapRows.slice().sort((a, b) => d3.descending(a.order, b.order))[0]; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "histogram_03"); + + const defs = svg.append("defs"); + svg.append("style").text(` + image.image, .image[data-type="image"] { display: none !important; } + .histogram03-full-canvas { display: none !important; } + `); + const shadow = defs.append("filter") + .attr("id", "histogram03-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "140%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 4 * scale) + .attr("stdDeviation", 5 * scale) + .attr("flood-color", "#8DB7DA") + .attr("flood-opacity", 0.22); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "#FFFFFF"); + + const outer = { + x: 22 * scale, + y: 16 * scale, + w: width - 44 * scale, + h: height - 34 * scale + }; + svg.append("rect") + .attr("class", "histogram03-outer-panel") + .attr("data-chart-element", "outer-panel") + .attr("x", 10 * scale) + .attr("y", 10 * scale) + .attr("width", width - 20 * scale) + .attr("height", height - 20 * scale) + .attr("rx", 14 * scale) + .attr("fill", "#FFFFFF") + .attr("stroke", "transparent") + .attr("stroke-width", 0); + + const header = svg.append("g").attr("class", "histogram03-header").attr("display", "none"); + header.append("rect") + .attr("x", width / 2 - 52 * scale) + .attr("y", outer.y + 12 * scale) + .attr("width", 104 * scale) + .attr("height", 13 * scale) + .attr("rx", 6.5 * scale) + .attr("fill", "#DCEEFF"); + header.append("text") + .attr("x", width / 2) + .attr("y", outer.y + 22 * scale) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${6.5 * scale}px`) + .style("font-weight", 800) + .style("letter-spacing", "0") + .style("fill", palette.blueStrong) + .text("PRIVATE SECTOR JOB CREATION"); + + const title = header.append("text") + .attr("class", "histogram03-title") + .attr("x", width / 2) + .attr("y", outer.y + 48 * scale) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", `${21 * scale}px`) + .style("font-weight", 800) + .style("fill", palette.navy) + .text(titleText); + wrapText(title, outer.w * 0.62, 2, 22 * scale); + + const subtitle = header.append("text") + .attr("class", "histogram03-subtitle") + .attr("x", width / 2) + .attr("y", outer.y + 83 * scale) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${7.8 * scale}px`) + .style("font-weight", 500) + .style("fill", palette.muted) + .text(subtitleText); + wrapText(subtitle, outer.w * 0.54, 2, 10 * scale); + + const summaryY = 42 * scale; + const trendCard = { + x: 28 * scale, + y: summaryY + 8 * scale, + w: 300 * scale, + h: 174 * scale + }; + const summaryGroup = svg.append("g") + .attr("class", "histogram03-summary-row") + .attr("data-reference-relationship", "large-left-trend-card-and-large-right-growth-slot"); + const trend = summaryGroup.append("g") + .attr("class", "histogram03-trend-highlight-card") + .attr("data-chart-element", "trend-highlight-card") + .attr("data-anchor", "upper-left-reference-card") + .attr("data-collision-policy", "independent-card-clear-of-header-growth-slot-and-chart-panel"); + trend.append("rect") + .attr("x", trendCard.x) + .attr("y", trendCard.y) + .attr("width", trendCard.w) + .attr("height", trendCard.h) + .attr("rx", 12 * scale) + .attr("fill", "#FFFFFF") + .attr("stroke", "#B9D8F4") + .attr("stroke-width", 1.1 * scale) + .attr("filter", "url(#histogram03-soft-shadow)"); + const trendIconSlot = trend.append("g") + .attr("class", "reserved-asset-slot histogram03-trend-icon-slot") + .attr("data-asset-slot", "histogram-trend-highlight-icon") + .attr("data-asset-policy", "neutral_placeholder") + .attr("data-anchor", "trend-highlight-card-heading-left") + .attr("data-bbox", `${(trendCard.x + 22 * scale) / scale},${(trendCard.y + 17 * scale) / scale},24,24`) + .attr("data-collision-policy", "contained-in-trend-highlight-heading-clear-of-label") + .attr("transform", `translate(${trendCard.x + 22 * scale}, ${trendCard.y + 17 * scale})`); + trendIconSlot.append("circle") + .attr("cx", 12 * scale) + .attr("cy", 12 * scale) + .attr("r", 12 * scale) + .attr("fill", "#F4FAFF") + .attr("stroke", palette.blueStrong) + .attr("stroke-width", 1.6 * scale); + trendIconSlot.append("circle") + .attr("cx", 12 * scale) + .attr("cy", 12 * scale) + .attr("r", 4 * scale) + .attr("fill", palette.blueStrong) + .attr("opacity", 0.62); + trend.append("text") + .attr("x", trendCard.x + 60 * scale) + .attr("y", trendCard.y + 34 * scale) + .style("font-family", labelFamily) + .style("font-size", `${12 * scale}px`) + .style("font-weight", 900) + .style("fill", palette.blueStrong) + .text("TREND HIGHLIGHT"); + trend.append("line") + .attr("x1", trendCard.x + trendCard.w / 2) + .attr("x2", trendCard.x + trendCard.w / 2) + .attr("y1", trendCard.y + 62 * scale) + .attr("y2", trendCard.y + trendCard.h - 20 * scale) + .attr("stroke", "#C9DAEA") + .attr("stroke-width", 1 * scale); + const trendEntries = groupTotals.slice(0, 2).sort((a, b) => { + const aBlue = groupColors[a.group] === palette.blue ? 1 : 0; + const bBlue = groupColors[b.group] === palette.blue ? 1 : 0; + return d3.ascending(aBlue, bBlue); + }); + trendEntries.forEach((entry, i) => { + const blockX = trendCard.x + (i === 0 ? 22 * scale : trendCard.w / 2 + 22 * scale); + const blockTop = trendCard.y + 78 * scale; + const blockW = trendCard.w / 2 - 38 * scale; + const latest = entry.last?.value || entry.total || 0; + const first = entry.first?.value || 0; + const delta = latest - first; + const deltaLabel = delta >= 0 ? `+${shortNumber(delta)}` : `-${shortNumber(Math.abs(delta))}`; + const tone = delta >= 0 ? "growth" : "change"; + const slot = trend.append("g") + .attr("class", "histogram03-trend-block") + .attr("data-chart-element", "trend-highlight-block") + .attr("data-group", entry.group) + .attr("data-latest-value", latest) + .attr("data-first-value", first) + .attr("data-delta", delta); + slot.append("circle") + .attr("cx", blockX + 25 * scale) + .attr("cy", blockTop + 15 * scale) + .attr("r", 28 * scale) + .attr("fill", d3.color(groupColors[entry.group]).copy({ opacity: 0.18 })) + .attr("stroke", d3.color(groupColors[entry.group]).copy({ opacity: 0.38 })) + .attr("stroke-width", 1.1 * scale); + slot.append("rect") + .attr("x", blockX + 14 * scale) + .attr("y", blockTop + 7 * scale) + .attr("width", 22 * scale) + .attr("height", 18 * scale) + .attr("rx", 3 * scale) + .attr("fill", groupColors[entry.group]) + .attr("opacity", 0.86); + slot.append("text") + .attr("x", blockX + 62 * scale) + .attr("y", blockTop + 5 * scale) + .style("font-family", labelFamily) + .style("font-size", `${11 * scale}px`) + .style("font-weight", 900) + .style("fill", groupColors[entry.group]) + .text(entry.group.length > 14 ? `${entry.group.slice(0, 12)}...` : entry.group); + slot.append("text") + .attr("x", blockX + 62 * scale) + .attr("y", blockTop + 22 * scale) + .style("font-family", labelFamily) + .style("font-size", `${8.5 * scale}px`) + .style("font-weight", 800) + .style("fill", palette.navy) + .text(entry.last ? `${plainNumber(latest)} in ${formatYear(entry.last.time)}` : plainNumber(latest)); + const absDelta = Math.abs(delta); + const ratio = first > 0 && latest > first * 1.8 ? `${d3.format(".1f")(latest / first)}x` : ""; + const note = delta >= 0 + ? (ratio ? `Strong acceleration, ${ratio} from ${plainNumber(first)} to ${plainNumber(latest)}.` : `Steady growth of ${shortNumber(absDelta)} over the years.`) + : `Decline of ${shortNumber(absDelta)} from ${entry.first ? formatYear(entry.first.time) : "start"} to ${entry.last ? formatYear(entry.last.time) : "latest"}.`; + const noteText = slot.append("text") + .attr("x", blockX + 2 * scale) + .attr("y", blockTop + 66 * scale) + .style("font-family", labelFamily) + .style("font-size", `${8.4 * scale}px`) + .style("font-weight", 600) + .style("fill", "#172033") + .text(note); + wrapText(noteText, blockW, 3, 10 * scale); + }); + + const assetX = 344 * scale; + const assetY = summaryY + 2 * scale; + const assetW = 228 * scale; + const assetH = 180 * scale; + const assetSlot = summaryGroup.append("g") + .attr("class", "reserved-asset-slot histogram03-header-growth-slot") + .attr("data-asset-slot", "histogram-header-growth") + .attr("data-asset-policy", "neutral_placeholder") + .attr("data-anchor", "upper-right-reference-growth-illustration") + .attr("data-bbox", `${assetX / scale},${assetY / scale},${assetW / scale},${assetH / scale}`) + .attr("data-bbox-policy", "local chart coordinates scaled by viewBox") + .attr("data-mask-policy", "downstream image2 may replace only inside this rounded illustration footprint") + .attr("data-collision-policy", "stay-right-of-trend-highlight-card-above-chart-panel") + .attr("transform", `translate(${assetX}, ${assetY})`); + assetSlot.append("rect") + .attr("width", assetW) + .attr("height", assetH) + .attr("rx", 12 * scale) + .attr("fill", "#F7FCFF") + .attr("stroke", "#CFE6F7") + .attr("stroke-dasharray", `${3 * scale} ${3 * scale}`); + const miniBars = [0.24, 0.34, 0.45, 0.58, 0.72, 0.88]; + miniBars.forEach((v, i) => { + assetSlot.append("rect") + .attr("x", (22 + i * 26) * scale) + .attr("y", (148 - v * 104) * scale) + .attr("width", 16 * scale) + .attr("height", v * 104 * scale) + .attr("rx", 2 * scale) + .attr("fill", i < 3 ? "#68C66B" : "#1D79E8") + .attr("opacity", 0.72); + }); + assetSlot.append("path") + .attr("d", `M${20 * scale},${134 * scale} C${72 * scale},${116 * scale} ${136 * scale},${82 * scale} ${202 * scale},${30 * scale}`) + .attr("fill", "none") + .attr("stroke", "#7AADE9") + .attr("stroke-width", 3 * scale) + .attr("stroke-linecap", "round"); + assetSlot.append("text") + .attr("x", assetW / 2) + .attr("y", assetH - 13 * scale) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${7 * scale}px`) + .style("font-weight", 700) + .style("fill", palette.softText) + .text("growth illustration asset slot"); + + const panel = { + x: 36 * scale, + y: 230 * scale, + w: width - 72 * scale, + h: height - 252 * scale + }; + svg.append("rect") + .attr("class", "histogram03-chart-panel") + .attr("data-chart-element", "chart-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 13 * scale) + .attr("fill", palette.panel) + .attr("stroke", "#D6E7F5") + .attr("filter", "url(#histogram03-soft-shadow)"); + + svg.append("text") + .attr("x", panel.x + 18 * scale) + .attr("y", panel.y + 28 * scale) + .style("font-family", labelFamily) + .style("font-size", `${14 * scale}px`) + .style("font-weight", 800) + .style("fill", palette.navy) + .text(labelFromField(yField)); + svg.append("text") + .attr("x", panel.x + 18 * scale) + .attr("y", panel.y + 45 * scale) + .style("font-family", labelFamily) + .style("font-size", `${8 * scale}px`) + .style("font-weight", 600) + .style("fill", palette.muted) + .text(yUnit ? `in ${yUnit}` : "by year and group"); + + const legend = svg.append("g") + .attr("class", "histogram03-legend") + .attr("data-chart-element", "legend"); + let legendX = panel.x + panel.w - 18 * scale; + const legendY = panel.y + 31 * scale; + [...groups].reverse().forEach(group => { + const labelWidth = measureText(svg, group, 7.5 * scale, 700); + legendX -= labelWidth + 21 * scale; + legend.append("rect") + .attr("x", legendX) + .attr("y", legendY - 8 * scale) + .attr("width", 7 * scale) + .attr("height", 7 * scale) + .attr("rx", 1.5 * scale) + .attr("fill", groupColors[group]); + legend.append("text") + .attr("x", legendX + 10 * scale) + .attr("y", legendY - 2 * scale) + .style("font-family", labelFamily) + .style("font-size", `${8.5 * scale}px`) + .style("font-weight", 700) + .style("fill", palette.muted) + .text(group); + legendX -= 8 * scale; + }); + + const margin = { + top: 78 * scale, + right: 28 * scale, + bottom: 54 * scale, + left: 50 * scale + }; + const plot = { + x: panel.x + margin.left, + y: panel.y + margin.top, + w: panel.w - margin.left - margin.right, + h: panel.h - margin.top - margin.bottom + }; + + const xScale = d3.scaleBand() + .domain(uniqueTimes.map(time => time.getTime())) + .range([0, plot.w]) + .paddingInner(0.22) + .paddingOuter(0.06); + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.16); + const yScale = d3.scaleLinear() + .domain([0, maxValue * 1.12]) + .range([plot.h, 0]) + .nice(5); + + const chartGroup = svg.append("g") + .attr("class", "histogram03-plot") + .attr("data-chart-element", "plot-area") + .attr("transform", `translate(${plot.x},${plot.y})`); + + chartGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", plot.w) + .attr("height", plot.h) + .attr("fill", "#FFFFFF"); + + const yTicks = yScale.ticks(5); + chartGroup.append("g") + .attr("class", "histogram03-grid") + .selectAll("line") + .data(yTicks) + .enter() + .append("line") + .attr("x1", 0) + .attr("x2", plot.w) + .attr("y1", d => yScale(d)) + .attr("y2", d => yScale(d)) + .attr("stroke", palette.grid) + .attr("stroke-width", 1 * scale); + + chartGroup.append("g") + .attr("class", "histogram03-y-labels") + .selectAll("text") + .data(yTicks) + .enter() + .append("text") + .attr("x", -9 * scale) + .attr("y", d => yScale(d) + 3 * scale) + .attr("text-anchor", "end") + .style("font-family", labelFamily) + .style("font-size", `${8 * scale}px`) + .style("font-weight", 700) + .style("fill", palette.muted) + .text(d => d === 0 ? "0" : shortNumber(d)); + + chartGroup.append("line") + .attr("x1", 0) + .attr("x2", plot.w) + .attr("y1", plot.h) + .attr("y2", plot.h) + .attr("stroke", "#BFD7EB") + .attr("stroke-width", 1 * scale); + + const bars = chartGroup.append("g").attr("class", "histogram03-bars"); + const rows = processedData.filter(d => groups.includes(d.group)); + bars.selectAll(".histogram03-bar") + .data(rows) + .enter() + .append("path") + .attr("class", "histogram03-bar") + .attr("data-series", d => d.group) + .attr("data-x-value", d => d.rawX) + .attr("data-y-value", d => d.value) + .attr("d", d => { + const x = (xScale(d.time.getTime()) || 0) + groupScale(d.group); + const y = yScale(d.value); + const h = plot.h - y; + return roundedTopRectPath(x, y, groupScale.bandwidth(), h, 3.5 * scale); + }) + .attr("fill", d => groupColors[d.group]) + .attr("opacity", 0.96); + + const labelEvery = uniqueTimes.length > 12 ? 2 : 1; + chartGroup.append("g") + .attr("class", "histogram03-value-labels") + .selectAll("text") + .data(rows.filter(d => d.order % labelEvery === 0 || d.order === uniqueTimes.length - 1)) + .enter() + .append("text") + .attr("x", d => (xScale(d.time.getTime()) || 0) + groupScale(d.group) + groupScale.bandwidth() / 2) + .attr("y", d => Math.max(7 * scale, yScale(d.value) - 5 * scale)) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${7.2 * scale}px`) + .style("font-weight", 800) + .style("fill", d => d3.color(groupColors[d.group]).darker(0.45)) + .text(d => shortNumber(d.value)); + + chartGroup.append("g") + .attr("class", "histogram03-x-labels") + .selectAll("text") + .data(uniqueTimes) + .enter() + .append("text") + .attr("x", d => (xScale(d.getTime()) || 0) + xScale.bandwidth() / 2) + .attr("y", plot.h + 19 * scale) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${8 * scale}px`) + .style("font-weight", 700) + .style("fill", palette.muted) + .text(d => formatYear(d)); + + if (annotationDatum && plot.w > 250 * scale) { + const targetX = (xScale(annotationDatum.time.getTime()) || 0) + + groupScale(annotationDatum.high.group) + + groupScale.bandwidth() / 2; + const targetY = yScale(annotationDatum.high.value); + const baseCardW = Math.min(230 * scale, plot.w * 0.52); + const baseCardH = 74 * scale; + const compactCardW = Math.min(210 * scale, plot.w * 0.48); + const compactCardH = 70 * scale; + const referenceX = Math.max(16 * scale, Math.min(plot.w - baseCardW - 18 * scale, plot.w * 0.08)); + const referenceY = Math.max(18 * scale, Math.min(plot.h - baseCardH - 18 * scale, plot.h * 0.12)); + const minX = Math.max(-36 * scale, -margin.left + 12 * scale); + const candidateCards = [ + { x: referenceX, y: referenceY, w: baseCardW, h: baseCardH, name: "reference-left-upper" }, + { x: minX, y: referenceY, w: baseCardW, h: baseCardH, name: "left-gutter-upper" }, + { x: Math.max(minX, plot.w * 0.03), y: 18 * scale, w: compactCardW, h: compactCardH, name: "compact-left-top" }, + { x: Math.max(minX, plot.w * 0.03), y: Math.max(18 * scale, plot.h * 0.26), w: compactCardW, h: compactCardH, name: "compact-left-mid" }, + { x: Math.max(16 * scale, Math.min(plot.w - compactCardW - 18 * scale, plot.w * 0.34)), y: 18 * scale, w: compactCardW, h: compactCardH, name: "compact-center-top" }, + { x: Math.max(16 * scale, plot.w - compactCardW - 18 * scale), y: 18 * scale, w: compactCardW, h: compactCardH, name: "compact-right-top" }, + { x: Math.max(16 * scale, plot.w - compactCardW - 18 * scale), y: Math.max(18 * scale, plot.h * 0.26), w: compactCardW, h: compactCardH, name: "compact-right-mid" } + ]; + const labelRows = rows.filter(d => d.order % labelEvery === 0 || d.order === uniqueTimes.length - 1); + const markRects = rows.map(d => { + const x = (xScale(d.time.getTime()) || 0) + groupScale(d.group); + const y = yScale(d.value); + return [x - 2 * scale, y - 2 * scale, x + groupScale.bandwidth() + 2 * scale, plot.h]; + }); + const labelRects = labelRows.map(d => { + const cx = (xScale(d.time.getTime()) || 0) + groupScale(d.group) + groupScale.bandwidth() / 2; + const y = Math.max(7 * scale, yScale(d.value) - 5 * scale); + return [cx - 19 * scale, y - 10 * scale, cx + 19 * scale, y + 4 * scale]; + }); + function overlapArea(a, b) { + const x0 = Math.max(a[0], b[0]); + const y0 = Math.max(a[1], b[1]); + const x1 = Math.min(a[2], b[2]); + const y1 = Math.min(a[3], b[3]); + return Math.max(0, x1 - x0) * Math.max(0, y1 - y0); + } + function cardMetrics(card) { + const box = [card.x, card.y, card.x + card.w, card.y + card.h]; + const markArea = d3.sum(markRects, r => overlapArea(box, r)); + const labelArea = d3.sum(labelRects, r => overlapArea(box, r)); + const referenceCost = Math.abs(card.x - referenceX) * 0.45 + Math.abs(card.y - referenceY) * 0.2; + const outsideCost = card.x < 0 ? Math.abs(card.x) * 1.2 : 0; + return { markArea, labelArea, referenceCost, outsideCost }; + } + function cardScore(card) { + const metrics = cardMetrics(card); + const markCost = metrics.markArea > 0 ? 100000 + metrics.markArea * 50 : 0; + const labelCost = metrics.labelArea > 0 ? 200000 + metrics.labelArea * 120 : 0; + return markCost + labelCost + metrics.referenceCost + metrics.outsideCost; + } + const selectedCard = candidateCards + .map(card => ({ ...card, ...cardMetrics(card), score: cardScore(card) })) + .sort((a, b) => d3.ascending(a.score, b.score))[0]; + const selectedCardArea = selectedCard.w * selectedCard.h; + const omitAnnotation = selectedCard.labelArea > 0 || selectedCard.markArea > selectedCardArea * 0.015; + const cardX = selectedCard.x; + const cardY = selectedCard.y; + const cardW = selectedCard.w; + const cardH = selectedCard.h; + const annotation = chartGroup.append("g") + .attr("class", "histogram03-annotation") + .attr("data-chart-element", "annotation-card") + .attr("data-anchor-year", formatYear(annotationDatum.time)) + .attr("data-reference-relationship", "large-left-plot-annotation-card") + .attr("data-placement-policy", "reference-left when open; otherwise choose a zero-overlap fallback or omit optional annotation content") + .attr("data-placement-choice", omitAnnotation ? "omitted-dense-collision" : selectedCard.name) + .attr("data-mark-overlap-area", selectedCard.markArea.toFixed(2)) + .attr("data-label-overlap-area", selectedCard.labelArea.toFixed(2)); + if (!omitAnnotation) { + annotation.append("rect") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardW) + .attr("height", cardH) + .attr("rx", 9 * scale) + .attr("fill", "#FFFFFF") + .attr("stroke", "#CAE2F6") + .attr("filter", "url(#histogram03-soft-shadow)"); + const calloutSlot = annotation.append("g") + .attr("class", "reserved-asset-slot histogram03-callout-icon-slot") + .attr("data-asset-slot", "histogram-callout-icon") + .attr("data-asset-policy", "neutral_placeholder") + .attr("data-anchor", "annotation-card-left") + .attr("data-collision-policy", "contained-in-annotation-card") + .attr("data-bbox", `${(cardX + 14 * scale) / scale},${(cardY + 16 * scale) / scale},44,44`) + .attr("transform", `translate(${cardX + 14 * scale}, ${cardY + 16 * scale})`); + calloutSlot.append("circle") + .attr("cx", 22 * scale) + .attr("cy", 22 * scale) + .attr("r", 22 * scale) + .attr("fill", "#EAF3FF") + .attr("stroke", "#BBD8F5") + .attr("stroke-width", 1.2 * scale); + calloutSlot.append("circle") + .attr("cx", 22 * scale) + .attr("cy", 22 * scale) + .attr("r", 6 * scale) + .attr("fill", palette.blueStrong) + .attr("opacity", 0.75); + const highGroup = annotationDatum.high.group; + const lowGroup = annotationDatum.low.group; + const highEntry = groupTotals.find(g => g.group === highGroup); + const firstValue = highEntry?.first?.value || 0; + const lastValue = highEntry?.last?.value || annotationDatum.high.value; + const highDelta = lastValue - firstValue; + const ratioText = firstValue > 0 && lastValue > firstValue + ? `${d3.format(".1f")(lastValue / firstValue)}x` + : shortNumber(annotationDatum.gap); + const lead = `${highGroup} leads`; + const line1 = highDelta >= 0 + ? `${highGroup} grew ${ratioText} from ${shortNumber(firstValue)} to ${shortNumber(lastValue)}` + : `${highGroup} declined ${shortNumber(Math.abs(highDelta))} from ${shortNumber(firstValue)} to ${shortNumber(lastValue)}`; + const line2 = `and is ${shortNumber(annotationDatum.gap)} over ${lowGroup} in ${formatYear(annotationDatum.time)}.`; + annotation.append("text") + .attr("x", cardX + 72 * scale) + .attr("y", cardY + 22 * scale) + .style("font-family", labelFamily) + .style("font-size", `${10 * scale}px`) + .style("font-weight", 800) + .style("fill", palette.navy) + .text(lead.length > 24 ? `${lead.slice(0, 21)}...` : lead); + const annotationBody = annotation.append("text") + .attr("x", cardX + 72 * scale) + .attr("y", cardY + 40 * scale) + .style("font-family", labelFamily) + .style("font-size", `${8.6 * scale}px`) + .style("font-weight", 600) + .style("fill", palette.muted) + .text(`${line1} ${line2}`); + wrapText(annotationBody, cardW - 88 * scale, 3, 11 * scale); + } + } + + svg.append("text") + .attr("class", "histogram03-date-range") + .attr("x", width / 2) + .attr("y", panel.y + panel.h - 12 * scale) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", `${7.5 * scale}px`) + .style("font-weight", 700) + .style("fill", "#9AAFC7") + .text(`${formatYear(uniqueTimes[0])} - ${formatYear(uniqueTimes[uniqueTimes.length - 1])}`); + + const fullW = 701; + const fullH = 934; + const full = svg.append("g") + .attr("class", "histogram03-full-canvas") + .attr("data-chart-element", "full-infographic-overlay") + .attr("transform", "translate(-50,-283)"); + full.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", fullW) + .attr("height", fullH) + .attr("fill", "#FFFFFF"); + full.append("rect") + .attr("x", 34) + .attr("y", 26) + .attr("width", fullW - 68) + .attr("height", fullH - 54) + .attr("rx", 18) + .attr("fill", "#EEF8FF") + .attr("stroke", "#D5E9F8") + .attr("stroke-width", 1.4); + + full.append("rect") + .attr("x", fullW / 2 - 62) + .attr("y", 42) + .attr("width", 124) + .attr("height", 16) + .attr("rx", 8) + .attr("fill", "#DCEEFF"); + full.append("text") + .attr("x", fullW / 2) + .attr("y", 54) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 800) + .style("fill", palette.blueStrong) + .text("PRIVATE SECTOR JOB CREATION"); + const fullTitle = full.append("text") + .attr("x", fullW / 2) + .attr("y", 96) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", "30px") + .style("font-weight", 900) + .style("fill", "#0B2C66") + .text(titleText); + wrapText(fullTitle, 475, 2, 32); + const fullSubtitle = full.append("text") + .attr("x", fullW / 2) + .attr("y", 146) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "10px") + .style("font-weight", 600) + .style("fill", "#6884A8") + .text(subtitleText); + wrapText(fullSubtitle, 430, 2, 13); + + const topY = 186; + full.append("text") + .attr("x", 72) + .attr("y", topY - 18) + .style("font-family", labelFamily) + .style("font-size", "9px") + .style("font-weight", 900) + .style("fill", palette.blueStrong) + .text("TREND HIGHLIGHT"); + groupTotals.slice(0, 2).forEach((entry, i) => { + const x = 70 + i * 150; + const card = full.append("g") + .attr("class", "histogram03-full-summary-card") + .attr("data-chart-element", "group-summary") + .attr("data-group", entry.group); + card.append("rect") + .attr("x", x) + .attr("y", topY) + .attr("width", 132) + .attr("height", 74) + .attr("rx", 12) + .attr("fill", "#FFFFFF") + .attr("stroke", "#CFE6F7") + .attr("filter", "url(#histogram03-soft-shadow)"); + card.append("rect") + .attr("x", x + 12) + .attr("y", topY + 17) + .attr("width", 28) + .attr("height", 28) + .attr("rx", 8) + .attr("fill", d3.color(groupColors[entry.group]).copy({ opacity: 0.16 })); + card.append("rect") + .attr("x", x + 22) + .attr("y", topY + 26) + .attr("width", 9) + .attr("height", 11) + .attr("rx", 2) + .attr("fill", groupColors[entry.group]); + card.append("text") + .attr("x", x + 50) + .attr("y", topY + 28) + .style("font-family", labelFamily) + .style("font-size", "10px") + .style("font-weight", 900) + .style("fill", "#0B2C66") + .text(entry.group); + card.append("text") + .attr("x", x + 50) + .attr("y", topY + 46) + .style("font-family", labelFamily) + .style("font-size", "15px") + .style("font-weight", 900) + .style("fill", groupColors[entry.group]) + .text(plainNumber(entry.last?.value || entry.total)); + card.append("text") + .attr("x", x + 50) + .attr("y", topY + 61) + .style("font-family", labelFamily) + .style("font-size", "7px") + .style("font-weight", 700) + .style("fill", "#6884A8") + .text(entry.last ? `in ${formatYear(entry.last.time)}` : "latest value"); + }); + + const fullAsset = full.append("g") + .attr("class", "reserved-asset-slot histogram03-header-growth-slot") + .attr("data-asset-slot", "histogram-header-growth") + .attr("data-asset-policy", "neutral_placeholder") + .attr("data-anchor", "header-summary-right") + .attr("data-collision-policy", "avoid-title-subtitle-summary-cards-chart-panel") + .attr("transform", "translate(385,168)"); + fullAsset.append("rect") + .attr("width", 214) + .attr("height", 94) + .attr("rx", 12) + .attr("fill", "#F7FCFF") + .attr("stroke", "#CFE6F7") + .attr("stroke-dasharray", "4 4"); + [0.26, 0.38, 0.52, 0.68, 0.86].forEach((v, i) => { + fullAsset.append("rect") + .attr("x", 30 + i * 28) + .attr("y", 72 - v * 52) + .attr("width", 14) + .attr("height", v * 52) + .attr("rx", 3) + .attr("fill", i < 2 ? "#A6DB86" : "#68A7EC"); + }); + fullAsset.append("path") + .attr("d", "M28,72 C74,58 104,50 176,18") + .attr("fill", "none") + .attr("stroke", "#6EA7E8") + .attr("stroke-width", 3) + .attr("stroke-linecap", "round"); + fullAsset.append("text") + .attr("x", 107) + .attr("y", 88) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 800) + .style("fill", "#8AA0BD") + .text("semantic asset slot"); + + const fullPanel = { x: 68, y: 316, w: 565, h: 510 }; + full.append("rect") + .attr("class", "histogram03-full-chart-panel") + .attr("data-chart-element", "chart-panel") + .attr("x", fullPanel.x) + .attr("y", fullPanel.y) + .attr("width", fullPanel.w) + .attr("height", fullPanel.h) + .attr("rx", 16) + .attr("fill", "#FFFFFF") + .attr("stroke", "#D6E7F5") + .attr("filter", "url(#histogram03-soft-shadow)"); + full.append("text") + .attr("x", fullPanel.x + 22) + .attr("y", fullPanel.y + 36) + .style("font-family", labelFamily) + .style("font-size", "15px") + .style("font-weight", 900) + .style("fill", "#0B2C66") + .text(labelFromField(yField)); + full.append("text") + .attr("x", fullPanel.x + 22) + .attr("y", fullPanel.y + 53) + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 700) + .style("fill", "#6884A8") + .text(yUnit ? `in ${yUnit}` : "by year and group"); + + const fullLegend = full.append("g").attr("class", "histogram03-full-legend").attr("data-chart-element", "legend"); + let fullLegendX = fullPanel.x + fullPanel.w - 25; + [...groups].reverse().forEach(group => { + const labelWidth = measureText(svg, group, 9, 800); + fullLegendX -= labelWidth + 25; + fullLegend.append("rect") + .attr("x", fullLegendX) + .attr("y", fullPanel.y + 29) + .attr("width", 9) + .attr("height", 9) + .attr("rx", 2) + .attr("fill", groupColors[group]); + fullLegend.append("text") + .attr("x", fullLegendX + 13) + .attr("y", fullPanel.y + 37) + .style("font-family", labelFamily) + .style("font-size", "9px") + .style("font-weight", 800) + .style("fill", "#6884A8") + .text(group); + fullLegendX -= 10; + }); + + const fullPlot = { x: fullPanel.x + 58, y: fullPanel.y + 88, w: fullPanel.w - 90, h: fullPanel.h - 154 }; + const fx = d3.scaleBand() + .domain(uniqueTimes.map(time => time.getTime())) + .range([0, fullPlot.w]) + .paddingInner(0.22) + .paddingOuter(0.06); + const fg = d3.scaleBand() + .domain(groups) + .range([0, fx.bandwidth()]) + .padding(0.14); + const fy = d3.scaleLinear() + .domain([0, maxValue * 1.12]) + .range([fullPlot.h, 0]) + .nice(5); + const fp = full.append("g") + .attr("class", "histogram03-full-plot") + .attr("data-chart-element", "plot-area") + .attr("transform", `translate(${fullPlot.x},${fullPlot.y})`); + const fyTicks = fy.ticks(6); + fp.selectAll(".histogram03-full-gridline") + .data(fyTicks) + .enter() + .append("line") + .attr("x1", 0) + .attr("x2", fullPlot.w) + .attr("y1", d => fy(d)) + .attr("y2", d => fy(d)) + .attr("stroke", "#D9E8F4") + .attr("stroke-width", 1.2); + fp.selectAll(".histogram03-full-y-label") + .data(fyTicks) + .enter() + .append("text") + .attr("x", -12) + .attr("y", d => fy(d) + 4) + .attr("text-anchor", "end") + .style("font-family", labelFamily) + .style("font-size", "9px") + .style("font-weight", 800) + .style("fill", "#6884A8") + .text(d => d === 0 ? "0" : shortNumber(d)); + fp.append("line") + .attr("x1", 0) + .attr("x2", fullPlot.w) + .attr("y1", fullPlot.h) + .attr("y2", fullPlot.h) + .attr("stroke", "#BFD7EB") + .attr("stroke-width", 1.2); + fp.selectAll(".histogram03-full-bar") + .data(rows) + .enter() + .append("path") + .attr("class", "histogram03-full-bar") + .attr("data-series", d => d.group) + .attr("data-x-value", d => d.rawX) + .attr("data-y-value", d => d.value) + .attr("d", d => { + const x = (fx(d.time.getTime()) || 0) + fg(d.group); + const y = fy(d.value); + return roundedTopRectPath(x, y, fg.bandwidth(), fullPlot.h - y, 4); + }) + .attr("fill", d => groupColors[d.group]); + fp.selectAll(".histogram03-full-value-label") + .data(rows) + .enter() + .append("text") + .attr("x", d => (fx(d.time.getTime()) || 0) + fg(d.group) + fg.bandwidth() / 2) + .attr("y", d => Math.max(8, fy(d.value) - 6)) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 900) + .style("fill", d => d3.color(groupColors[d.group]).darker(0.45)) + .text(d => shortNumber(d.value)); + fp.selectAll(".histogram03-full-x-label") + .data(uniqueTimes) + .enter() + .append("text") + .attr("x", d => (fx(d.getTime()) || 0) + fx.bandwidth() / 2) + .attr("y", fullPlot.h + 27) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "9px") + .style("font-weight", 800) + .style("fill", "#6884A8") + .text(d => formatYear(d)); + + if (annotationDatum) { + const targetX = (fx(annotationDatum.time.getTime()) || 0) + fg(annotationDatum.high.group) + fg.bandwidth() / 2; + const targetY = fy(annotationDatum.high.value); + const callout = fp.append("g") + .attr("class", "histogram03-full-annotation") + .attr("data-chart-element", "annotation-card") + .attr("data-anchor-year", formatYear(annotationDatum.time)); + const cardX = Math.max(20, Math.min(fullPlot.w - 220, targetX - 300)); + const cardY = Math.max(34, Math.min(fullPlot.h - 86, targetY + 32)); + callout.append("line") + .attr("x1", cardX + 188) + .attr("y1", cardY + 22) + .attr("x2", targetX) + .attr("y2", Math.max(10, targetY - 10)) + .attr("stroke", "#85AFE8") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "4 4"); + callout.append("rect") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", 202) + .attr("height", 60) + .attr("rx", 11) + .attr("fill", "#FFFFFF") + .attr("stroke", "#CAE2F6") + .attr("filter", "url(#histogram03-soft-shadow)"); + const calloutSlot = callout.append("g") + .attr("class", "reserved-asset-slot histogram03-callout-icon-slot") + .attr("data-asset-slot", "histogram-callout-icon") + .attr("data-asset-policy", "neutral_placeholder") + .attr("data-anchor", "annotation-card-left") + .attr("data-collision-policy", "contained-in-annotation-card") + .attr("transform", `translate(${cardX + 16}, ${cardY + 18})`); + calloutSlot.append("circle") + .attr("cx", 12) + .attr("cy", 12) + .attr("r", 12) + .attr("fill", "#EAF3FF") + .attr("stroke", "#BBD8F5"); + calloutSlot.append("circle") + .attr("cx", 12) + .attr("cy", 12) + .attr("r", 4) + .attr("fill", "#1266D8"); + callout.append("text") + .attr("x", cardX + 52) + .attr("y", cardY + 24) + .style("font-family", labelFamily) + .style("font-size", "10px") + .style("font-weight", 900) + .style("fill", "#0B2C66") + .text(`${annotationDatum.high.group} leads`); + callout.append("text") + .attr("x", cardX + 52) + .attr("y", cardY + 42) + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 800) + .style("fill", "#6884A8") + .text(`${shortNumber(annotationDatum.gap)} over ${annotationDatum.low.group} in ${formatYear(annotationDatum.time)}`); + } + full.append("text") + .attr("x", fullW / 2) + .attr("y", fullPanel.y + fullPanel.h - 23) + .attr("text-anchor", "middle") + .style("font-family", labelFamily) + .style("font-size", "8px") + .style("font-weight", 800) + .style("fill", "#9AAFC7") + .text(`${formatYear(uniqueTimes[0])} - ${formatYear(uniqueTimes[uniqueTimes.length - 1])}`); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_04.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_04.js new file mode 100644 index 0000000000000000000000000000000000000000..bb99acc52d4a11c87fe75eb23139ba0eb2448d06 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_04.js @@ -0,0 +1,570 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_04", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["temporal"], ["numerical"], ["categorical"]], + "required_fields_range": [[10, 50], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const rawRows = (jsonData.data && jsonData.data.data) || []; + const columns = chartUtils.schema.columns(jsonData); + const typography = jsonData.typography || {}; + const colorResolver = chartUtils.color.resolver(jsonData); + + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const xField = xChannel.key; + const yField = yChannel.key; + const groupField = groupChannel.key; + const xColumn = columns.find(c => c.name === xField) || {}; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + + d3.select(containerSelector).html(""); + + const width = 1024; + const height = 1536; + const fontFamily = (typography.label && typography.label.font_family) || "Arial, Helvetica, sans-serif"; + const titleFamily = (typography.title && typography.title.font_family) || fontFamily; + const textColor = "#F7FBFF"; + const mutedText = "#B8C9E2"; + const gridColor = "#1E6A9C"; + const primaryColor = "#2F8DFF"; + const secondaryColor = "#30D7CF"; + + const titleText = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || + "Grouped Histogram"; + const subtitleText = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || + (jsonData.description || ""); + + function safeId(value) { + return String(value == null ? "" : value) + .replace(/[^a-zA-Z0-9_-]+/g, "-") + .replace(/^-+|-+$/g, "") + .toLowerCase() || "item"; + } + + function parseTemporal(value) { + if (value instanceof Date) return value.getTime(); + const raw = String(value == null ? "" : value).trim(); + if (/^\d{4}$/.test(raw)) return +raw; + const parsed = Date.parse(raw); + return Number.isFinite(parsed) ? parsed : raw; + } + + function isTemporalField() { + if (xColumn.data_type === "temporal") return true; + return rawRows.length > 0 && rawRows.every(d => { + const value = d[xField]; + return /^\d{4}$/.test(String(value)) || Number.isFinite(Date.parse(String(value))); + }); + } + + const temporal = isTemporalField(); + let dimensions = [...new Set(rawRows.map(d => d[xField]).filter(d => d !== undefined && d !== null))]; + if (temporal) { + dimensions = dimensions.sort((a, b) => { + const av = parseTemporal(a); + const bv = parseTemporal(b); + if (typeof av === "number" && typeof bv === "number") return av - bv; + return String(a).localeCompare(String(b)); + }); + } + + const groups = [...new Set(rawRows.map(d => d[groupField]).filter(d => d !== undefined && d !== null))].slice(0, 2); + const rowsByKey = new Map(); + rawRows.forEach((d, i) => { + rowsByKey.set(`${d[xField]}|||${d[groupField]}`, { + raw: d, + index: i, + dimension: d[xField], + group: d[groupField], + value: +d[yField] || 0 + }); + }); + const plotRows = []; + dimensions.forEach((dimension, dimensionIndex) => { + groups.forEach((group, groupIndex) => { + const row = rowsByKey.get(`${dimension}|||${group}`); + if (row) { + plotRows.push({ ...row, dimensionIndex, groupIndex }); + } + }); + }); + + const maxValue = d3.max(plotRows, d => d.value) || 1; + const magnitude = Math.pow(10, Math.max(1, Math.floor(Math.log10(maxValue)))); + const stepBase = maxValue / magnitude > 6 ? magnitude * 2 : magnitude; + const yMax = Math.max(stepBase, Math.ceil(maxValue / stepBase) * stepBase); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const bgGradient = defs.append("radialGradient") + .attr("id", "histogram04-bg") + .attr("cx", "52%") + .attr("cy", "42%") + .attr("r", "80%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#07345D"); + bgGradient.append("stop").attr("offset", "48%").attr("stop-color", "#031C37"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#000B1C"); + + const baselineGlow = defs.append("linearGradient") + .attr("id", "histogram04-baseline-glow") + .attr("x1", "0%").attr("x2", "100%") + .attr("y1", "0%").attr("y2", "0%"); + baselineGlow.append("stop").attr("offset", "0%").attr("stop-color", "#1CCBFF").attr("stop-opacity", 0.55); + baselineGlow.append("stop").attr("offset", "50%").attr("stop-color", "#77F4FF").attr("stop-opacity", 0.95); + baselineGlow.append("stop").attr("offset", "100%").attr("stop-color", "#1CCBFF").attr("stop-opacity", 0.55); + + function addBarGradient(id, base, light) { + const gradient = defs.append("linearGradient") + .attr("id", id) + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "0%").attr("y2", "100%"); + gradient.append("stop").attr("offset", "0%").attr("stop-color", light); + gradient.append("stop").attr("offset", "46%").attr("stop-color", base); + gradient.append("stop").attr("offset", "100%").attr("stop-color", colorResolver.variant(base, { mode: "darker", amount: 0.28 }) || base); + } + addBarGradient("histogram04-bar-0", primaryColor, "#8BC6FF"); + addBarGradient("histogram04-bar-1", secondaryColor, "#84FFF8"); + + const glow = defs.append("filter") + .attr("id", "histogram04-soft-glow") + .attr("x", "-35%").attr("y", "-35%") + .attr("width", "170%").attr("height", "170%"); + glow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 0) + .attr("stdDeviation", 4) + .attr("flood-color", "#42DFFF") + .attr("flood-opacity", 0.32); + + const axisGlow = defs.append("filter") + .attr("id", "histogram04-axis-glow") + .attr("x", "-10%").attr("y", "-500%") + .attr("width", "120%").attr("height", "1000%"); + axisGlow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 0) + .attr("stdDeviation", 6) + .attr("flood-color", "#1BD9FF") + .attr("flood-opacity", 0.75); + + svg.append("rect") + .attr("class", "histogram04-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#histogram04-bg)"); + + svg.append("ellipse") + .attr("cx", 760) + .attr("cy", 305) + .attr("rx", 340) + .attr("ry", 190) + .attr("fill", "#0C66A8") + .attr("opacity", 0.12); + + function measure(text, fontSize, fontWeight = 400, family = fontFamily) { + try { + return chartUtils.text.measure(svg, String(text || ""), { + fontFamily: family, + fontSize: `${fontSize}px`, + fontWeight + }).width; + } catch (e) { + return String(text || "").length * fontSize * 0.58; + } + } + + function wrapLines(text, maxWidth, fontSize, fontWeight, maxLines, family = fontFamily) { + const words = String(text || "").split(/\s+/).filter(Boolean); + if (!words.length) return []; + const lines = []; + let line = ""; + words.forEach(word => { + const candidate = line ? `${line} ${word}` : word; + if (line && measure(candidate, fontSize, fontWeight, family) > maxWidth) { + lines.push(line); + line = word; + } else { + line = candidate; + } + }); + if (line) lines.push(line); + const visible = lines.slice(0, maxLines); + if (lines.length > maxLines && visible.length) { + let last = visible[visible.length - 1]; + while (last.length > 4 && measure(`${last}...`, fontSize, fontWeight, family) > maxWidth) { + const parts = last.split(/\s+/); + parts.pop(); + last = parts.join(" "); + if (!last) break; + } + visible[visible.length - 1] = `${last || visible[visible.length - 1]}...`; + } + return visible; + } + + function addWrappedText(parent, text, x, y, maxWidth, options) { + const cfg = { + fontSize: 24, + fontWeight: 400, + fill: textColor, + anchor: "start", + family: fontFamily, + lineHeight: 1.18, + maxLines: 3, + letterSpacing: 0, + transform: value => value, + ...options + }; + const lines = wrapLines(cfg.transform(text), maxWidth, cfg.fontSize, cfg.fontWeight, cfg.maxLines, cfg.family); + const textEl = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", cfg.anchor) + .style("font-family", cfg.family) + .style("font-size", `${cfg.fontSize}px`) + .style("font-weight", cfg.fontWeight) + .style("fill", cfg.fill) + .style("letter-spacing", cfg.letterSpacing); + lines.forEach((line, i) => { + textEl.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : `${cfg.fontSize * cfg.lineHeight}px`) + .text(line); + }); + return { element: textEl, lines, height: Math.max(1, lines.length) * cfg.fontSize * cfg.lineHeight }; + } + + function titleParts(value) { + const words = String(value || "").split(/\s+/).filter(Boolean); + if (words.length <= 3) { + return { kicker: "TREND OVER TIME", main: value }; + } + return { + kicker: words.slice(0, 2).join(" ").toUpperCase(), + main: words.slice(2).join(" ") + }; + } + + const header = svg.append("g").attr("class", "header-layer"); + const parts = titleParts(titleText); + addWrappedText(header, parts.kicker, 54, 86, 430, { + fontSize: 34, + fontWeight: 800, + fill: "#2EB8FF", + family: titleFamily, + maxLines: 1, + letterSpacing: 7 + }); + const mainTitle = addWrappedText(header, parts.main, 54, 150, 620, { + fontSize: parts.main.length > 38 ? 54 : 72, + fontWeight: 900, + fill: "#F7FBFF", + family: titleFamily, + maxLines: 3, + lineHeight: 1.08 + }); + const titleTspans = mainTitle.element.selectAll("tspan"); + titleTspans.filter((d, i, nodes) => i === nodes.length - 1) + .style("fill", "#28C9FF"); + const accentY = Math.min(430, 150 + mainTitle.height + 10); + header.append("line") + .attr("x1", 58) + .attr("x2", 232) + .attr("y1", accentY) + .attr("y2", accentY) + .attr("stroke", "#22B8FF") + .attr("stroke-width", 5) + .attr("stroke-linecap", "round"); + const subtitleY = accentY + 52; + addWrappedText(header, subtitleText, 58, subtitleY, 455, { + fontSize: 25, + fontWeight: 400, + fill: mutedText, + family: fontFamily, + maxLines: 3, + lineHeight: 1.45 + }); + + const headerSlot = header.append("g") + .attr("class", "asset-slot header-topic-illustration-slot") + .attr("data-asset-slot", "header-topic-illustration") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "top-right-header-safe-area") + .attr("data-collision-rule", "avoid-title-subtitle-plot-and-legend") + .attr("data-bbox", "482,72,476,350"); + headerSlot.append("rect") + .attr("x", 482) + .attr("y", 72) + .attr("width", 476) + .attr("height", 350) + .attr("rx", 34) + .attr("fill", "#0C3960") + .attr("opacity", 0.08) + .attr("stroke", "#1A7BB3") + .attr("stroke-width", 1.2) + .attr("stroke-opacity", 0); + [0, 1, 2, 3].forEach(i => { + headerSlot.append("path") + .attr("d", `M${520 + i * 28},${340 - i * 22} C${610 + i * 18},${240 - i * 30} ${780 - i * 16},${220 - i * 16} ${925 - i * 8},${145 + i * 22}`) + .attr("fill", "none") + .attr("stroke", i === 0 ? "#26D7FF" : "#1A7BB3") + .attr("stroke-width", i === 0 ? 2.4 : 1.4) + .attr("stroke-opacity", i === 0 ? 0.36 : 0.18); + }); + headerSlot.append("path") + .attr("d", "M590,352 C690,300 782,300 892,346") + .attr("fill", "none") + .attr("stroke", "#2EB8FF") + .attr("stroke-width", 4) + .attr("stroke-opacity", 0.26) + .attr("stroke-linecap", "round"); + headerSlot.append("path") + .attr("d", "M676,196 L840,118 L802,246 Z") + .attr("fill", "#2EB8FF") + .attr("opacity", 0.11); + + const plot = { + x: 102, + y: 555, + width: 862, + height: 585 + }; + const baselineY = plot.y + plot.height; + const xScale = d3.scaleBand() + .domain(dimensions) + .range([plot.x, plot.x + plot.width]) + .paddingInner(dimensions.length > 22 ? 0.10 : 0.18) + .paddingOuter(0.04); + const yScale = d3.scaleLinear() + .domain([0, yMax]) + .range([baselineY, plot.y]) + .nice(); + + const axisLayer = svg.append("g").attr("class", "axis-grid-layer"); + const tickValues = yScale.ticks(6).filter(d => d >= 0); + tickValues.forEach(tick => { + const y = yScale(tick); + axisLayer.append("line") + .attr("class", "y-gridline") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.width) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", gridColor) + .attr("stroke-width", tick === 0 ? 0 : 1.4) + .attr("stroke-dasharray", tick === 0 ? null : "5 8") + .attr("opacity", tick === 0 ? 0 : 0.55); + axisLayer.append("text") + .attr("class", "y-axis-label") + .attr("x", plot.x - 26) + .attr("y", y + 8) + .attr("text-anchor", "end") + .style("font-family", fontFamily) + .style("font-size", "31px") + .style("font-weight", 800) + .style("fill", textColor) + .text(formatNumber(tick)); + }); + + axisLayer.append("line") + .attr("class", "x-axis-baseline") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.width) + .attr("y1", baselineY) + .attr("y2", baselineY) + .attr("stroke", "url(#histogram04-baseline-glow)") + .attr("stroke-width", 3) + .attr("filter", "url(#histogram04-axis-glow)"); + + if (yUnit) { + const badge = axisLayer.append("g") + .attr("class", "y-axis-unit-badge") + .attr("transform", `translate(${plot.x - 58},${plot.y - 66})`); + badge.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", 94) + .attr("height", 44) + .attr("rx", 22) + .attr("fill", "#06345E") + .attr("stroke", "#1AB6F9") + .attr("stroke-width", 1.6) + .attr("opacity", 0.96); + badge.append("text") + .attr("x", 47) + .attr("y", 30) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", "25px") + .style("font-weight", 900) + .style("fill", "#27D6FF") + .text(`(${yUnit})`); + } + + function formatDimension(value) { + if (/^\d{4}$/.test(String(value))) return String(value); + if (value instanceof Date) return String(value.getFullYear()); + const parsed = Date.parse(String(value)); + if (temporal && Number.isFinite(parsed)) return String(new Date(parsed).getFullYear()); + return String(value); + } + + function formatNumber(value) { + if (chartUtils.format && chartUtils.format.autoText) { + const formatted = chartUtils.format.autoText(value); + if (formatted && typeof formatted === "object" && formatted.text) return formatted.text; + if (formatted !== undefined && formatted !== null) return String(formatted); + } + if (Math.abs(value) >= 1000) return `${Math.round(value / 100) / 10}k`; + return String(value); + } + + function squareBarPath(x, y, barWidth, barHeight) { + const h = Math.max(0, barHeight); + const bottom = y + h; + if (h <= 0) return `M${x},${bottom}Z`; + return [ + `M${x},${bottom}`, + `L${x},${y}`, + `L${x + barWidth},${y}`, + `L${x + barWidth},${bottom}`, + "Z" + ].join(" "); + } + + const markLayer = svg.append("g").attr("class", "histogram-mark-layer"); + const xTickStep = dimensions.length <= 13 ? 1 : Math.ceil(dimensions.length / 11); + dimensions.forEach((dimension, index) => { + if (index % xTickStep !== 0 && index !== dimensions.length - 1) return; + const cx = xScale(dimension) + xScale.bandwidth() / 2; + axisLayer.append("text") + .attr("class", "x-axis-label") + .attr("x", cx) + .attr("y", baselineY + 37) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", dimensions.length > 18 ? "20px" : "27px") + .style("font-weight", 900) + .style("fill", textColor) + .text(formatDimension(dimension)); + }); + + const groupCount = Math.max(1, groups.length); + const groupGap = dimensions.length > 18 ? 3 : 8; + const availableBand = xScale.bandwidth(); + const barWidth = Math.max(5, Math.min(28, (availableBand - groupGap * (groupCount - 1)) / groupCount * 0.82)); + const totalGroupWidth = barWidth * groupCount + groupGap * (groupCount - 1); + + plotRows.forEach(d => { + const groupOffset = d.groupIndex * (barWidth + groupGap); + const x = xScale(d.dimension) + (availableBand - totalGroupWidth) / 2 + groupOffset; + const y = yScale(d.value); + const h = baselineY - y; + markLayer.append("path") + .attr("class", `bar bar-${d.groupIndex}`) + .attr("data-chart-mark", "histogram-bar") + .attr("data-x-value", String(d.dimension)) + .attr("data-group", String(d.group)) + .attr("data-value", d.value) + .attr("d", squareBarPath(x, y, barWidth, h)) + .attr("fill", `url(#histogram04-bar-${d.groupIndex})`) + .attr("stroke", d.groupIndex === 0 ? "#B9DDFF" : "#B9FFFB") + .attr("stroke-width", 1.3) + .attr("stroke-opacity", 0.72) + .attr("filter", "url(#histogram04-soft-glow)"); + }); + + const legendLayer = svg.append("g") + .attr("class", "legend-layer") + .attr("data-coordinate-relationship", "independent-centered-below-plot") + .attr("transform", `translate(${width / 2},${baselineY + 92})`); + const legendFont = groups.some(g => String(g).length > 19) ? 25 : 29; + const legendItems = groups.map((group, index) => ({ + group, + index, + color: index === 0 ? primaryColor : secondaryColor, + width: Math.min(420, 64 + measure(group, legendFont, 800, fontFamily)) + })); + const totalLegendWidth = legendItems.reduce((sum, item) => sum + item.width, 0) + (legendItems.length - 1) * 58; + let cursor = -totalLegendWidth / 2; + legendItems.forEach(item => { + const itemG = legendLayer.append("g") + .attr("class", "legend-item") + .attr("transform", `translate(${cursor},0)`); + const icon = itemG.append("g") + .attr("class", "asset-slot legend-series-icon-slot") + .attr("data-asset-slot", "legend-series-icon") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-series", String(item.group)) + .attr("data-anchor", "legend-item-left") + .attr("data-collision-rule", "stay-inside-legend-row"); + icon.append("circle") + .attr("cx", 20) + .attr("cy", 0) + .attr("r", 28) + .attr("fill", item.index === 0 ? "#0C4F91" : "#066C71") + .attr("stroke", item.color) + .attr("stroke-width", 2) + .attr("opacity", 0.96); + icon.append("rect") + .attr("x", 8) + .attr("y", -11) + .attr("width", 24) + .attr("height", 22) + .attr("rx", 6) + .attr("fill", item.color) + .attr("opacity", 0.82); + itemG.append("text") + .attr("x", 66) + .attr("y", 10) + .attr("text-anchor", "start") + .style("font-family", fontFamily) + .style("font-size", `${legendFont}px`) + .style("font-weight", 900) + .style("fill", textColor) + .text(String(item.group)); + cursor += item.width + 58; + }); + + svg.append("g") + .attr("class", "ignored-bottom-wrapper-policy") + .attr("data-ignored-reference-element", "bottom_takeaway_card") + .attr("data-policy", "no-bottom-takeaway-source-footer-or-replacement-prose") + .attr("opacity", 0); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_05.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_05.js new file mode 100644 index 0000000000000000000000000000000000000000..b9dde8bb9c9f47a64920a465cbfd1d1364bed850 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_05.js @@ -0,0 +1,432 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_05", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["temporal"], ["numerical"], ["categorical"]], + "required_fields_range": [[10, 50], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = variables.height || 600; + const uid = String(containerSelector || "chart-container").replace(/[^a-zA-Z0-9_-]/g, "_"); + + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + const xUnit = chartUtils.schema.channel(jsonData, "x").unit !== "none" ? chartUtils.schema.channel(jsonData, "x").unit : ""; + const yUnit = chartUtils.schema.channel(jsonData, "y").unit !== "none" ? chartUtils.schema.channel(jsonData, "y").unit : ""; + + function parseTemporalValue(value) { + if (value instanceof Date) return value; + if (typeof value === "number") return new Date(value, 0, 1); + const parsed = chartUtils.format.parseDate(value); + if (parsed instanceof Date && !Number.isNaN(parsed.getTime())) return parsed; + const yearMatch = String(value).match(/^\d{4}$/); + return yearMatch ? new Date(+value, 0, 1) : new Date(value); + } + + const processedData = chartData.map((d, i) => ({ + rawX: d[xField], + time: parseTemporalValue(d[xField]), + value: +d[yField], + group: d[groupField], + originalIndex: i + })).filter(d => Number.isFinite(d.value) && d.time instanceof Date && !Number.isNaN(d.time.getTime())); + + processedData.sort((a, b) => a.time - b.time); + + const uniqueTimes = Array.from(new Set(processedData.map(d => d.time.getTime()))) + .map(t => new Date(t)); + uniqueTimes.sort((a, b) => a - b); + + const timeOrderMap = new Map(); + uniqueTimes.forEach((time, index) => timeOrderMap.set(time.getTime(), index)); + processedData.forEach(d => { d.order = timeOrderMap.get(d.time.getTime()); }); + + const groups = [...new Set(processedData.map(d => d.group))]; + const groupsToUse = groups.slice(0, 2); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto; display: block;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("class", "histogram-05-reference-layout") + .attr("data-chart-type", "Histogram") + .attr("data-chart-variation", "histogram_05") + .attr("data-reference-style", "sample_00_gpt_image_2_01") + .attr("data-source-rows", processedData.length) + .attr("data-rendered-points", processedData.length) + .attr("data-x-field", xField) + .attr("data-y-field", yField) + .attr("data-group-field", groupField); + + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", `histogram_05_bg_${uid}`) + .attr("x1", "0%").attr("y1", "0%").attr("x2", "0%").attr("y2", "100%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#F6FBFF"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#EAF5FD"); + }); + defs.append("linearGradient") + .attr("id", `histogram_05_accent_${uid}`) + .attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#BFE3FA"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#E9F5FF"); + }); + + const referencePalette = [ + { top: "#1476D4", bottom: "#0757B4", stroke: "#064E9D", label: "#0757B4" }, + { top: "#A8D4F7", bottom: "#6FADE6", stroke: "#5E9ED8", label: "#5B9DE1" } + ]; + groupsToUse.forEach((group, i) => { + const role = referencePalette[i] || referencePalette[referencePalette.length - 1]; + defs.append("linearGradient") + .attr("id", `histogram_05_bar_${i}_${uid}`) + .attr("x1", "0%").attr("y1", "0%").attr("x2", "0%").attr("y2", "100%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", role.top); + g.append("stop").attr("offset", "100%").attr("stop-color", role.bottom); + }); + }); + + function formatYear(date) { + return chartUtils.format.date(date, { output: "%Y" }).text; + } + + function formatValue(value, includeUnit = false) { + const abs = Math.abs(value); + let text; + if (abs >= 1000000) text = `${d3.format(".2~f")(value / 1000000)}M`; + else if (abs >= 10000) text = `${d3.format(".1~f")(value / 1000)}K`; + else if (abs >= 1000) text = `${d3.format(".2~f")(value / 1000)}K`; + else text = d3.format(abs < 10 && value % 1 ? ".1f" : ".3~g")(value); + return includeUnit && yUnit ? `${text} ${yUnit}` : text; + } + + function ellipsize(text, maxChars) { + const value = String(text || ""); + return value.length > maxChars ? `${value.slice(0, Math.max(1, maxChars - 1))}…` : value; + } + + function roundedTopRectPath(x, y, w, h, r) { + const radius = Math.max(0, Math.min(r, w / 2, h)); + if (h <= 0 || w <= 0) return ""; + return [ + `M${x},${y + radius}`, + `Q${x},${y} ${x + radius},${y}`, + `H${x + w - radius}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `V${y + h}`, + `H${x}`, + "Z" + ].join(" "); + } + + svg.append("rect") + .attr("class", "chart-background") + .attr("width", width) + .attr("height", height) + .attr("fill", `url(#histogram_05_bg_${uid})`); + + const panel = { x: 18, y: 12, w: width - 36, h: height - 27 }; + svg.append("rect") + .attr("class", "reference-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 10) + .attr("ry", 10) + .attr("fill", "#FFFFFF") + .attr("opacity", 0.9) + .attr("stroke", "#D6E8F2") + .attr("stroke-width", 1.2); + + svg.append("rect") + .attr("class", "panel-accent-band") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", 6) + .attr("rx", 6) + .attr("fill", `url(#histogram_05_accent_${uid})`); + + svg.append("g") + .attr("class", "reserved-asset-slot header-illustration-slot") + .attr("data-asset-slot", "histogram-05-header-illustration") + .attr("data-bbox", "365,24,176,54") + .attr("data-anchor", "header-safe-area") + .attr("data-collision-rule", "avoid-title-subtitle-chart-panel-axis-legend") + .append("rect") + .attr("x", 365) + .attr("y", 24) + .attr("width", 176) + .attr("height", 54) + .attr("rx", 8) + .attr("fill", "none") + .attr("stroke", "none") + .attr("opacity", 0); + + svg.append("g") + .attr("class", "reserved-asset-slot trend-icon-slot") + .attr("data-asset-slot", "histogram-05-trend-icon") + .attr("data-bbox", "42,30,34,34") + .attr("data-anchor", "header-annotation-safe-area") + .attr("data-collision-rule", "avoid-title-subtitle-chart-panel-axis-legend") + .append("circle") + .attr("cx", 59) + .attr("cy", 47) + .attr("r", 17) + .attr("fill", "none") + .attr("stroke", "none") + .attr("opacity", 0); + + const metricLabel = yUnit ? `${yField} (${yUnit})` : yField; + + svg.append("text") + .attr("class", "metric-label") + .attr("x", 42) + .attr("y", 55) + .attr("fill", "#10284A") + .style("font-family", typography.title.font_family || "Arial") + .style("font-size", "19px") + .style("font-weight", 800) + .text(ellipsize(metricLabel, 26)); + + svg.append("line") + .attr("class", "header-rule") + .attr("x1", 36) + .attr("x2", width - 36) + .attr("y1", 86) + .attr("y2", 86) + .attr("stroke", "#DCE9F3") + .attr("stroke-width", 1); + + const plot = { x: 82, y: 112, w: width - 126, h: 354 }; + const chartGroup = svg.append("g") + .attr("class", "plot-area") + .attr("data-source-count", processedData.length) + .attr("data-x-field", xField) + .attr("data-y-field", yField) + .attr("data-group-field", groupField) + .attr("data-y-unit", yUnit) + .attr("transform", `translate(${plot.x}, ${plot.y})`); + + chartGroup.append("rect") + .attr("class", "plot-backdrop") + .attr("x", 0) + .attr("y", 0) + .attr("width", plot.w) + .attr("height", plot.h) + .attr("rx", 6) + .attr("ry", 6) + .attr("fill", "#FFFFFF") + .attr("opacity", 0.72); + + const maxValue = d3.max(processedData, d => d.value) || 1; + const yScale = d3.scaleLinear() + .domain([0, maxValue]) + .range([plot.h, 0]) + .nice(5); + const yTicks = yScale.ticks(5); + const groupSlot = Math.max(1, plot.w / Math.max(1, uniqueTimes.length)); + const xScale = d3.scaleLinear() + .domain([0, Math.max(1, uniqueTimes.length - 1)]) + .range([groupSlot * 0.5, plot.w - groupSlot * 0.5]); + const barGap = Math.max(2, Math.min(6, groupSlot * 0.06)); + const barWidth = Math.max(4, Math.min(26, (groupSlot * 0.58 - barGap * (groupsToUse.length - 1)) / Math.max(1, groupsToUse.length))); + const groupTotalWidth = groupsToUse.length * barWidth + (groupsToUse.length - 1) * barGap; + + yTicks.forEach(tick => { + const y = yScale(tick); + chartGroup.append("line") + .attr("class", "gridline") + .attr("x1", 0) + .attr("x2", plot.w) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", tick === 0 ? "#9FBBD0" : "#D8E8F1") + .attr("stroke-width", tick === 0 ? 1.2 : 0.9) + .attr("stroke-dasharray", tick === 0 ? null : "4,5") + .attr("opacity", tick === 0 ? 0.95 : 0.75); + chartGroup.append("text") + .attr("class", "axis-label y-axis-label") + .attr("x", -12) + .attr("y", y) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", "#5E6975") + .style("font-family", typography.label.font_family) + .style("font-size", "12px") + .style("font-weight", 700) + .text(formatValue(tick)); + }); + + chartGroup.append("line") + .attr("class", "axis y-axis") + .attr("x1", 0).attr("x2", 0) + .attr("y1", 0).attr("y2", plot.h) + .attr("stroke", "#9FBBD0") + .attr("stroke-width", 1.1); + + const maxXTicks = uniqueTimes.length <= 7 ? uniqueTimes.length : 6; + const tickStep = Math.max(1, Math.ceil((uniqueTimes.length - 1) / Math.max(1, maxXTicks - 1))); + const xTickIndices = []; + for (let i = 0; i < uniqueTimes.length; i += tickStep) xTickIndices.push(i); + if (xTickIndices[xTickIndices.length - 1] !== uniqueTimes.length - 1) xTickIndices.push(uniqueTimes.length - 1); + + xTickIndices.forEach(i => { + chartGroup.append("text") + .attr("class", "axis-label x-axis-label") + .attr("x", xScale(i)) + .attr("y", plot.h + 24) + .attr("text-anchor", "middle") + .attr("fill", "#4D5965") + .style("font-family", typography.label.font_family) + .style("font-size", "12px") + .style("font-weight", 700) + .text(formatYear(uniqueTimes[i])); + }); + + chartGroup.append("text") + .attr("class", "x-axis-title") + .attr("x", plot.w / 2) + .attr("y", plot.h + 47) + .attr("text-anchor", "middle") + .attr("fill", "#7A8793") + .style("font-family", typography.label.font_family) + .style("font-size", "11px") + .style("font-weight", 800) + .text(xUnit ? `${String(xField).toUpperCase()} (${xUnit})` : String(xField).toUpperCase()); + + const barData = processedData.filter(d => groupsToUse.includes(d.group)); + chartGroup.selectAll(".grouped-histogram-bar") + .data(barData) + .enter() + .append("path") + .attr("class", "bar grouped-histogram-bar data-point") + .attr("data-source-index", d => d.originalIndex) + .attr("data-x", d => d.rawX) + .attr("data-value", d => d.value) + .attr("data-display-value", d => formatValue(d.value, Boolean(yUnit))) + .attr("data-group", d => d.group) + .attr("data-x-field", xField) + .attr("data-y-field", yField) + .attr("data-group-field", groupField) + .attr("data-top-cap", "rounded-corners") + .attr("data-bottom-cap", "flat-baseline") + .attr("d", d => { + const groupIndex = groupsToUse.indexOf(d.group); + const x = xScale(d.order) - groupTotalWidth / 2 + groupIndex * (barWidth + barGap); + const y = yScale(d.value); + const h = Math.max(0, plot.h - y); + const r = Math.min(barWidth * 0.28, 5.5, Math.max(1, h * 0.45)); + return roundedTopRectPath(x, y, barWidth, h, r); + }) + .attr("fill", d => `url(#histogram_05_bar_${groupsToUse.indexOf(d.group)}_${uid})`) + .attr("stroke", d => referencePalette[groupsToUse.indexOf(d.group)]?.stroke || "#5E9ED8") + .attr("stroke-width", 0.8) + .attr("opacity", d => groupsToUse.indexOf(d.group) === 0 ? 0.97 : 0.88); + + const labelTimes = new Set(uniqueTimes.slice(Math.max(0, uniqueTimes.length - 3)).map(d => d.getTime())); + const labelCandidates = barData.filter(d => labelTimes.has(d.time.getTime())); + const placedLabelBoxes = []; + labelCandidates.forEach(d => { + const groupIndex = groupsToUse.indexOf(d.group); + const x = xScale(d.order) - groupTotalWidth / 2 + groupIndex * (barWidth + barGap) + barWidth / 2; + const y = yScale(d.value) - 8; + const labelText = formatValue(d.value); + const estimatedW = Math.max(22, labelText.length * 6.4); + const box = { x0: x - estimatedW / 2, x1: x + estimatedW / 2, y0: y - 12, y1: y + 2 }; + const collides = placedLabelBoxes.some(b => !(box.x1 < b.x0 || box.x0 > b.x1 || box.y1 < b.y0 || box.y0 > b.y1)); + if (collides || y < 14) return; + placedLabelBoxes.push(box); + chartGroup.append("text") + .attr("class", "bar-value-label") + .attr("data-source-index", d.originalIndex) + .attr("data-x", d.rawX) + .attr("data-value", d.value) + .attr("data-display-value", formatValue(d.value, Boolean(yUnit))) + .attr("data-group", d.group) + .attr("x", x) + .attr("y", y) + .attr("text-anchor", "middle") + .attr("fill", referencePalette[groupIndex]?.label || "#0757B4") + .style("font-family", typography.label.font_family) + .style("font-size", "11px") + .style("font-weight", 800) + .text(labelText); + }); + + const legendFont = groupsToUse.some(g => String(g).length > 18) ? 11 : 13; + const legendGap = groupsToUse.some(g => String(g).length > 18) ? 18 : 28; + const estimatedLegendWidths = groupsToUse.map(g => 20 + 8 + Math.min(String(g).length, 22) * legendFont * 0.55); + const totalLegendW = estimatedLegendWidths.reduce((sum, w) => sum + w, 0) + legendGap * Math.max(0, groupsToUse.length - 1); + let cursor = width / 2 - totalLegendW / 2; + const legendY = height - 38; + groupsToUse.forEach((group, i) => { + const item = svg.append("g") + .attr("class", "legend-item") + .attr("data-group", group) + .attr("transform", `translate(${cursor}, ${legendY})`); + item.append("rect") + .attr("class", "legend-swatch") + .attr("x", 0) + .attr("y", -13) + .attr("width", 20) + .attr("height", 20) + .attr("rx", 4) + .attr("ry", 4) + .attr("fill", `url(#histogram_05_bar_${i}_${uid})`) + .attr("stroke", referencePalette[i]?.stroke || "#5E9ED8") + .attr("stroke-width", 0.8); + item.append("text") + .attr("x", 29) + .attr("y", 2) + .attr("fill", "#425064") + .style("font-family", typography.label.font_family) + .style("font-size", `${legendFont}px`) + .style("font-weight", 800) + .text(ellipsize(group, 24)); + cursor += estimatedLegendWidths[i] + legendGap; + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_06.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_06.js new file mode 100644 index 0000000000000000000000000000000000000000..59f7a4de8ca62c9f3398759dae5125ec065ff976 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/histogram_06.js @@ -0,0 +1,600 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "histogram_06", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["temporal"], ["numerical"], ["categorical"]], + "required_fields_range": [[10, 50], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || jsonData.colors_dark || { + text_color: "#333333", + other: { + primary: "#D32F2F", // 主要颜色 + secondary: "#AAAAAA", // 次要颜色 + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + const fullCanvasMode = width >= 850 || height >= 900; + const panelBox = fullCanvasMode + ? { x: 36, y: 430, width: width - 72, height: height - 470 } + : { x: 6, y: 6, width: width - 12, height: height - 12 }; + + // 设置边距 + const margin = fullCanvasMode + ? { + top: panelBox.y + 124, + right: width - panelBox.x - panelBox.width + 42, + bottom: height - panelBox.y - panelBox.height + 54, + left: panelBox.x + 74 + } + : { + top: 120, + right: 36, + bottom: 54, + left: 72 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + const titles = jsonData.titles || {}; + const mainTitle = titles.main_title || ""; + const subtitle = titles.sub_title || jsonData.description || ""; + const splitTitle = mainTitle.includes(",") + ? [mainTitle.slice(0, mainTitle.indexOf(",")).trim(), mainTitle.slice(mainTitle.indexOf(",") + 1).trim()] + : [mainTitle, ""]; + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确，将时间字符串转换为日期对象 + const processedData = chartData.map((d, i) => ({ + time: chartUtils.format.parseDate(d[xField]), // 确保转换为日期对象 + value: +d[yField], // 确保转换为数字 + group: d[groupField], // 添加分组信息 + originalIndex: i // 保留原始索引 + })); + + // 排序数据（按时间升序） + processedData.sort((a, b) => a.time - b.time); + + // 查找唯一的时间值 + const uniqueTimes = Array.from(new Set(processedData.map(d => d.time.getTime()))) + .map(t => new Date(t)); + uniqueTimes.sort((a, b) => a - b); + + // 为每个唯一的时间分配顺序值 + const timeOrderMap = new Map(); + uniqueTimes.forEach((time, index) => { + timeOrderMap.set(time.getTime(), index); + }); + + // 为每个数据点分配order + processedData.forEach(d => { + d.order = timeOrderMap.get(d.time.getTime()); + }); + + // 获取所有唯一的组值 + const groups = [...new Set(processedData.map(d => d.group))]; + + // 只保留前两个组（根据需求） + const groupsToUse = groups.slice(0, 2); + + // 为每个组分配颜色 + const groupColors = {}; + const referencePalette = ["#C86D95", "#6AA84F"]; + groupsToUse.forEach((group, index) => { + const resolved = colorResolver.field(group, index, { fallbackKey: index === 0 ? "primary" : "secondary" }).value; + groupColors[group] = fullCanvasMode + ? (referencePalette[index] || "#6AA84F") + : (resolved || referencePalette[index] || "#6AA84F"); + }); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用序号比例尺 + const xPadding = chartWidth / Math.max(1, uniqueTimes.length) / 2; + const xScale = d3.scaleLinear() + .domain([0, uniqueTimes.length - 1]) + .range([xPadding, chartWidth - xPadding]); + const bandStep = Math.max(1, chartWidth / uniqueTimes.length); + const binWidth = Math.min(26, bandStep * 0.34); + + // Y轴比例尺 - 使用数值 + const maxValue = d3.max(processedData, d => d.value) || 1; + const yDomainTop = maxValue <= 1 ? 1 : maxValue * 1.12; + const yScale = d3.scaleLinear() + .domain([0, yDomainTop]) + .range([chartHeight, 0]) + .nice(); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + + defs.append("filter") + .attr("id", "histogram06-panel-shadow") + .attr("x", "-10%") + .attr("y", "-10%") + .attr("width", "120%") + .attr("height", "120%") + .append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 3) + .attr("flood-color", "#7E927E") + .attr("flood-opacity", 0.16); + + defs.append("clipPath") + .attr("id", "histogram06-plot-clip") + .append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", chartWidth) + .attr("height", chartHeight); + + if (fullCanvasMode) { + svg.append("rect") + .attr("class", "histogram06-full-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("rx", 24) + .attr("ry", 24) + .attr("fill", "#F4F8EF"); + + const header = svg.append("g") + .attr("class", "histogram06-header") + .attr("data-collision-rule", "title, subtitle, cards, and header image stay above chart panel"); + + const wrapWords = (text, maxChars) => { + const lines = []; + let line = ""; + String(text).split(/\s+/).filter(Boolean).forEach(word => { + const next = line ? `${line} ${word}` : word; + if (next.length > maxChars && line) { + lines.push(line); + line = word; + } else { + line = next; + } + }); + if (line) lines.push(line); + return lines; + }; + + if (splitTitle[1]) { + header.append("text") + .attr("class", "histogram06-title-line histogram06-title-primary") + .attr("x", 54) + .attr("y", 76) + .attr("font-family", "Georgia, serif") + .attr("font-size", 34) + .attr("font-weight", 700) + .attr("fill", "#14262D") + .text(splitTitle[0].replace(/\s+\S+$/, "")); + const firstAccent = (splitTitle[0].match(/\S+$/) || [""])[0].replace(/,$/, ""); + const secondAccent = splitTitle[1]; + header.append("text") + .attr("class", "histogram06-title-line histogram06-title-positive") + .attr("x", 54) + .attr("y", 136) + .attr("font-family", "Georgia, serif") + .attr("font-size", 48) + .attr("font-weight", 700) + .attr("fill", "#3F7A3D") + .text(firstAccent || splitTitle[1]); + if (secondAccent && secondAccent !== firstAccent) { + header.append("text") + .attr("class", "histogram06-title-line histogram06-title-negative") + .attr("x", 54) + .attr("y", 194) + .attr("font-family", "Georgia, serif") + .attr("font-size", 48) + .attr("font-weight", 700) + .attr("fill", "#BE5F87") + .text(secondAccent); + } + } else { + wrapWords(mainTitle, 34).slice(0, 2).forEach((line, index) => { + header.append("text") + .attr("class", "histogram06-title-line histogram06-title-primary") + .attr("x", 54) + .attr("y", 70 + index * 34) + .attr("font-family", "Georgia, serif") + .attr("font-size", 26) + .attr("font-weight", 700) + .attr("fill", index === 1 ? "#BE5F87" : "#14262D") + .text(line); + }); + } + + const subtitleLines = String(subtitle).match(/.{1,54}(?:\s|$)/g) || []; + subtitleLines.slice(0, 2).forEach((line, index) => { + header.append("text") + .attr("class", "histogram06-subtitle") + .attr("x", 56) + .attr("y", 256 + index * 28) + .attr("font-family", typography.description?.font_family || "Arial") + .attr("font-size", 18) + .attr("font-weight", 500) + .attr("fill", "#26383E") + .text(line.trim()); + }); + + const backgroundSlot = { + x: width * 0.52, + y: 182, + width: 390, + height: 138 + }; + header.append("rect") + .attr("class", "reserved-asset-slot histogram06-header-background-slot") + .attr("data-asset-slot", "histogram06-header-background") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "header-lower-right") + .attr("data-bbox", `${Math.round(backgroundSlot.x)},${backgroundSlot.y},${backgroundSlot.width},${backgroundSlot.height}`) + .attr("data-mask-policy", "downstream image2/retrieval art must stay inside this rounded bbox and behind the illustration slot") + .attr("data-collision-rule", "stay right of subtitle/cards and above chart panel") + .attr("data-no-copied-reference-art", "true") + .attr("x", backgroundSlot.x) + .attr("y", backgroundSlot.y) + .attr("width", backgroundSlot.width) + .attr("height", backgroundSlot.height) + .attr("rx", 28) + .attr("ry", 28) + .attr("fill", "#DCEADF") + .attr("stroke", "#B7CFB0") + .attr("stroke-width", 1.2) + .attr("stroke-dasharray", "8 8") + .attr("opacity", 0.42); + + const illustrationSlot = { + x: width * 0.61, + y: 58, + width: 260, + height: 230 + }; + const slot = header.append("g") + .attr("class", "reserved-asset-slot histogram06-header-illustration-slot") + .attr("data-asset-slot", "histogram06-header-illustration") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "top-right-header") + .attr("data-bbox", `${Math.round(illustrationSlot.x)},${illustrationSlot.y},${illustrationSlot.width},${illustrationSlot.height}`) + .attr("data-mask-policy", "downstream image2/retrieval art must stay inside this rounded bbox") + .attr("data-collision-rule", "stay above chart panel and right of title/subtitle/cards") + .attr("data-no-copied-reference-art", "true") + .attr("transform", `translate(${illustrationSlot.x}, ${illustrationSlot.y})`); + slot.append("rect") + .attr("width", illustrationSlot.width) + .attr("height", illustrationSlot.height) + .attr("rx", 28) + .attr("ry", 28) + .attr("fill", "#E7F0E1") + .attr("stroke", "#9FB99D") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "10 8"); + slot.append("circle") + .attr("cx", illustrationSlot.width * 0.5) + .attr("cy", illustrationSlot.height * 0.5) + .attr("r", Math.min(illustrationSlot.width, illustrationSlot.height) * 0.22) + .attr("fill", "none") + .attr("stroke", "#9FB99D") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "7 7") + .attr("opacity", 0.75); + + const trendByGroup = groupsToUse.map(group => { + const values = processedData.filter(d => d.group === group).sort((a, b) => a.order - b.order); + const first = values[0]?.value || 0; + const last = values[values.length - 1]?.value || 0; + return { group, direction: last >= first ? "up" : "down" }; + }); + const cards = header.append("g").attr("class", "histogram06-trend-cards"); + trendByGroup.slice(0, 2).forEach((trend, index) => { + const cardX = 54 + index * 244; + const cardY = 326; + const positive = trend.direction === "up"; + const card = cards.append("g") + .attr("class", "histogram06-trend-card") + .attr("transform", `translate(${cardX}, ${cardY})`); + card.append("rect") + .attr("width", 218) + .attr("height", 62) + .attr("rx", 10) + .attr("fill", positive ? "#EEF7E8" : "#F9EAF0") + .attr("stroke", positive ? "#A7C69B" : "#D8A7BA"); + card.append("circle") + .attr("cx", 31) + .attr("cy", 31) + .attr("r", 20) + .attr("fill", positive ? "#67A64C" : "#C86D95"); + card.append("text") + .attr("x", 31) + .attr("y", 38) + .attr("text-anchor", "middle") + .attr("font-size", 22) + .attr("font-weight", 700) + .attr("fill", "#FFFFFF") + .text(positive ? "↗" : "↘"); + card.append("text") + .attr("x", 62) + .attr("y", 26) + .attr("font-size", 14) + .attr("font-weight", 700) + .attr("fill", "#1A252A") + .text(`${trend.group}`); + card.append("text") + .attr("x", 62) + .attr("y", 46) + .attr("font-size", 13) + .attr("fill", "#1A252A") + .text(positive ? "shows an increase" : "shows a decline"); + }); + } + + svg.append("rect") + .attr("class", "histogram06-chart-panel") + .attr("x", panelBox.x) + .attr("y", panelBox.y) + .attr("width", panelBox.width) + .attr("height", panelBox.height) + .attr("rx", Math.min(24, height * 0.05)) + .attr("ry", Math.min(24, height * 0.05)) + .attr("fill", "#FFFDF5") + .attr("stroke", "#9FB99D") + .attr("stroke-width", 1.2) + .attr("filter", "url(#histogram06-panel-shadow)"); + + const labelFromKey = key => String(key || "") + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .replace(/[_-]+/g, " ") + .replace(/\b\w/g, c => c.toUpperCase()) + .trim(); + const panelTitleRaw = labelFromKey(yField) || dataColumns.find(col => col.role === "y")?.description || yField; + const panelTitle = panelTitleRaw.length > 34 ? `${panelTitleRaw.slice(0, 31).trim()}...` : panelTitleRaw; + svg.append("text") + .attr("class", "histogram06-panel-title") + .attr("x", panelBox.x + 48) + .attr("y", panelBox.y + 56) + .attr("font-family", typography.title?.font_family || typography.label.font_family) + .attr("font-size", 18) + .attr("font-weight", 700) + .attr("fill", "#111D22") + .text(panelTitle); + + const legendFontSize = Math.max(11, Math.min(16, width / 44)); + const legendItemGap = 22; + const legendWidths = groupsToUse.map(group => 18 + String(group).length * legendFontSize * 0.58 + legendItemGap); + const legendTotalWidth = d3.sum(legendWidths); + const legendStartX = Math.max(panelBox.x + panelBox.width * 0.56, panelBox.x + panelBox.width - 52 - legendTotalWidth); + const legend = svg.append("g") + .attr("class", "histogram06-legend") + .attr("transform", `translate(${legendStartX}, ${panelBox.y + 44})`); + + let legendX = 0; + groupsToUse.forEach(group => { + const item = legend.append("g") + .attr("class", "histogram06-legend-item") + .attr("transform", `translate(${legendX}, 0)`); + item.append("rect") + .attr("width", 14) + .attr("height", 14) + .attr("rx", 2) + .attr("ry", 2) + .attr("fill", groupColors[group]); + item.append("text") + .attr("x", 24) + .attr("y", 12) + .attr("font-family", typography.label.font_family) + .attr("font-size", legendFontSize) + .attr("font-weight", 700) + .attr("fill", "#111D22") + .text(group); + legendX += 18 + String(group).length * legendFontSize * 0.58 + legendItemGap; + }); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + // 根据数据点数量计算合适的标签间距 + const maxTicks = 8; // 最多显示的刻度数 + const dataLength = uniqueTimes.length; + + // 计算间距 - 向上取整以确保不会超过最大刻度数 + const indexStep = Math.ceil(dataLength / maxTicks); + + // 生成标签索引 + const tickIndices = []; + let currentIndex = 0; + const endIndex = dataLength - 1; + + // 添加起点 + tickIndices.push(currentIndex); + + // 按计算出的间距添加中间点 + while (currentIndex + indexStep < endIndex) { + currentIndex += indexStep; + tickIndices.push(currentIndex); + } + + // 添加终点(如果最后一个点不是终点) + if (tickIndices[tickIndices.length - 1] + indexStep / 2 < endIndex) { + tickIndices.push(endIndex); + } + + const xAxis = d3.axisBottom(xScale) + .tickValues(tickIndices) + .tickFormat(i => { + const date = uniqueTimes[i]; + return chartUtils.format.date(date, { output: "%Y" }).text; // 只显示年份 + }) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", "16px") + .style("text-anchor", "middle") + .style("fill", "#1E2C32"); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(maxValue <= 1 ? 5 : 6) + .tickFormat(d => chartUtils.format.autoText(d)) // 只显示值，不显示单位 + .tickSize(-chartWidth) + .tickPadding(15); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain") + .attr("stroke", "#1E2C32") + .attr("stroke-width", 1.2)) + .call(g => g.selectAll(".tick line") + .attr("stroke", "#D9DED5") + .attr("stroke-dasharray", "4 4") + .attr("stroke-width", 1)) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", "15px") + .style("text-anchor", "end") // 右对齐 + .attr("dx", "-0.5em") // 向左微调 + .style("fill", "#1E2C32"); + + // 如果存在Y轴单位，则在Y轴顶端显示 + if (yUnit) { + chartGroup.append("text") + .attr("class", "y-axis-unit") + .attr("x", 10) + .attr("y", -20) + .style("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `calc(${typography.label.font_size} * 1.5)`) // 字体大小增大1.5倍 + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text("(" + yUnit + ")"); + } + + // 按组分别添加直方图柱子 + const barsLayer = chartGroup.append("g") + .attr("class", "histogram06-bars") + .attr("clip-path", "url(#histogram06-plot-clip)"); + + groupsToUse.forEach((group, groupIndex) => { + // 过滤当前组的数据 + const groupData = processedData.filter(d => d.group === group); + + // 添加当前组的柱子 + barsLayer.selectAll(`.bar-${groupIndex}`) + .data(groupData) + .enter() + .append("rect") + .attr("class", `bar bar-${groupIndex}`) + .attr("data-chart-mark", "histogram-bar") + .attr("data-series", group) + .attr("data-x", d => chartUtils.format.date(d.time, { output: "%Y" }).text) + .attr("data-value", d => d.value) + .attr("x", d => xScale(d.order) - binWidth * 0.66 + (groupIndex * binWidth * 0.95)) + .attr("y", d => yScale(d.value)) + .attr("rx", 3) + .attr("ry", 3) + .attr("opacity", 0.94) + .attr("width", binWidth * 0.82) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", groupColors[group]) // 使用组对应的颜色 + .attr("stroke", "none"); // 无边框 + }); + + chartGroup.append("line") + .attr("class", "histogram06-x-baseline") + .attr("x1", 0) + .attr("x2", chartWidth) + .attr("y1", chartHeight) + .attr("y2", chartHeight) + .attr("stroke", "#1E2C32") + .attr("stroke-width", 1.2); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..1fa48971b60b3ef568808125620f8a5d08f1ce1d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_0.js @@ -0,0 +1,219 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_plain_chart_01", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 10000000]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..75617611dcb3f4bf18496ff86f4c65193926c0e0 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_01.js @@ -0,0 +1,489 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "overlay", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js创建简单的垂直条形图 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + xField = xChannel.key; + yField = yChannel.key; + + // 获取字段单位(如果存在) + if (xChannel.unit) { + xUnit = xChannel.unit; + } + + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField] // 确保y是数值类型 + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colorResolver.other("primary").value; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.1 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.1 })); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = measureTextWidth(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 10; // 标签开始的 Y 位置 (保持和原来一致) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加延伸到图标的柱子 + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.x)) + .attr("y", d => yScale(d.y)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.max(0, barBottomY - yScale(d.y))) + .attr("fill", d => { + if (variables.has_gradient) { + const safeCategory = typeof d.x === 'string' ? + d.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${sortedData.findIndex(item => item.x === d.x)}`; // 修正: 使用 findIndex 确保唯一性 + return `url(#gradient-${safeCategory})`; + } + return getColor(); + }) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const valueText = chartUtils.format.autoText(d.y) + (yUnit ? ` ${yUnit}` : ""); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = measureTextWidth(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", "#ffffff") // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加圆形图标 - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-circle") + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-circle") + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + // 添加圆形轮廓 + d3.select(this) + .append("circle") + .attr("r", iconRadius) // 使用变量 + .attr("fill", "none") // 无填充 + .attr("stroke", "#2D3748") // 更深灰色的描边 + .attr("stroke-width", 0.1); + + // 如果有该类别的图像 + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加圆形图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..3aee36ad5ee43f52fb710dfbbcd2cf7082c9f524 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_02.js @@ -0,0 +1,653 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart With Circle", + "chart_name": "vertical_bar_chart_02", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical", "temporal"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 12], [0, "inf"], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary"], + "supported_effects": ["radius_corner", "spacing", "shadow", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const chartData = (jsonData.data && jsonData.data.data) || []; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const sourceColors = jsonData.colors || {}; + const colorOther = sourceColors.other || {}; + + d3.select(containerSelector).html(""); + + const width = Number(variables.width) || 700; + const height = Number(variables.height) || 500; + const textColor = sourceColors.text_color || "#273044"; + const canvasColor = "#e8f6fb"; + const panelColor = "#ffffff"; + const inkColor = "#09284a"; + const mutedColor = "#56708b"; + const gridColor = "#b8cfdd"; + const barColor = "#1569b7"; + const barTopColor = "#61aee8"; + const circleColor = "#2f8f67"; + const circleFill = "#e6f6ee"; + const labelTypography = typography.label || {}; + const annotationTypography = typography.annotation || labelTypography; + const labelFamily = labelTypography.font_family || "Arial"; + const labelWeight = labelTypography.font_weight || "600"; + const valueFamily = annotationTypography.font_family || labelFamily; + const valueWeight = annotationTypography.font_weight || "600"; + const baseLabelSize = parseFloat(labelTypography.font_size) || 12; + const baseValueSize = parseFloat(annotationTypography.font_size) || 11; + + function rgba(color, opacity) { + try { + const c = d3.rgb(color); + return `rgba(${c.r}, ${c.g}, ${c.b}, ${opacity})`; + } catch (error) { + return `rgba(39, 48, 68, ${opacity})`; + } + } + + function firstColumnBy(predicate) { + return Array.from(dataColumns).find(predicate) || null; + } + + const xColumn = + firstColumnBy(col => col["role"] === "x") || + firstColumnBy(col => col.data_type === "temporal") || + firstColumnBy(col => col.data_type === "categorical") || + dataColumns[0] || + {}; + const yColumn = + firstColumnBy(col => col["role"] === "y") || + firstColumnBy(col => col.data_type === "numerical") || + dataColumns[1] || + {}; + const y2Column = + firstColumnBy(col => col["role"] === "y2") || + Array.from(dataColumns).find(col => col !== yColumn && col.data_type === "numerical") || + dataColumns[2] || + {}; + + const xField = xColumn.name || "category"; + const yField = yColumn.name || "value"; + const y2Field = y2Column.name || "secondary"; + const yUnit = yColumn.unit && yColumn.unit !== "none" ? yColumn.unit : ""; + const y2Unit = y2Column.unit && y2Column.unit !== "none" ? y2Column.unit : ""; + + function parseTemporalSortValue(value) { + const text = String(value ?? "").trim(); + const year = text.match(/^(-?\d{4})$/); + if (year) return Number(year[1]) * 10000; + const date = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (date) return Number(date[1]) * 10000 + Number(date[2]) * 100 + Number(date[3] || 1); + const seasonOrder = { winter: 1, spring: 2, summer: 3, fall: 4, autumn: 4 }; + let season = text.match(/^(winter|spring|summer|fall|autumn)\s+(-?\d{4})$/i); + if (season) return Number(season[2]) * 10 + seasonOrder[season[1].toLowerCase()]; + season = text.match(/^(-?\d{4})\s+(winter|spring|summer|fall|autumn)$/i); + if (season) return Number(season[1]) * 10 + seasonOrder[season[2].toLowerCase()]; + return NaN; + } + + function formatNumber(value) { + const numericValue = Number(value); + if (!Number.isFinite(numericValue)) return String(value ?? ""); + const absValue = Math.abs(numericValue); + if (absValue >= 1000000000) return `${d3.format(".3~g")(numericValue / 1000000000)}B`; + if (absValue >= 1000000) return `${d3.format(".3~g")(numericValue / 1000000)}M`; + if (absValue >= 1000) return `${d3.format(".3~g")(numericValue / 1000)}K`; + return d3.format(",.4~g")(numericValue); + } + + function formatWithUnit(value, unit, includeLongUnit = true) { + const formatted = formatNumber(value); + if (!unit) return formatted; + if (unit === "$") return `$${formatted}`; + if (unit === "€") return `€${formatted}`; + if (unit === "%") return `${formatted}%`; + return includeLongUnit ? `${formatted} ${unit}` : formatted; + } + + const rows = chartData.map((row, index) => ({ + ...row, + __index: index, + __category: String(row[xField] ?? ""), + __y: Number(row[yField]), + __y2: Number(row[y2Field]) + })).filter(row => row.__category && Number.isFinite(row.__y) && Number.isFinite(row.__y2)); + + if (!rows.length) return; + + const isTemporal = + xColumn.data_type === "temporal" || + rows.every(row => Number.isFinite(parseTemporalSortValue(row.__category))); + + rows.sort((a, b) => { + if (isTemporal) { + const byTime = parseTemporalSortValue(a.__category) - parseTemporalSortValue(b.__category); + if (Number.isFinite(byTime) && byTime !== 0) return byTime; + } + const byValue = b.__y - a.__y; + if (byValue !== 0) return byValue; + return a.__category.localeCompare(b.__category); + }); + + const prefixCounts = new Map(); + rows.forEach(row => { + const match = row.__category.match(/^(.+?)\s*\(([^)]+)\)$/); + if (match) { + const prefix = match[1].trim(); + prefixCounts.set(prefix, (prefixCounts.get(prefix) || 0) + 1); + } + }); + const usedDisplayLabels = new Set(); + rows.forEach((row, index) => { + const match = row.__category.match(/^(.+?)\s*\(([^)]+)\)$/); + let displayLabel = row.__category; + if (match && prefixCounts.get(match[1].trim()) > 1) { + displayLabel = match[2].trim(); + } + if (usedDisplayLabels.has(displayLabel)) { + displayLabel = row.__category; + } + usedDisplayLabels.add(displayLabel); + row.__displayLabel = displayLabel; + row.__rank = index + 1; + }); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg"); + + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", "barCircleShadow") + .attr("x", "-12%") + .attr("y", "-12%") + .attr("width", "124%") + .attr("height", "130%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 2.5) + .attr("flood-color", "#536a7c") + .attr("flood-opacity", 0.14); + const gradient = defs.append("linearGradient") + .attr("id", "barGradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + gradient.append("stop").attr("offset", "0%").attr("stop-color", barTopColor); + gradient.append("stop").attr("offset", "100%").attr("stop-color", barColor); + + const measure = svg.append("g").attr("visibility", "hidden"); + function measureLabelText(text, fontSize, family, weight) { + const node = measure.append("text") + .style("font-family", family) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight) + .text(String(text ?? "")) + .node(); + const widthEstimate = node ? node.textContent.length * 7 : 0; + measure.selectAll("text").remove(); + return Math.max(widthEstimate || 0, String(text ?? "").length * fontSize * 0.52); + } + + function appendFittedText(parent, text, options) { + const { + x, + y, + maxWidth, + fontSize, + minFontSize = 7, + family = labelFamily, + weight = labelWeight, + fill = textColor, + anchor = "start", + baseline = "middle", + className = "label" + } = options; + let size = fontSize; + while (size > minFontSize && measureLabelText(text, size, family, weight) > maxWidth) { + size -= 0.5; + } + const node = parent.append("text") + .attr("class", className) + .attr("x", x) + .attr("y", y) + .attr("text-anchor", anchor) + .attr("dominant-baseline", baseline) + .style("font-family", family) + .style("font-size", `${size}px`) + .style("font-weight", weight) + .style("fill", fill) + .text(String(text ?? "")); + if (measureLabelText(text, size, family, weight) > maxWidth) { + node.attr("textLength", maxWidth).attr("lengthAdjust", "spacingAndGlyphs"); + } + return node; + } + + const cardX = 18; + const cardY = 18; + const cardWidth = width - cardX * 2; + const cardHeight = height - cardY * 2; + const headerHeight = 54; + const footerHeight = 62; + const sidebarWidth = Math.max(190, Math.min(250, width * 0.32)); + const margin = { + top: cardY + headerHeight + 8, + right: width - (cardX + cardWidth - sidebarWidth - 26), + bottom: height - (cardY + cardHeight - footerHeight), + left: cardX + 54 + }; + const innerWidth = Math.max(220, width - margin.left - margin.right); + const innerHeight = Math.max(240, height - margin.top - margin.bottom); + + svg.append("rect") + .attr("class", "chart-canvas") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", canvasColor); + + svg.append("rect") + .attr("class", "chart-style-panel") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardWidth) + .attr("height", cardHeight) + .attr("rx", 10) + .attr("ry", 10) + .attr("fill", panelColor) + .attr("stroke", "#cfe1ec") + .attr("stroke-width", 1.1) + .attr("filter", "url(#barCircleShadow)"); + + const metricCardWidth = Math.min(cardWidth - sidebarWidth - 52, Math.max(228, innerWidth * 0.58)); + const metricCard = svg.append("g") + .attr("class", "metric-card") + .attr("transform", `translate(${cardX + 22}, ${cardY + 17})`); + metricCard.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", metricCardWidth) + .attr("height", 34) + .attr("rx", 7) + .attr("ry", 7) + .attr("fill", "#f5fbff") + .attr("stroke", "#cbe0ef") + .attr("stroke-width", 1); + metricCard.append("circle") + .attr("cx", 18) + .attr("cy", 17) + .attr("r", 8) + .attr("fill", barColor); + appendFittedText(metricCard, yUnit ? `${yField} (${yUnit})` : yField, { + x: 34, + y: 17, + maxWidth: metricCardWidth - 46, + fontSize: Math.max(9, Math.min(baseLabelSize, 12)), + minFontSize: 7.5, + family: labelFamily, + weight: "700", + fill: inkColor, + className: "metric-card-label" + }); + + const chart = svg.append("g") + .attr("class", "bar-circle-plot") + .attr("data-count", rows.length) + .attr("data-sort-mode", isTemporal ? "temporal" : "value_desc") + .attr("data-y-field", yField) + .attr("data-y2-field", y2Field) + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + const yMin = Math.min(0, d3.min(rows, row => row.__y) || 0); + const yMax = Math.max(0, d3.max(rows, row => row.__y) || 0); + const ySpan = Math.max(1, yMax - yMin); + const yScale = d3.scaleLinear() + .domain([yMin, yMax + ySpan * 0.24]) + .nice(5) + .range([innerHeight, 0]); + const xScale = d3.scaleBand() + .domain(rows.map(row => String(row.__rank))) + .range([0, innerWidth]) + .padding(variables.has_spacing === false ? 0.16 : 0.34); + + const y2AbsMax = Math.max(1, d3.max(rows, row => Math.abs(row.__y2)) || 1); + const y2AbsMin = Math.min(y2AbsMax, d3.min(rows, row => Math.abs(row.__y2)) || 0); + const maxCircleRadius = Math.max(7, Math.min(18, xScale.bandwidth() * 0.42)); + const minCircleRadius = Math.max(4, Math.min(maxCircleRadius - 1, maxCircleRadius * 0.45)); + const circleRadiusScale = d3.scaleSqrt() + .domain(y2AbsMax === y2AbsMin ? [0, y2AbsMax] : [y2AbsMin, y2AbsMax]) + .range(y2AbsMax === y2AbsMin ? [maxCircleRadius * 0.72, maxCircleRadius * 0.72] : [minCircleRadius, maxCircleRadius]); + + const yTicks = yScale.ticks(5).filter((tick, index, arr) => index === 0 || tick !== arr[index - 1]); + yTicks.forEach(tick => { + const y = yScale(tick); + chart.append("line") + .attr("class", "gridline") + .attr("data-value", tick) + .attr("x1", 0) + .attr("x2", innerWidth) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", tick === 0 ? rgba(inkColor, 0.38) : rgba(gridColor, 0.88)) + .attr("stroke-width", tick === 0 ? 1.25 : 1); + chart.append("text") + .attr("class", "axis-tick") + .attr("data-value", tick) + .attr("x", -8) + .attr("y", y) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .style("font-family", valueFamily) + .style("font-size", `${Math.max(8, baseValueSize * 0.78)}px`) + .style("font-weight", valueWeight) + .style("fill", rgba(inkColor, 0.72)) + .text(formatWithUnit(tick, yUnit, false)); + }); + + chart.append("line") + .attr("class", "axis-line") + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", rgba(inkColor, 0.42)) + .attr("stroke-width", 1.2); + chart.append("line") + .attr("class", "axis-line baseline") + .attr("x1", 0) + .attr("x2", innerWidth) + .attr("y1", yScale(0)) + .attr("y2", yScale(0)) + .attr("stroke", rgba(inkColor, 0.44)) + .attr("stroke-width", 1.3); + + rows.forEach(row => { + const key = String(row.__rank); + const x = xScale(key); + const bandwidth = xScale.bandwidth(); + const zeroY = yScale(0); + const valueY = yScale(row.__y); + const barY = Math.min(valueY, zeroY); + const barHeight = Math.abs(zeroY - valueY); + const circleRadius = circleRadiusScale(Math.abs(row.__y2)); + const circleY = Math.max(circleRadius + 2, barY - circleRadius - 5); + const centerX = x + bandwidth / 2; + + chart.append("rect") + .attr("class", "bar mark") + .attr("data-category", row.__category) + .attr("data-display-label", row.__displayLabel) + .attr("data-value", row.__y) + .attr("data-y2-value", row.__y2) + .attr("data-rank", row.__rank) + .attr("x", x) + .attr("y", barY) + .attr("width", bandwidth) + .attr("height", Math.max(1, barHeight)) + .attr("rx", Math.min(7, bandwidth / 4)) + .attr("ry", Math.min(7, bandwidth / 4)) + .attr("fill", "url(#barGradient)") + .attr("stroke", "#0d5598") + .attr("stroke-opacity", 0.18) + .attr("stroke-width", 0.8); + + chart.append("circle") + .attr("class", "circle-mark mark") + .attr("data-category", row.__category) + .attr("data-display-label", row.__displayLabel) + .attr("data-y-value", row.__y) + .attr("data-value", row.__y2) + .attr("data-rank", row.__rank) + .attr("cx", centerX) + .attr("cy", circleY) + .attr("r", circleRadius) + .attr("fill", circleFill) + .attr("stroke", circleColor) + .attr("stroke-width", 1.8) + .style("filter", "url(#barCircleShadow)"); + + appendFittedText(chart, formatWithUnit(row.__y2, y2Unit, false), { + x: centerX, + y: circleY, + maxWidth: Math.max(10, circleRadius * 1.55), + fontSize: Math.max(7, Math.min(baseValueSize * 0.78, circleRadius * 0.62)), + minFontSize: 5.8, + family: valueFamily, + weight: "800", + fill: circleColor, + anchor: "middle", + className: "circle-inner-value value" + }) + .attr("data-category", row.__category) + .attr("data-value", row.__y2) + .attr("data-rank", row.__rank); + + chart.append("text") + .attr("class", "x-label label") + .attr("data-category", row.__category) + .attr("data-display-label", row.__displayLabel) + .attr("data-rank", row.__rank) + .attr("x", centerX) + .attr("y", innerHeight + 18) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", valueFamily) + .style("font-size", `${Math.max(8, Math.min(11, bandwidth * 0.45))}px`) + .style("font-weight", "700") + .style("fill", inkColor) + .text(row.__rank); + }); + + const legendX = margin.left + innerWidth + 22; + const legendY = cardY + 24; + const sidebarInnerWidth = width - legendX - cardX - 18; + svg.append("rect") + .attr("class", "legend-style-panel") + .attr("x", legendX - 12) + .attr("y", cardY + 16) + .attr("width", sidebarInnerWidth + 24) + .attr("height", cardHeight - 32) + .attr("rx", 9) + .attr("ry", 9) + .attr("fill", "#f6fbff") + .attr("stroke", "#d2e5f2") + .attr("stroke-width", 1); + const legend = svg.append("g") + .attr("class", "metric-legend") + .attr("transform", `translate(${legendX}, ${legendY})`); + + function metricLabel(field, unit) { + return unit ? `${field} (${unit})` : field; + } + + const metricRows = [ + { label: `Bars: ${metricLabel(yField, yUnit)}`, color: barColor, className: "bar-legend label" }, + { label: `Circles: ${metricLabel(y2Field, y2Unit)}`, color: circleColor, className: "circle-legend label" } + ]; + metricRows.forEach((metric, index) => { + const item = legend.append("g").attr("transform", `translate(0, ${index * 20})`); + item.append("rect") + .attr("class", "legend-swatch") + .attr("x", 0) + .attr("y", -7) + .attr("width", 12) + .attr("height", 12) + .attr("rx", 2) + .attr("fill", metric.color); + appendFittedText(item, metric.label, { + x: 17, + y: -1, + maxWidth: Math.max(90, sidebarInnerWidth - 18), + fontSize: Math.max(8, baseLabelSize * 0.78), + minFontSize: 7, + className: metric.className + }); + }); + + const tableY = legendY + 52; + const table = svg.append("g") + .attr("class", "category-legend") + .attr("transform", `translate(${legendX}, ${tableY})`); + table.append("text") + .attr("class", "label") + .attr("x", 0) + .attr("y", 0) + .attr("dominant-baseline", "middle") + .style("font-family", labelFamily) + .style("font-size", `${Math.max(9, baseLabelSize * 0.82)}px`) + .style("font-weight", "700") + .style("fill", inkColor) + .text("Items"); + + const rowGap = Math.max(14, Math.min(28, (height - tableY - 26) / rows.length)); + const rowFontSize = Math.max(6.8, Math.min(baseLabelSize * 0.76, rowGap * 0.48)); + const valueFontSize = Math.max(6.8, Math.min(baseValueSize * 0.74, rowGap * 0.42)); + const yValueWidth = Math.max(38, Math.min(60, d3.max(rows, row => measureLabelText(formatWithUnit(row.__y, yUnit, false), valueFontSize, valueFamily, valueWeight)) || 38)); + const y2ValueWidth = Math.max(38, Math.min(60, d3.max(rows, row => measureLabelText(formatWithUnit(row.__y2, y2Unit, false), valueFontSize, valueFamily, valueWeight)) || 38)); + const labelWidth = Math.max(56, sidebarInnerWidth - yValueWidth - y2ValueWidth - 46); + + rows.forEach((row, index) => { + const item = table.append("g") + .attr("class", "category-row") + .attr("data-category", row.__category) + .attr("data-display-label", row.__displayLabel) + .attr("data-y-value", row.__y) + .attr("data-y2-value", row.__y2) + .attr("data-rank", row.__rank) + .attr("transform", `translate(0, ${18 + index * rowGap})`); + item.append("text") + .attr("class", "x-label label") + .attr("data-category", row.__category) + .attr("data-rank", row.__rank) + .attr("x", 0) + .attr("y", 0) + .attr("dominant-baseline", "middle") + .style("font-family", valueFamily) + .style("font-size", `${Math.max(8, rowFontSize)}px`) + .style("font-weight", "700") + .style("fill", inkColor) + .text(row.__rank); + appendFittedText(item, row.__displayLabel, { + x: 20, + y: 0, + maxWidth: labelWidth, + fontSize: rowFontSize, + minFontSize: 6.8, + family: labelFamily, + weight: labelWeight, + fill: inkColor, + className: "category-label label" + }) + .attr("data-category", row.__category) + .attr("data-display-label", row.__displayLabel) + .attr("data-rank", row.__rank); + item.append("text") + .attr("class", "bar-value value") + .attr("data-category", row.__category) + .attr("data-value", row.__y) + .attr("data-rank", row.__rank) + .attr("x", 24 + labelWidth + yValueWidth) + .attr("y", 0) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .style("font-family", valueFamily) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", valueWeight) + .style("fill", rgba(barColor, 0.88)) + .text(formatWithUnit(row.__y, yUnit, false)); + item.append("text") + .attr("class", "circle-value value") + .attr("data-category", row.__category) + .attr("data-value", row.__y2) + .attr("data-rank", row.__rank) + .attr("x", sidebarInnerWidth) + .attr("y", 0) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .style("font-family", valueFamily) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", valueWeight) + .style("fill", rgba(circleColor, 0.88)) + .text(formatWithUnit(row.__y2, y2Unit, false)); + }); + + const noteY = cardY + cardHeight - 31; + svg.append("rect") + .attr("class", "scale-note") + .attr("x", cardX + 20) + .attr("y", noteY) + .attr("width", cardWidth - sidebarWidth - 54) + .attr("height", 20) + .attr("rx", 6) + .attr("ry", 6) + .attr("fill", "#eef8fd") + .attr("stroke", "#cbe0ee") + .attr("stroke-width", 1); + appendFittedText(svg, `${metricLabel(yField, yUnit)} bars; ${metricLabel(y2Field, y2Unit)} circles`, { + x: cardX + 32, + y: noteY + 10, + maxWidth: cardWidth - sidebarWidth - 78, + fontSize: Math.max(7.5, baseValueSize * 0.72), + minFontSize: 6.5, + family: valueFamily, + weight: valueWeight, + fill: mutedColor, + className: "scale-note-label" + }); + + measure.remove(); + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_03.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_03.js new file mode 100644 index 0000000000000000000000000000000000000000..6b6b826e722b4d7cd4e9bf8761ff76d3e2d5b1e2 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_03.js @@ -0,0 +1,547 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart With Circle", + "chart_name": "vertical_bar_chart_03", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [["categorical"], ["numerical"], ["numerical"]], + "required_fields_range": [[2, 12], ["-inf", "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直条形图与比例圆复合图表实现 - 使用D3.js vertical_bar_proportional_circle_area_chart_01 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#008080", secondary: "#FF0000" }, // 默认颜色: 蓝绿色和红色 + available_colors: ["#FFBF00"] // 默认: 黄色 + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // *** 添加: 创建用于文本测量的Canvas Context *** + const canvas = document.createElement('canvas'); + const context = canvas.getContext('2d'); + + // *** 修改: 提前提取字段名和单位 *** + const dimensionField = chartUtils.schema.channel(jsonData, "x").key ; + const valueField = chartUtils.schema.channel(jsonData, "y").key ; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key ; + + let valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit || ""; // 默认为百分号 + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit || ""; + + // 确保单位是字符串 + valueUnit = valueUnit || ""; + valueUnit2 = valueUnit2 || ""; + + // 数值单位规范 + // 添加数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距 - 需要足够空间给标签和条形图 + const margin = { top: 90, right: 50, bottom: 60, left: 50 }; // 增加底部边距给X轴标签和图标 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 定义中间灰色区域和标签区域的高度 + const centralBandHeight = innerHeight * 0.20; // 中间区域占20%高度 + + const barAreaHeight = innerHeight - centralBandHeight ; // 上下条形图的总可用高度 + // *** 修改: 按正负最大值比例分配高度 *** + const maxPositiveY = d3.max(chartData, d => Math.max(0, +d[valueField])) || 0; + const maxNegativeY = Math.abs(d3.min(chartData, d => Math.min(0, +d[valueField])) || 0); + const totalMagnitudeRange = maxPositiveY + maxNegativeY; + + let topBarAreaHeight; + let bottomBarAreaHeight; + + if (totalMagnitudeRange > 0) { + topBarAreaHeight = barAreaHeight * (maxPositiveY / totalMagnitudeRange); + bottomBarAreaHeight = barAreaHeight * (maxNegativeY / totalMagnitudeRange); + } else { + // 如果所有值都为0，则平分高度 + topBarAreaHeight = barAreaHeight / 2; + bottomBarAreaHeight = barAreaHeight / 2; + } + + // 计算中间灰色区域的Y坐标 (现在依赖于 topBarAreaHeight) + const centralBandTopY = margin.top + topBarAreaHeight; + const centralBandBottomY = centralBandTopY + centralBandHeight; + + // 定义图标和标签尺寸 + const iconSize = 20; + const iconMargin = 3; // 图标和标签之间的距离 (减小) + const labelMargin = 3; // 圆圈和下方标签的距离 (减小) + const circlePadding = 5; // 圆圈与其标签之间的内边距 + + // *** 修改: 预定义基础字体大小 *** + const baseFontSizeLabel = parseFloat(typography.label.font_size) || 14; + const baseFontSizeAnnotation = parseFloat(typography.annotation.font_size) || 12; + const minFontSize = 8; + + // *** 修改: 为中央区域内的元素计算Y坐标 *** + const bandTopPadding = 5; + const iconY = centralBandTopY + bandTopPadding + iconSize / 2; + const dimensionLabelY = iconY + iconSize / 2 + iconMargin + baseFontSizeLabel / 2; // 在图标下方 + // 剩余空间给圆圈 + const circleAreaTopY = dimensionLabelY + baseFontSizeLabel / 2 + labelMargin; + const circleAreaHeight = centralBandBottomY - circleAreaTopY - bandTopPadding; + const circleY = circleAreaTopY + circleAreaHeight / 2; + // 最大半径是可用高度的90%的一半 + const maxCircleRadiusAvailableBasedOnHeight = Math.max(0, (circleAreaHeight * 0.9) / 2); + // *** 添加: 限制最大半径不超过bar宽度的一半 *** + const maxRadiusFromBarWidth = innerWidth / 2; + const maxCircleRadiusAvailable = Math.min(maxCircleRadiusAvailableBasedOnHeight, maxRadiusFromBarWidth); + + // ---------- 4. 数据处理 ---------- + + // 转换数值类型 + chartData.forEach(d => { + d[valueField] = +d[valueField]; + d[valueField2] = +d[valueField2]; + }); + + // *** 修改: 按 y 值 (valueField) 降序排序数据 *** + chartData.sort((a, b) => +b[valueField] - +a[valueField]); + + // 获取排序后的维度列表 + const dimensions = chartData.map(d => d[dimensionField]); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 (类别) + const xScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerWidth]) + .padding(0.2); // 柱子之间的间距 + + // *** 恢复: 使用独立的比例尺，但范围基于比例计算的高度 *** + // 正值比例尺 + const yScalePositive = d3.scaleLinear() + .domain([0, maxPositiveY === 0 ? 1 : maxPositiveY]) // 处理max为0的情况 + .range([centralBandTopY, centralBandTopY - topBarAreaHeight]); + + // 负值比例尺 + const yScaleNegative = d3.scaleLinear() + .domain([0, maxNegativeY === 0 ? 1 : maxNegativeY]) // 处理max为0的情况 + .range([centralBandBottomY, centralBandBottomY + bottomBarAreaHeight]); + + // 圆形面积比例尺 (销售额 - y2) + const maxValue2 = d3.max(chartData, d => +d[valueField2]) || 0; + const minRadius = 2; // 最小半径，防止圆点太小看不见 + // *** 修改: 最大半径基于圆圈可用空间 *** + const maxRadius = Math.max(minRadius, maxCircleRadiusAvailable); + + const radiusScale = d3.scaleSqrt() // 平方根比例尺保证面积正比 + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); // 半径范围 + + // *** 修改: 文本大小和换行辅助函数 *** + // 计算字体大小的函数，确保文本在指定宽度内 + const calculateFontSize = (text, maxWidth, baseSize = 14) => { + // 检查参数是否有效 + if (!text || typeof text !== 'string' || !maxWidth || maxWidth <= 0 || !baseSize || baseSize <= 0) { + return Math.max(10, baseSize || 14); // 返回一个合理的默认值或最小尺寸 + } + + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + + // 否则，按比例缩小字体大小，确保不小于10 + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + // 文本换行辅助函数 (添加 alignment 参数) + function wrapText(textElement, text, width, x, y, fontSize, fontWeight, fontFamily, alignment = 'middle') { + textElement.each(function() { + const text_element = d3.select(this); + const words = text.split(/\s+/).reverse(); // 按空格分割单词 + let word; + let lineNumber = 0; + const lineHeight = 1.3; // 增加行高，避免行间重叠 + + text_element.text(null); // 清空现有文本 + + let tspans = []; // 存储最终要渲染的行 + + // 优先按单词换行 + if (words.length > 1) { + let currentLine = []; + while (word = words.pop()) { + currentLine.push(word); + const currentText = currentLine.join(" "); + // 使用getTextWidth函数计算宽度 + const currentWidth = measureTextWidth(currentText, fontSize, fontWeight, fontFamily); + + if (currentWidth > width && currentLine.length > 1) { + currentLine.pop(); // 回退一个词 + tspans.push(currentLine.join(" ")); // 添加完成的行 + currentLine = [word]; // 新行以当前词开始 + lineNumber++; + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } else { // 如果没有空格或只有一个词，则按字符换行 + const chars = text.split(''); + let currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const nextLine = currentLine + chars[i]; + const currentWidth = measureTextWidth(nextLine, fontSize, fontWeight, fontFamily); + + if (currentWidth > width && currentLine.length > 0) { // 如果加了新字符就超长了，并且当前行不为空 + tspans.push(currentLine); // 添加当前行 + currentLine = chars[i]; // 新行从这个字符开始 + lineNumber++; + } else { + currentLine = nextLine; // 没超长就继续加字符 + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } + + // 计算总行数 + const totalLines = tspans.length; + let startDy = 0; + + // 根据对齐方式计算起始偏移 + if (alignment === 'middle') { + // 垂直居中：向上移动半行*(总行数-1) + startDy = -((totalLines - 1) * lineHeight / 2); + } else if (alignment === 'bottom') { + // 底部对齐：计算总高度，向上移动 总高度 - 单行高度 + const totalHeightEm = totalLines * lineHeight; + startDy = -(totalHeightEm - lineHeight); // 将底部对齐到原始y + } + // 如果是 'top' 对齐，startDy 保持为 0，即第一行基线在原始y位置 + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + text_element.append("tspan") + .attr("x", x) // x坐标固定 + .attr("dy", (i === 0 ? startDy : lineHeight) + "em") // 第一行应用起始偏移，后续行应用行高 + .text(lineText); + }); + + // 保存行数以供外部使用 + text_element.attr("data-lines", totalLines); + }); + } + + // *** 修改: 字体大小计算函数 -> 精确测量 *** + function measureTextWidth(text, fontSize, fontWeight, fontFamily) { + return chartUtils.text.measure(null, text, { fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight }).width; + } + + let minDimensionLabelRatio = 1.0; + let minCircleLabelRatio = 1.0; + let minBarLabelRatio = 1.0; + + const maxDimensionLabelWidth = xScale.bandwidth() * 0.95; + const maxCircleLabelWidth = xScale.bandwidth() * 1.03; // 圆圈标签也用这个宽度限制 + const maxBarLabelWidth = xScale.bandwidth(); // 条形图标签限制在条形宽度内 + + chartData.forEach(d => { + // 维度标签 + const dimensionText = String(d[dimensionField]); // Ensure string + // *** 修改: 使用精确宽度计算 *** + let currentWidth = measureTextWidth(dimensionText, baseFontSizeLabel, typography.label.font_weight, typography.label.font_family); + if (currentWidth > maxDimensionLabelWidth) { + minDimensionLabelRatio = Math.min(minDimensionLabelRatio, maxDimensionLabelWidth / currentWidth); + } + + // 圆圈标签 + const circleText = chartUtils.format.autoText(+d[valueField2]) + (valueUnit2 ? ` ${valueUnit2}` : ''); // *** 修改: 单位放在后面 *** + currentWidth = measureTextWidth(circleText, baseFontSizeLabel, typography.label.font_weight, typography.label.font_family); + // *** 修改: 圆圈标签宽度只受bar宽度限制 *** + const effectiveMaxCircleWidth = maxCircleLabelWidth; // Remove constraint from maxAllowedCircleWidth + if (currentWidth > effectiveMaxCircleWidth) { + minCircleLabelRatio = Math.min(minCircleLabelRatio, effectiveMaxCircleWidth / currentWidth); + } + + // 条形图标签 + const barValue = d[valueField]; + const barText = (barValue > 0 ? "+" : "") + chartUtils.format.autoText(barValue) + (valueUnit ? ` ${valueUnit}` : ''); + // *** 修改: 使用精确宽度计算 *** + currentWidth = measureTextWidth(barText, baseFontSizeAnnotation, typography.annotation.font_weight, typography.annotation.font_family); + if (currentWidth > maxBarLabelWidth) { + minBarLabelRatio = Math.min(minBarLabelRatio, maxBarLabelWidth / currentWidth); + } + }); + + // 计算最终字体大小 (应用最小比例并限制最小值) + const finalDimensionFontSize = Math.max(minFontSize, baseFontSizeLabel * minDimensionLabelRatio); + const finalCircleFontSize = Math.max(minFontSize, baseFontSizeLabel * minCircleLabelRatio); + const finalBarFontSize = Math.max(minFontSize, baseFontSizeAnnotation * minBarLabelRatio); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") // 保持宽高比 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 7. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, 0)`); // Y方向不移动，因为Y坐标已包含margin.top + const positiveColor = colorResolver.other("primary", { fallback: "#008080" }).value; + const negativeColor = colorResolver.other("secondary", { fallback: "#FF0000" }).value; + const circleLegendColor = colorResolver.available(0, { fallback: "#FFBF00" }).value; + const legendSquareSize = 12; + const legendCircleRadius = 6; + const legendY = margin.top - 30; + const legendItemPadding = 5; + const legendPadding = 10; + const legendFontSize = parseFloat(typography.annotation.font_size) || 12; + const legendFontFamily = typography.annotation.font_family || typography.label.font_family; + const legendFontWeight = typography.annotation.font_weight || 400; + const yName = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).rawLabel || valueField; + const y2Name = chartUtils.schema.channel(jsonData, "y2", { fallbackIndex: 2 }).rawLabel || valueField2; + chartUtils.legend.segmentsCentered(svg, [ + { type: "rect", size: legendSquareSize, color: positiveColor }, + { type: "rect", size: legendSquareSize, color: negativeColor }, + { type: "text", label: yName }, + { type: "circle", size: legendCircleRadius * 2, radius: legendCircleRadius, color: circleLegendColor }, + { type: "text", label: y2Name }, + ], { + centerX: margin.left + innerWidth / 2, + y: legendY, + itemGap: legendItemPadding, + sectionGap: legendPadding, + fontSize: legendFontSize, + fontFamily: legendFontFamily, + fontWeight: legendFontWeight, + textColor: colorResolver.text({ fallback: "#000000" }).value, + }); + // ---------- 8. 绘制中间灰色矩形区域 ---------- + + // *** 修改: 使用 path 绘制带半圆结束的灰色区域 *** + const bandRadius = centralBandHeight / 2; + g.append("path") + // *** 修改: 调整 d 属性使半圆在 0 和 innerWidth 外侧绘制 *** + .attr("d", ` + M ${0},${centralBandTopY} + L ${innerWidth},${centralBandTopY} + A ${bandRadius},${bandRadius} 0 0 1 ${innerWidth},${centralBandBottomY} + L ${0},${centralBandBottomY} + A ${bandRadius},${bandRadius} 0 0 1 ${0},${centralBandTopY} + Z + `) + .attr("class","background") + .attr("fill", "#f0f0f0"); // 浅灰色背景 + + // ---------- 9. 绘制图表元素 (循环处理每个数据点) ---------- + + // 首先创建所有维度标签，确定最大高度 + const dimensionLabels = []; + let maxLabelHeight = 0; + + chartData.forEach((d, i) => { + const x = xScale(d[dimensionField]); // 获取当前类别的X坐标 + const barWidth = xScale.bandwidth(); // 获取条形的宽度 + const centerX = x + barWidth / 2; // 当前类别的中心X坐标 + + // 添加维度标签文字 (先仅计算高度，不添加到DOM) + const labelInfo = { + x: centerX, + y: dimensionLabelY, + text: d[dimensionField], + width: maxDimensionLabelWidth + }; + + // 创建一个临时文本元素来计算行数 + const tempText = g.append("text") + .attr("x", centerX) + .attr("y", dimensionLabelY) + .attr("text-anchor", "middle") + .attr("class", "temp-dimension-label") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimensionFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", "none") // 不可见 + .call(wrapText, d[dimensionField], maxDimensionLabelWidth, centerX, dimensionLabelY, + finalDimensionFontSize, typography.label.font_weight, typography.label.font_family, 'top'); + + // 获取行数并计算高度 + const lineCount = parseInt(tempText.attr("data-lines") || "1"); + const labelHeight = lineCount * finalDimensionFontSize * 1.3; // 使用增加的行高计算 + + // 保存标签信息和高度 + labelInfo.lineCount = lineCount; + labelInfo.height = labelHeight; + dimensionLabels.push(labelInfo); + + // 更新最大高度 + maxLabelHeight = Math.max(maxLabelHeight, labelHeight); + + // 删除临时元素 + tempText.remove(); + }); + + // 计算统一的圆圈Y坐标 (基于最大标签高度) + const uniformCircleY = dimensionLabelY + maxLabelHeight + circlePadding +5; + + // 现在绘制所有元素 + chartData.forEach((d, i) => { + const x = xScale(d[dimensionField]); // 获取当前类别的X坐标 + const barWidth = xScale.bandwidth(); // 获取条形的宽度 + const centerX = x + barWidth / 2; // 当前类别的中心X坐标 + const labelInfo = dimensionLabels[i]; + + // 9.1 绘制垂直条形图 (y值) + const yValue = d[valueField]; + let barHeight, barY, barColor; + + // *** 修改: 使用 yScalePositive/yScaleNegative 计算高度和位置 *** + if (yValue > 0) { + barY = yScalePositive(yValue); + barHeight = centralBandTopY - barY; // 高度是 band 顶部 和 scale 输出的差值 + barColor = positiveColor; // 正值颜色 + } else if (yValue < 0) { + barY = centralBandBottomY; // 负值条从 band 底部开始 + const scaledY = yScaleNegative(Math.abs(yValue)); + barHeight = scaledY - barY; // 高度是 scale 输出 和 band 底部的差值 + barColor = negativeColor; // 负值颜色 + } else { + barHeight = 0; // 如果值为0，则不绘制条形 + barY = centralBandTopY; + barColor = "none"; + } + + // Ensure minimum height for tiny bars if needed, e.g., barHeight = Math.max(barHeight, 0.5); + if (barHeight < 0) barHeight = 0; // Prevent negative height due to floating point issues + + if (barHeight > 0) { // 只有高度大于0才绘制 + g.append("rect") + .attr("x", x) + .attr("width", barWidth) + .attr("fill", barColor) + .attr("y", barY) + .attr("height", barHeight); + + // 9.2 添加条形图数值标签 (y值) + const labelText = (yValue > 0 ? "+" : "") + chartUtils.format.autoText(yValue) + (valueUnit ? ` ${valueUnit}` : ''); + const labelY = (yValue >= 0) ? barY - 5 : barY + barHeight + (finalBarFontSize * 0.8); // 调整下方标签距离 + const textAnchor = "middle"; + + g.append("text") + .attr("x", centerX) + .attr("y", labelY) + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${finalBarFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .text(labelText); + } + + // 绘制维度标签 + const dimensionText = g.append("text") + .attr("x", centerX) + .attr("y", dimensionLabelY) + .attr("text-anchor", "middle") + .attr("class", "dimension-label") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimensionFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .call(wrapText, d[dimensionField], maxDimensionLabelWidth, centerX, dimensionLabelY, + finalDimensionFontSize, typography.label.font_weight, typography.label.font_family, 'top'); + + // 9.3 绘制圆圈 (y2值) - 使用统一的Y坐标 + const circleRadius = radiusScale(+d[valueField2]); + g.append("circle") + .attr("cx", centerX) + .attr("cy", uniformCircleY) + .attr("r", circleRadius) + .attr("fill", circleLegendColor) + .attr("opacity", 0.8); + + // 9.4 添加圆圈数值标签 (y2值) - 放置在圆心 + const circleLabelText = chartUtils.format.autoText(+d[valueField2]) + (valueUnit2 ? ` ${valueUnit2}` : ''); + + g.append("text") + .attr("x", centerX) + .attr("y", uniformCircleY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalCircleFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .text(circleLabelText); + + // 9.5 添加维度图标和标签 (x值) + // 添加图标 (如果存在) + if (images.field && images.field[d[dimensionField]]) { + g.append("image") + .attr("x", centerX - iconSize / 2) + .attr("y", iconY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", images.field[d[dimensionField]]) + .attr("preserveAspectRatio","xMidYMid meet"); + } + }); + + // ---------- 10. 返回SVG节点 ---------- + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_04.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_04.js new file mode 100644 index 0000000000000000000000000000000000000000..8642fde7b7afba6c7799a05c3c0fddf0747a08cf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_04.js @@ -0,0 +1,262 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_04", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 3D效果的偏移量 + const depth = 15; // 3D效果的深度 + + // 添加条形 + const bars = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + // 绘制柱子前面 + bars.append("rect") + .attr("class", "bar-front") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 2) + .attr("ry", 2); + + // 绘制柱子顶部 (3D效果) + bars.append("path") + .attr("class", "bar-top") + .attr("d", d => { + const topY = yScale(d.value); + const barWidth = xScale.bandwidth(); + return ` + M0,${topY} + L${depth},${topY - depth} + L${barWidth + depth},${topY - depth} + L${barWidth},${topY} + Z + `; + }) + .attr("fill", (d, i) => chartUtils.color.variant(colorScale(d, i), { mode: "brighter", amount: 0.2 })); + + // 绘制柱子右侧 (3D效果) + bars.append("path") + .attr("class", "bar-right") + .attr("d", d => { + const topY = yScale(d.value); + const bottomY = chartHeight; + const barWidth = xScale.bandwidth(); + return ` + M${barWidth},${topY} + L${barWidth + depth},${topY - depth} + L${barWidth + depth},${bottomY - depth} + L${barWidth},${bottomY} + Z + `; + }) + .attr("fill", (d, i) => chartUtils.color.variant(colorScale(d, i), { mode: "darker", amount: 0.2 })); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 10 - depth) // 调整标签位置以适应3D效果 + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_05.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_05.js new file mode 100644 index 0000000000000000000000000000000000000000..8f92511753753f8ef4bba8f9bbfc3858c5f3c14a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_05.js @@ -0,0 +1,289 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_05", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 3D效果的偏移量 + const depth = 15; // 3D效果的深度 + + // 添加条形 + const bars = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + // 绘制柱子前面 + bars.append("rect") + .attr("class", "bar-front") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 2) + .attr("ry", 2); + // 为每个柱子创建一个裁剪路径 + bars.each(function(d, i) { + const clipId = `clip-circle-${i}`; + d3.select(this).append("clipPath") + .attr("id", clipId) + .append("circle") + .attr("cx", xScale.bandwidth() / 2) + .attr("cy", d => yScale(d.value) + 10 + xScale.bandwidth() / 2) + .attr("r", xScale.bandwidth() / 2 * 0.9); + + // 添加圆形背景 + d3.select(this).append("circle") + .attr("cx", xScale.bandwidth() / 2) + .attr("cy", d => yScale(d.value) + 10 + xScale.bandwidth() / 2) + .attr("r", xScale.bandwidth() / 2 * 0.9) + .attr("fill", "#ffffff") + .attr("stroke", "#dddddd") + .attr("stroke-width", 1); + + // 添加图片并应用裁剪路径 + d3.select(this).append("image") + .attr("x", 0) + .attr("y", d => yScale(d.value) + 10) + .attr("width", xScale.bandwidth() * 0.9) + .attr("height", xScale.bandwidth() * 0.9) + .attr("clip-path", `url(#${clipId})`) + .attr("xlink:href", d => jsonData.images.field[d.category]); + }); + + // 绘制柱子顶部 (3D效果) + bars.append("path") + .attr("class", "bar-top") + .attr("d", d => { + const topY = yScale(d.value); + const barWidth = xScale.bandwidth(); + return ` + M0,${topY} + L${depth},${topY - depth} + L${barWidth + depth},${topY - depth} + L${barWidth},${topY} + Z + `; + }) + .attr("fill", (d, i) => chartUtils.color.variant(colorScale(d, i), { mode: "brighter", amount: 0.2 })); + + // 绘制柱子右侧 (3D效果) + bars.append("path") + .attr("class", "bar-right") + .attr("d", d => { + const topY = yScale(d.value); + const bottomY = chartHeight; + const barWidth = xScale.bandwidth(); + return ` + M${barWidth},${topY} + L${barWidth + depth},${topY - depth} + L${barWidth + depth},${bottomY - depth} + L${barWidth},${bottomY} + Z + `; + }) + .attr("fill", (d, i) => chartUtils.color.variant(colorScale(d, i), { mode: "darker", amount: 0.2 })); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 10 - depth) // 调整标签位置以适应3D效果 + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_06.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_06.js new file mode 100644 index 0000000000000000000000000000000000000000..fd5b086cd5f2c17493e34166da007d7745bbbb01 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_06.js @@ -0,0 +1,230 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_06", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("path") + .attr("class", "bar") + .attr("d", d => { + const x = xScale(d.category); + const y = yScale(d.value); + const width = xScale.bandwidth(); + const height = chartHeight - yScale(d.value); + const midX = x + width/2; + + // 按照参考路径的比例创建形状 + // 原始参考路径: M0,10 L10,10 C5.5,10 5.5,5 5,0 C4.5,5 4.5,10 0,10 z + return `M ${x} ${chartHeight} + L ${x + width} ${chartHeight} + C ${x + width * 0.55} ${chartHeight}, ${midX + width * 0.05} ${y + height * 0.5}, ${midX} ${y} + C ${midX - width * 0.05} ${y + height * 0.5}, ${x + width * 0.45} ${chartHeight}, ${x} ${chartHeight} + Z`; + }) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_07.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_07.js new file mode 100644 index 0000000000000000000000000000000000000000..4556549e8327e1dc9443f37591a5dd81c625424f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_07.js @@ -0,0 +1,481 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_07", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "overlay", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js创建简单的垂直条形图 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列 + + // 数值格式化函数 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + xField = xChannel.key; + yField = yChannel.key; + + // 获取字段单位(如果存在) + if (xChannel.unit) { + xUnit = xChannel.unit; + } + + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField] // 确保y是数值类型 + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colorResolver.other("primary").value; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.1 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.1 })); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = measureTextWidth(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 10; // 标签开始的 Y 位置 (靠近柱子底部) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加柱子 (修改高度) + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.x)) + .attr("y", d => yScale(d.y)) + .attr("width", xScale.bandwidth()) + // 修改: 使柱子高度只取决于数据值和yScale + .attr("height", d => Math.max(0, innerHeight - yScale(d.y))) + .attr("fill", d => { + if (variables.has_gradient) { + const safeCategory = typeof d.x === 'string' ? + d.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${sortedData.findIndex(item => item.x === d.x)}`; // 修正: 使用 findIndex 确保唯一性 + return `url(#gradient-${safeCategory})`; + } + return getColor(); + }) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const valueText = chartUtils.format.autoText(d.y) + (yUnit ? ` ${yUnit}` : ''); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = measureTextWidth(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加图标 (移除圆形) - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-group") // 修改类名以反映不再是圆形 + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-group") // 修改类名 + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_08.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_08.js new file mode 100644 index 0000000000000000000000000000000000000000..086d05a8e401cb60b8160b9fef61fcec8b14fe67 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_08.js @@ -0,0 +1,471 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_08", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "overlay", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js创建简单的垂直条形图 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列 + + // 数值格式化函数 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + xField = xChannel.key; + yField = yChannel.key; + + // 获取字段单位(如果存在) + if (xChannel.unit) { + xUnit = xChannel.unit; + } + + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField] // 确保y是数值类型 + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + + // *** BEGIN ADDITION: Define vertical gradient per category *** + sortedData.forEach((item, idx) => { + const dimension = item.x; + let barColor = colorResolver.other("primary").value; // Default color + if (colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value) { + barColor = colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value; // Use specific color if available + } + + // Create safe ID for the gradient + const safeCategory = typeof dimension === 'string' ? + dimension.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") // Bottom + .attr("x2", "0%") + .attr("y2", "0%"); // Top + + // Darker color at the bottom + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.5 })); // Adjust factor as needed + + // Lighter color at the top + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 0.5 })); // Adjust factor as needed + }); + // *** END ADDITION *** + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + // 计算字体大小的函数，确保文本在指定宽度内 + const calculateFontSize = (text, maxWidth, baseSize = 14) => { + // 检查参数是否有效 + if (!text || typeof text !== 'string' || !maxWidth || maxWidth <= 0 || !baseSize || baseSize <= 0) { + return Math.max(10, baseSize || 14); // 返回一个合理的默认值或最小尺寸 + } + + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + + // 否则，按比例缩小字体大小，确保不小于10 + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + // 文本换行辅助函数 (添加 alignment 参数) + function wrapText(textElement, str, width, lineHeight = 1.1, alignment = 'middle') { + const words = str.split(/\s+/).reverse(); // 按空格分割单词 + let word; + let line = []; + let lineNumber = 0; + const initialY = parseFloat(textElement.attr("y")); // 获取原始y坐标 + const initialX = parseFloat(textElement.attr("x")); // 获取原始x坐标 + // const actualFontSize = parseFloat(textElement.style("font-size")); // 获取实际应用的字体大小 + + textElement.text(null); // 清空现有文本 + + let tspans = []; // 存储最终要渲染的行 + + // 优先按单词换行 + if (words.length > 1) { + let currentLine = []; + while (word = words.pop()) { + currentLine.push(word); + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: textElement.style("font-family"), + fontSize: parseFloat(textElement.style("font-size")), + fontWeight: textElement.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + currentLine.pop(); // 回退一个词 + tspans.push(currentLine.join(" ")); // 添加完成的行 + currentLine = [word]; // 新行以当前词开始 + lineNumber++; + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } else { // 如果没有空格或只有一个词，则按字符换行 + const chars = str.split(''); + let currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const nextLine = currentLine + chars[i]; + const isOverflow = chartUtils.text.measure(null, nextLine, { + fontFamily: textElement.style("font-family"), + fontSize: parseFloat(textElement.style("font-size")), + fontWeight: textElement.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 0) { // 如果加了新字符就超长了，并且当前行不为空 + tspans.push(currentLine); // 添加当前行 + currentLine = chars[i]; // 新行从这个字符开始 + lineNumber++; + } else { + currentLine = nextLine; // 没超长就继续加字符 + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } + + // 计算总行数 + const totalLines = tspans.length; + let startDy = 0; + + // 根据对齐方式计算起始偏移 + if (alignment === 'middle') { + // 垂直居中：向上移动半行*(总行数-1) + startDy = -( (totalLines - 1) * lineHeight / 2); + } else if (alignment === 'bottom') { + // 底部对齐：计算总高度，向上移动 总高度 - 单行高度(近似) + const totalHeightEm = totalLines * lineHeight; + startDy = -(totalHeightEm - lineHeight); // 将底部对齐到原始y + } + // 如果是 'top' 对齐，startDy 保持为 0，即第一行基线在原始y位置 + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + textElement.append("tspan") + .attr("x", initialX) // x坐标与父相同 + .attr("dy", (i === 0 ? startDy : lineHeight) + "em") // 第一行应用起始偏移，后续行应用行高 + .text(lineText); + }); + // 保存实际行数 + textElement.attr("data-lines", totalLines); + } + + // 预计算标签字体大小和最大行数 + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const baseFontSize = defaultLabelFontSize; + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const labelLineHeight = 1.2; // 行高倍数 + + let maxLinesOverall = 0; + let uniformFontSize = baseFontSize; + + // 第一遍：计算统一字体大小 + const longestLabel = sortedData.reduce((a, b) => String(a.x).length > String(b.x).length ? a : b, {x:""}).x; + const labelMaxWidth = xScale.bandwidth() * 0.9; + uniformFontSize = calculateFontSize(String(longestLabel), labelMaxWidth, baseFontSize); + + // 第二遍：使用统一字体大小计算每个标签的实际行数，并找出最大行数 + sortedData.forEach(d => { + const tempText = svg.append("text") // 临时创建text用于调用wrapText + .attr("x", -1000) // 移出可视区 + .attr("y", -1000) + .style("font-size", `${uniformFontSize}px`) + .style("font-family", labelFontFamily) + .style("font-weight", labelFontWeight); + + wrapText(tempText, String(d.x), xScale.bandwidth(), labelLineHeight, 'top'); + const lines = parseInt(tempText.attr("data-lines") || 1); + if (lines > maxLinesOverall) { + maxLinesOverall = lines; + } + tempText.remove(); // 移除临时text元素 + }); + + // 计算维度标签的起始Y位置和水平线的Y位置 + const labelBaselineFirstLineY = innerHeight + 22; // 维度标签第一行基线的Y位置 (原为 innerHeight + 20) + const paddingBarToLabelTop = 3; // Bar底部到标签顶部的额外间距 + // horizontalLineY 现在基于标签顶部加上额外间距 + const horizontalLineY = labelBaselineFirstLineY - (uniformFontSize * 0.8) - paddingBarToLabelTop; // uniformFontSize * 0.8 估算升部高度 + + // 计算图标的统一Y位置 + // 计算标签块的底部Y坐标 + const bottomOfLabelBlockY = labelBaselineFirstLineY + (maxLinesOverall - 1) * uniformFontSize * labelLineHeight + uniformFontSize * 0.25; // 0.25 估算降部高度 + const iconRadius = 12; // 图标的半径或半尺寸 (假设图标是24x24) + const iconPaddingFromLabel = 2; // 图标与最下方标签的间距 (原为5) + const iconCenterY = bottomOfLabelBlockY + iconPaddingFromLabel + iconRadius; + + // 添加水平线 (作为柱子底部和标签顶部参考) + chart.append("line") + .attr("x1", 0) + .attr("y1", horizontalLineY) + .attr("x2", innerWidth) + .attr("y2", horizontalLineY) + .attr("stroke", "#e0e0e0") + .attr("stroke-width", 1); + + // 添加柱子 (修改高度和Y值，使其底部在horizontalLineY) + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.x)) + .attr("width", xScale.bandwidth()) + .attr("y", d => yScale(d.y)) // Y值由yScale决定 (顶部) + .attr("height", d => Math.max(0, horizontalLineY - yScale(d.y))) // 高度延伸到水平线 + .attr("fill", d => { + const dimension = d.x; + const safeCategory = typeof dimension === 'string' ? + dimension.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${sortedData.findIndex(item => item.x === dimension)}`; + const gradientId = `gradient-${safeCategory}`; + return `url(#${gradientId})`; + }) + .attr("rx", 4) + .attr("ry", 4) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const valueText = chartUtils.format.autoText(d.y) + (yUnit ? ` ${yUnit}` : ''); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = measureTextWidth(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + // 添加维度标签 (使用新的wrapText和统一的Y位置) + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", labelBaselineFirstLineY) // 统一的起始Y (使用新的变量名) + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${uniformFontSize}px`) + .style("font-weight", labelFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用默认文本颜色 + .each(function(d) { + wrapText(d3.select(this), String(d.x), xScale.bandwidth(), labelLineHeight, 'top'); + }); + + // 添加图标 (统一Y位置) + chart.selectAll(".icon-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-group") + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconCenterY})`) // 应用统一的Y位置 + .each(function(d) { + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -iconRadius) // 基于iconRadius调整 + .attr("y", -iconRadius) // 基于iconRadius调整 + .attr("width", iconRadius * 2) + .attr("height", iconRadius * 2) + .attr("preserveAspectRatio","xMidYMid meet"); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_09.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_09.js new file mode 100644 index 0000000000000000000000000000000000000000..f143d75a9257ab00a5eb682727649adeeaf11894 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_09.js @@ -0,0 +1,252 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_09", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 10], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + const imageBase64 = "data:image/png;base64,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" + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + // 计算图片的宽高比 + const imgAspectRatio = 1 + + // 为每个柱子添加图片叠加 + bars.each(function(d) { + const barHeight = chartHeight - yScale(d.value); + const barWidth = xScale.bandwidth(); + + // 计算单个图片的尺寸 + const imgWidth = barWidth; + const imgHeight = imgWidth / imgAspectRatio; + + // 计算需要叠加的图片数量 + const numImages = Math.ceil(barHeight / imgHeight)/0.353; + + // 创建图片叠加 + for (let i = 0; i < numImages; i++) { + d3.select(this) + .append("image") + .attr("xlink:href", imageBase64) + .attr("x", 0) + .attr("y", chartHeight-imgHeight*0.7 - (i + 1) * imgHeight*0.353) + .attr("width", imgWidth) + .attr("height", imgHeight); + } + }); + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => { + // 计算图片堆叠的实际高度 + const barHeight = chartHeight - yScale(d.value); + const imgWidth = xScale.bandwidth(); + const imgHeight = imgWidth / imgAspectRatio; + const numImages = Math.ceil(barHeight / imgHeight) / 0.353; + const stackHeight = numImages * imgHeight * 0.353; + + // 确保标签位于图片堆叠的顶部上方 + return chartHeight - stackHeight - imgHeight-10; + }) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..92780b245d7fef4de2a6d837cb79fdf681b1292a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_10.js @@ -0,0 +1,236 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_10", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const circleRadius = 5; // 每个圆形的半径 + const circleSpacing = 2; // 圆形之间的间距 + + // 为每个数据点创建圆形组 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category) + xScale.bandwidth()/2}, ${yScale(d.value)})`); + + // 计算每个柱子需要多少个圆形 + barGroups.each(function(d) { + const totalHeight = chartHeight - yScale(d.value); + const numCircles = Math.floor(totalHeight / (circleRadius * 2 + circleSpacing)); + + // 为每个柱子创建多个圆形 + for (let i = 0; i < numCircles; i++) { + d3.select(this) + .append("circle") + .attr("r", circleRadius) + .attr("cy", i * (circleRadius * 2 + circleSpacing)) + .attr("fill", colorScale(d, i)) + .attr("opacity", 1 - (i/numCircles/2)); // 添加透明度渐变效果 + } + }); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_11.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_11.js new file mode 100644 index 0000000000000000000000000000000000000000..ecc2f59831d0fa502375602de2452107fb51f67d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_11.js @@ -0,0 +1,221 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Histogram", + "chart_name": "vertical_bar_chart_11", + "required_fields": ["x", "y"], + "required_fields_type": [["temporal"], ["numerical"]], + "required_fields_range": [[20,40], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickValues(xScale.domain().filter((d, i) => i % 4 === 0)); // 每隔4个显示一个标签 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const circleRadius = xScale.bandwidth() / 2; // 每个圆形的半径 + const circleSpacing = 2; // 圆形之间的间距 + + // 为每个数据点创建圆形组 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category) + xScale.bandwidth()/2}, -10)`); + + // 计算每个柱子需要多少个圆形 + barGroups.each(function(d) { + const totalHeight = chartHeight - yScale(d.value); + const numCircles = Math.floor(totalHeight / (circleRadius * 2 + circleSpacing)); + + // 为每个柱子创建多个圆形 + for (let i = 0; i < numCircles; i++) { + d3.select(this) + .append("circle") + .attr("r", circleRadius) + .attr("cy", chartHeight - i * (circleRadius * 2 + circleSpacing)) + .attr("fill", colorScale(d, i)) + .attr("opacity", 1 - (i/numCircles/2)); // 添加透明度渐变效果 + } + }); + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..8ef724a1ba3f29d087855c9496c2e67083923789 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_12.js @@ -0,0 +1,854 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart With Circle", + "chart_name": "vertical_bar_chart_12", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 12], ["-inf", "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, dataJSON) { + const jsonData = dataJSON || {}; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const rawDataBlock = jsonData.data || {}; + const dataBlock = Array.isArray(rawDataBlock) + ? { data: rawDataBlock, columns: jsonData.columns || [] } + : rawDataBlock; + const sourceRows = dataBlock.data || []; + const columns = dataBlock.columns || jsonData.columns || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const sourceColors = jsonData.colors || {}; + + d3.select(containerSelector).html(""); + + const xColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const yColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const y2Column = Array.from(columns).find(c => c["role"] === "y2") + || Array.from(columns).find(c => c !== xColumn && c !== yColumn && c.data_type === "numerical") + || columns[2] || {}; + const xField = xColumn.name; + const yField = yColumn.name; + const y2Field = y2Column.name; + + const width = Math.max(580, Number(variables.width) || 640); + const height = Math.max(860, Number(variables.height) || 900); + const fontFamily = typography.label?.font_family || typography.title?.font_family || "Arial, sans-serif"; + const titleFamily = typography.title?.font_family || fontFamily; + const annotationFamily = typography.annotation?.font_family || fontFamily; + const darkText = sourceColors.text_color || "#08255a"; + const mutedText = "#53657a"; + const navy = "#08245c"; + const blue = sourceColors.other?.secondary || "#0b82c8"; + const red = sourceColors.other?.primary || "#b9152d"; + const palette = sourceColors.available_colors?.length + ? sourceColors.available_colors + : [red, "#159f9b", "#12a84f", "#5cb33e", "#7350a6", "#f3b719", "#1f77b4", "#f97316"]; + const labelSize = Math.max(8.5, Math.min(11.5, parseFloat(typography.label?.font_size) || 10)); + const valueSize = Math.max(8.5, Math.min(12, parseFloat(typography.annotation?.font_size) || 10)); + const yUnit = yColumn.unit === "none" ? "" : (yColumn.unit || ""); + const y2Unit = y2Column.unit === "none" ? "" : (y2Column.unit || ""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("class", "vertical-bar-chart-12 vertical-bar-chart-12-reference-layout"); + + const defs = svg.append("defs"); + const pageGradient = defs.append("linearGradient") + .attr("id", "vb12-page-gradient") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "100%"); + pageGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ffffff"); + pageGradient.append("stop").attr("offset", "62%").attr("stop-color", "#fbfdff"); + pageGradient.append("stop").attr("offset", "100%").attr("stop-color", "#e5f5ff"); + + const barGradient = defs.append("linearGradient") + .attr("id", "vb12-bar-highlight") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "100%"); + barGradient.append("stop").attr("offset", "0%").attr("stop-color", "rgba(255,255,255,0.26)"); + barGradient.append("stop").attr("offset", "100%").attr("stop-color", "rgba(0,0,0,0.10)"); + + const cardShadow = defs.append("filter") + .attr("id", "vb12-card-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "150%"); + cardShadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 10) + .attr("flood-color", "#7bb9df") + .attr("flood-opacity", 0.18); + + svg.append("rect") + .attr("class", "chart-canvas reference-page-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#vb12-page-gradient)"); + + svg.append("path") + .attr("class", "top-background-wave") + .attr("d", `M${width * 0.48},0 C${width * 0.62},${height * 0.04} ${width * 0.72},${height * 0.02} ${width},${height * 0.09} L${width},0 Z`) + .attr("fill", "#dff0fb"); + + svg.append("path") + .attr("class", "bottom-wave wave-back") + .attr("d", `M0 ${height - 62} C${width * 0.18} ${height - 90},${width * 0.36} ${height - 42},${width * 0.52} ${height - 68} S${width * 0.82} ${height - 96},${width} ${height - 56} L${width} ${height} L0 ${height} Z`) + .attr("fill", "#dceffd"); + svg.append("path") + .attr("class", "bottom-wave wave-front") + .attr("d", `M0 ${height - 36} C${width * 0.18} ${height - 58},${width * 0.40} ${height - 12},${width * 0.60} ${height - 38} S${width * 0.83} ${height - 68},${width} ${height - 28} L${width} ${height} L0 ${height} Z`) + .attr("fill", "#55ace5"); + svg.append("path") + .attr("class", "bottom-wave wave-deep") + .attr("d", `M0 ${height - 18} C${width * 0.24} ${height - 40},${width * 0.44} ${height + 8},${width * 0.70} ${height - 22} C${width * 0.84} ${height - 38},${width * 0.92} ${height - 22},${width} ${height - 30} L${width} ${height} L0 ${height} Z`) + .attr("fill", "#1594d2"); + + function message(text) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .attr("fill", darkText) + .style("font-family", fontFamily) + .style("font-size", "16px") + .text(text); + return svg.node(); + } + + if (!xField || !yField || !y2Field) return message("Missing vertical bar fields"); + + function readableLabel(value) { + return String(value ?? "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function parseTemporalRank(value) { + const text = String(value ?? "").trim(); + const lower = text.toLowerCase(); + const months = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, + sep: 9, sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + const seasons = { winter: 1, spring: 2, summer: 3, fall: 4, autumn: 4 }; + if (months[lower] != null) return months[lower]; + let match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^Q([1-4])\s+(-?\d{4})$/i) || text.match(/^(-?\d{4})\s+Q([1-4])$/i); + if (match && text.toUpperCase().startsWith("Q")) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + match = text.match(/^(winter|spring|summer|fall|autumn)\s+(-?\d{4})$/i); + if (match) return Number(match[2]) * 10 + seasons[match[1].toLowerCase()]; + match = text.match(/^(-?\d{4})\s+(winter|spring|summer|fall|autumn)$/i); + if (match) return Number(match[1]) * 10 + seasons[match[2].toLowerCase()]; + return NaN; + } + + function parseOrdinalRank(value) { + const text = String(value ?? "").trim().toLowerCase(); + const named = { + primary: 1, elementary: 1, secondary: 2, college: 3, university: 3, + low: 1, lower: 1, medium: 2, moderate: 2, high: 3, higher: 3, + children: 1, adolescents: 2, teens: 2, adults: 3, seniors: 4 + }; + if (named[text] != null) return named[text]; + let match = text.match(/(?:less than|under)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) - 0.5; + match = text.match(/(?:more than|over)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) + 0.5; + match = text.match(/^[$]?\s*([\d,]+(?:\.\d+)?)\s*(?:-|to)/); + if (match) return Number(match[1].replace(/,/g, "")); + match = text.match(/^(-?\d+(?:\.\d+)?)/); + if (match) return Number(match[1]); + return NaN; + } + + function compactNumber(value) { + const numeric = Number(value); + const abs = Math.abs(numeric); + if (abs >= 1000000000) return `${d3.format(".3~g")(numeric / 1000000000)}B`; + if (abs >= 1000000) return `${d3.format(".3~g")(numeric / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".3~g")(numeric / 1000)}K`; + return d3.format(",.4~g")(numeric); + } + + function formatLocalValue(value, unit = "") { + const numeric = Number(value); + const formatted = compactNumber(numeric); + if (!unit) return formatted; + if (unit === "%") return `${formatted}%`; + if (unit.startsWith("$")) { + const sign = numeric < 0 ? "-" : ""; + return `${sign}$${compactNumber(Math.abs(numeric))}${unit.slice(1)}`; + } + if (unit.length <= 3 && /^[^A-Za-z0-9]+$/.test(unit)) return `${unit}${formatted}`; + return `${formatted} ${unit}`; + } + + function fitText(value, maxChars) { + const text = readableLabel(value); + if (text.length <= maxChars) return text; + return text.slice(0, Math.max(1, maxChars)).trim(); + } + + function wrapLines(value, maxChars, maxLines = 2) { + const words = readableLabel(value).split(/\s+/).filter(Boolean); + if (!words.length) return [""]; + const lines = []; + let current = ""; + words.forEach(word => { + const shortWord = word.length > maxChars ? word.slice(0, maxChars) : word; + const next = current ? `${current} ${shortWord}` : shortWord; + if (next.length <= maxChars) { + current = next; + } else { + if (current) lines.push(current); + current = shortWord; + } + }); + if (current) lines.push(current); + if (lines.length <= maxLines) return lines; + return lines.slice(0, maxLines).map(line => fitText(line, maxChars)); + } + + const grouped = new Map(); + sourceRows.forEach((row, index) => { + const category = readableLabel(row[xField]); + const yValue = Number(row[yField]); + const y2Value = Number(row[y2Field]); + if (!category || !Number.isFinite(yValue) || !Number.isFinite(y2Value)) return; + if (!grouped.has(category)) { + grouped.set(category, { + category, + rawCategory: row[xField], + firstIndex: index, + y: 0, + y2: 0 + }); + } + const entry = grouped.get(category); + entry.y += yValue; + entry.y2 += Math.max(0, y2Value); + }); + + const rows = Array.from(grouped.values()).map((row, index) => ({ + ...row, + originalIndex: index, + temporalRank: parseTemporalRank(row.rawCategory), + ordinalRank: parseOrdinalRank(row.rawCategory) + })); + if (!rows.length) return message("No valid data for vertical bars"); + + const allTemporal = xColumn.data_type === "temporal" || rows.every(d => Number.isFinite(d.temporalRank)); + const allOrdinal = !allTemporal && rows.every(d => Number.isFinite(d.ordinalRank)); + const sortMode = allTemporal ? "chronological" : (allOrdinal ? "ordered category" : "largest primary value"); + rows.sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + if (allOrdinal) return d3.ascending(a.ordinalRank, b.ordinalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.y, b.y) || d3.ascending(a.category, b.category); + }); + + const yLabel = readableLabel(yColumn.label || yField); + const y2Label = readableLabel(y2Column.label || y2Field); + const xLabel = readableLabel(xColumn.label || xField); + const titleLines = wrapLines(`${yLabel} and ${y2Label}`, 16, 5); + const byLine = fitText(`by ${xLabel}`, 24); + const subtitle = `${fitText(yLabel, 36)} compared with ${fitText(y2Label, 34)} across ${fitText(xLabel, 24).toLowerCase()} categories.`; + + const headerX = 42; + const headerTop = 42; + const titleSize = Math.max(22, Math.min(25, width * 0.042)); + const titleLeading = titleSize * 0.93; + const byLineY = titleLines.length * titleLeading + 8; + const accentY = byLineY + 31; + const subtitleY = accentY + 29; + const referenceHeader = svg.append("g") + .attr("class", "reference-header title-text-block") + .attr("transform", `translate(${headerX}, ${headerTop})`); + + titleLines.forEach((line, index) => { + referenceHeader.append("text") + .attr("class", `reference-title-line reference-title-line-${index + 1}`) + .attr("x", 0) + .attr("y", index * titleLeading) + .attr("fill", navy) + .style("font-family", titleFamily) + .style("font-size", `${titleSize}px`) + .style("font-weight", "900") + .style("letter-spacing", "0") + .text(line); + }); + + referenceHeader.append("text") + .attr("class", "reference-byline") + .attr("x", 0) + .attr("y", byLineY) + .attr("fill", blue) + .style("font-family", titleFamily) + .style("font-size", `${Math.max(18, titleSize * 0.60)}px`) + .style("font-weight", "900") + .style("letter-spacing", "0") + .text(byLine); + + referenceHeader.append("line") + .attr("class", "title-accent-rule") + .attr("x1", 0) + .attr("x2", 58) + .attr("y1", accentY) + .attr("y2", accentY) + .attr("stroke", "#0e9f9a") + .attr("stroke-width", 4) + .attr("stroke-linecap", "round"); + + wrapLines(subtitle, 42, 2).forEach((line, index) => { + referenceHeader.append("text") + .attr("class", "reference-subtitle-line") + .attr("x", 0) + .attr("y", subtitleY + index * 20) + .attr("fill", "#374151") + .style("font-family", annotationFamily) + .style("font-size", "15px") + .style("font-weight", "500") + .text(line); + }); + + const decor = svg.append("g") + .attr("class", "top-decorative-image-slot swimmer-wave-slot") + .attr("transform", `translate(${width * 0.48}, 34)`); + const decorW = width * 0.46; + decor.append("path") + .attr("class", "decorative-wave-ribbon") + .attr("d", `M0 110 C${decorW * 0.25} 88,${decorW * 0.36} 132,${decorW * 0.60} 92 C${decorW * 0.75} 68,${decorW * 0.90} 86,${decorW} 62 L${decorW} 118 C${decorW * 0.73} 139,${decorW * 0.42} 141,0 126 Z`) + .attr("fill", "#bfe6ff") + .attr("opacity", 0.86); + decor.append("path") + .attr("class", "decorative-wave-front") + .attr("d", `M${decorW * 0.06} 122 C${decorW * 0.25} 92,${decorW * 0.38} 124,${decorW * 0.55} 98 C${decorW * 0.76} 66,${decorW * 0.82} 94,${decorW * 0.98} 78`) + .attr("fill", "none") + .attr("stroke", "#178ed8") + .attr("stroke-width", 9) + .attr("stroke-linecap", "round") + .attr("opacity", 0.72); + decor.append("path") + .attr("class", "decorative-swimmer-arm") + .attr("d", `M${decorW * 0.28} 72 C${decorW * 0.41} 56,${decorW * 0.54} 42,${decorW * 0.64} 48 C${decorW * 0.70} 54,${decorW * 0.72} 68,${decorW * 0.76} 78`) + .attr("fill", "none") + .attr("stroke", "#f4a072") + .attr("stroke-width", 18) + .attr("stroke-linecap", "round"); + decor.append("circle") + .attr("class", "decorative-swimmer-head") + .attr("cx", decorW * 0.84) + .attr("cy", 66) + .attr("r", 19) + .attr("fill", "#f5b18a"); + decor.append("path") + .attr("class", "decorative-swimmer-cap") + .attr("d", `M${decorW * 0.80} 56 Q${decorW * 0.84} 37 ${decorW * 0.90} 55 L${decorW * 0.89} 73 Q${decorW * 0.84} 62 ${decorW * 0.80} 56 Z`) + .attr("fill", "#e91d36"); + decor.append("circle") + .attr("class", "decorative-swimmer-goggle") + .attr("cx", decorW * 0.855) + .attr("cy", 64) + .attr("r", 5) + .attr("fill", navy); + + const legendY = Math.max(214, headerTop + subtitleY + 64); + const legend = svg.append("g") + .attr("class", "legend-card reference-legend") + .attr("transform", `translate(${headerX}, ${legendY})`); + legend.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", Math.min(width - 84, 308)) + .attr("height", 46) + .attr("rx", 10) + .attr("fill", "rgba(255,255,255,0.92)") + .attr("stroke", "rgba(148,163,184,0.36)"); + + const legendItems = [ + { label: yLabel, color: red, shape: "rect", className: "legend-primary" }, + { label: y2Label, color: navy, shape: "circle", className: "legend-secondary" } + ]; + legendItems.forEach((item, index) => { + const itemX = index ? Math.min(176, width * 0.30) : 24; + const itemG = legend.append("g") + .attr("class", `legend-item ${item.className}`) + .attr("transform", `translate(${itemX}, 23)`); + if (item.shape === "rect") { + itemG.append("rect") + .attr("x", -8) + .attr("y", -8) + .attr("width", 16) + .attr("height", 16) + .attr("rx", 1.5) + .attr("fill", item.color); + } else { + itemG.append("circle") + .attr("cx", 0) + .attr("cy", 0) + .attr("r", 8) + .attr("fill", item.color); + } + itemG.append("text") + .attr("x", 18) + .attr("y", 0) + .attr("dominant-baseline", "middle") + .attr("fill", darkText) + .style("font-family", annotationFamily) + .style("font-size", "13px") + .style("font-weight", "700") + .text(fitText(item.label + (index === 0 && yUnit ? ` (${yUnit})` : index === 1 && y2Unit ? ` (${y2Unit})` : ""), 19)); + }); + + const chartX = Math.max(58, width * 0.10); + const chartY = legendY + 84; + const chartW = width - chartX * 2; + const footerH = 72; + const footerY = height - footerH - 45; + const chartH = Math.max(300, footerY - chartY - 34); + const plotTop = chartY + 142; + const plotBottom = chartY + chartH - 74; + const circleY = chartY + chartH - 34; + const xScale = d3.scaleBand() + .domain(rows.map(d => d.category)) + .range([0, chartW]) + .padding(rows.length > 8 ? 0.13 : 0.17); + + const minY = d3.min(rows, d => d.y) || 0; + const maxY = d3.max(rows, d => d.y) || 0; + const span = Math.max(1, maxY - minY); + const yDomain = [ + Math.min(0, minY - span * 0.12), + Math.max(0, maxY + span * 0.12) + ]; + const yScale = d3.scaleLinear() + .domain(yDomain) + .nice(5) + .range([plotBottom, plotTop]); + const zeroY = yScale(0); + const maxY2 = d3.max(rows, d => d.y2) || 1; + const circleScale = d3.scaleSqrt() + .domain([0, maxY2]) + .range([Math.max(5, Math.min(8, xScale.bandwidth() * 0.18)), Math.max(13, Math.min(22, xScale.bandwidth() * 0.32))]); + const colorFor = (row, index) => sourceColors.field?.[row.rawCategory] + || sourceColors.field?.[row.category] + || palette[index % palette.length] + || red; + const softFillFor = (color, index) => { + const fallback = ["#f8e9ed", "#e7f6f6", "#eaf8ef", "#edf7e9", "#f0ecfa", "#fff4cf", "#e8f1ff", "#fff0df"]; + return d3.color(color)?.copy({ opacity: 0.10 })?.formatRgb() || fallback[index % fallback.length]; + }; + + const chart = svg.append("g") + .attr("class", "reference-chart-block vertical-bar-plot") + .attr("transform", `translate(${chartX}, 0)`); + + chart.append("rect") + .attr("class", "plot-background reference-plot-panel") + .attr("x", -10) + .attr("y", chartY - 8) + .attr("width", chartW + 20) + .attr("height", chartH + 24) + .attr("rx", 10) + .attr("fill", "rgba(255,255,255,0.68)") + .attr("stroke", "rgba(210,225,238,0.62)"); + + let yTicks = yScale.ticks(5); + if (!yTicks.some(tick => Math.abs(tick) < 1e-9)) yTicks.push(0); + yTicks = Array.from(new Set(yTicks.map(tick => Number(tick.toPrecision(12))))).sort((a, b) => a - b); + + yTicks.forEach(tick => { + const y = yScale(tick); + chart.append("line") + .attr("class", "gridline y-axis-gridline") + .attr("x1", 0) + .attr("x2", chartW) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", Math.abs(tick) < 1e-9 ? "rgba(148,163,184,0.58)" : "rgba(148,163,184,0.26)") + .attr("stroke-width", Math.abs(tick) < 1e-9 ? 1.2 : 0.8) + .attr("stroke-dasharray", Math.abs(tick) < 1e-9 ? "4 3" : "none"); + chart.append("text") + .attr("class", "y-axis-tick primary-axis-tick") + .attr("x", -12) + .attr("y", y) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", "#3f4755") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8, valueSize - 0.5)}px`) + .style("font-weight", "650") + .text(formatLocalValue(tick, yUnit)); + }); + + const y2Scale = d3.scaleLinear().domain([0, maxY2]).nice(4).range([plotBottom, plotTop]); + y2Scale.ticks(4).forEach(tick => { + chart.append("text") + .attr("class", "secondary-axis-tick") + .attr("x", chartW + 12) + .attr("y", y2Scale(tick)) + .attr("dominant-baseline", "middle") + .attr("fill", "#075ca5") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8, valueSize - 0.5)}px`) + .style("font-weight", "650") + .text(formatLocalValue(tick, y2Unit)); + }); + + chart.append("text") + .attr("class", "axis-title y-axis-title") + .attr("x", -(plotTop + plotBottom) / 2) + .attr("y", -76) + .attr("transform", "rotate(-90)") + .attr("text-anchor", "middle") + .attr("fill", red) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(10, valueSize)}px`) + .style("font-weight", "800") + .text(fitText(yLabel + (yUnit ? ` (${yUnit})` : ""), 34)); + + chart.append("text") + .attr("class", "axis-title secondary-axis-title") + .attr("x", (plotTop + plotBottom) / 2) + .attr("y", -(chartW + 64)) + .attr("transform", "rotate(90)") + .attr("text-anchor", "middle") + .attr("fill", "#075ca5") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(10, valueSize)}px`) + .style("font-weight", "800") + .text(fitText(y2Label + (y2Unit ? ` (${y2Unit})` : ""), 34)); + + rows.forEach((row, index) => { + const x = xScale(row.category); + const bandWidth = xScale.bandwidth(); + const centerX = x + bandWidth / 2; + const color = colorFor(row, index); + const panelWidth = Math.max(32, bandWidth * 0.94); + const panelX = centerX - panelWidth / 2; + const panelY = chartY + 12; + const panelH = chartH - 2; + const iconR = Math.max(14, Math.min(24, bandWidth * 0.27)); + const barWidth = Math.max(13, Math.min(40, bandWidth * 0.46)); + const yValue = row.y; + const yTop = yScale(Math.max(0, yValue)); + const yBottom = yScale(Math.min(0, yValue)); + const barHeight = Math.max(1, Math.abs(yBottom - yTop)); + const barY = yValue >= 0 ? yTop : zeroY; + const labelY = yValue >= 0 ? Math.max(plotTop - 8, barY - 13) : Math.min(plotBottom + 17, barY + barHeight + 13); + const radius = circleScale(row.y2); + + chart.append("rect") + .attr("class", "category-column-panel reference-column-card") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-y", row.y) + .attr("data-y2", row.y2) + .attr("x", panelX) + .attr("y", panelY) + .attr("width", panelWidth) + .attr("height", panelH) + .attr("rx", 13) + .attr("fill", softFillFor(color, index)) + .attr("stroke", "rgba(255,255,255,0.88)") + .attr("filter", rows.length <= 7 ? "url(#vb12-card-shadow)" : null); + + const icon = chart.append("g") + .attr("class", "category-icon-slot") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("transform", `translate(${centerX}, ${chartY + 50})`); + icon.append("circle") + .attr("r", iconR) + .attr("fill", "rgba(255,255,255,0.86)") + .attr("stroke", "rgba(226,232,240,0.72)"); + icon.append("path") + .attr("d", index % 3 === 0 + ? `M${-iconR * 0.55},${iconR * 0.16} C${-iconR * 0.18},${-iconR * 0.36} ${iconR * 0.18},${iconR * 0.48} ${iconR * 0.55},${-iconR * 0.14}` + : index % 3 === 1 + ? `M${-iconR * 0.52},${iconR * 0.24} L${-iconR * 0.10},${-iconR * 0.38} L${iconR * 0.50},${iconR * 0.16}` + : `M${-iconR * 0.48},0 L${iconR * 0.48},0 M0,${-iconR * 0.48} L0,${iconR * 0.48}`) + .attr("fill", "none") + .attr("stroke", color) + .attr("stroke-width", Math.max(2.2, iconR * 0.18)) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + + const categoryText = chart.append("text") + .attr("class", "x-axis-tick category-label") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("x", centerX) + .attr("y", chartY + 94) + .attr("text-anchor", "middle") + .attr("fill", navy) + .style("font-family", fontFamily) + .style("font-size", `${Math.max(8, Math.min(labelSize + 0.5, bandWidth * 0.17))}px`) + .style("font-weight", "900"); + const categoryChars = Math.max(5, Math.floor(panelWidth / (labelSize * 0.48))); + wrapLines(row.category.toUpperCase(), categoryChars, 2).forEach((line, lineIndex) => { + categoryText.append("tspan") + .attr("x", centerX) + .attr("dy", lineIndex === 0 ? 0 : labelSize + 1) + .text(line); + }); + + chart.append("rect") + .attr("class", "bar-track") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("x", centerX - barWidth / 2) + .attr("y", plotTop) + .attr("width", barWidth) + .attr("height", plotBottom - plotTop) + .attr("rx", Math.min(12, barWidth / 2)) + .attr("fill", "rgba(255,255,255,0.62)"); + + chart.append("rect") + .attr("class", "vertical-bar bar-mark data-point mark") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-y", row.y) + .attr("data-y2", row.y2) + .attr("x", centerX - barWidth / 2) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", variables.has_rounded_corners === false ? 4 : Math.min(12, barWidth / 2)) + .attr("fill", color); + + chart.append("rect") + .attr("class", "bar-highlight") + .attr("x", centerX - barWidth / 2) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", variables.has_rounded_corners === false ? 4 : Math.min(12, barWidth / 2)) + .attr("fill", "url(#vb12-bar-highlight)") + .attr("opacity", 0.45); + + chart.append("text") + .attr("class", "bar-value-label value-label") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-y", row.y) + .attr("x", centerX) + .attr("y", labelY) + .attr("text-anchor", "middle") + .attr("fill", color) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(11, valueSize + 2)}px`) + .style("font-weight", "900") + .text(formatLocalValue(row.y, yUnit)); + + chart.append("line") + .attr("class", "secondary-marker-guide") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("x1", centerX) + .attr("x2", centerX) + .attr("y1", zeroY) + .attr("y2", circleY) + .attr("stroke", color) + .attr("stroke-width", 1.2) + .attr("stroke-dasharray", "3 3") + .attr("opacity", 0.62); + + chart.append("circle") + .attr("class", "secondary-circle circle-mark") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-y2", row.y2) + .attr("cx", centerX) + .attr("cy", circleY) + .attr("r", radius) + .attr("fill", color) + .attr("stroke", "rgba(255,255,255,0.95)") + .attr("stroke-width", 2.2); + + chart.append("text") + .attr("class", "secondary-value-label") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-y2", row.y2) + .attr("x", centerX) + .attr("y", circleY + Math.max(3, valueSize * 0.36)) + .attr("text-anchor", "middle") + .attr("fill", "#ffffff") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.5, Math.min(valueSize, radius * 0.72))}px`) + .style("font-weight", "900") + .text(formatLocalValue(row.y2, "")); + + if (y2Unit) { + chart.append("text") + .attr("class", "secondary-unit-label") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("x", centerX) + .attr("y", circleY + radius + 17) + .attr("text-anchor", "middle") + .attr("fill", "#334155") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.5, valueSize - 1)}px`) + .text(fitText(y2Unit, 8)); + } + }); + + const footer = svg.append("g") + .attr("class", "bottom-insight-card footer-source-card") + .attr("transform", `translate(${Math.max(34, width * 0.07)}, ${footerY})`); + const footerW = width - Math.max(34, width * 0.07) * 2; + footer.append("rect") + .attr("class", "footer-card-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", footerW) + .attr("height", footerH) + .attr("rx", 11) + .attr("fill", "rgba(255,255,255,0.86)") + .attr("stroke", "#bed7ee") + .attr("stroke-width", 1); + + const footerIcon = footer.append("g") + .attr("class", "footer-icon-slot") + .attr("transform", "translate(58, 36)"); + footerIcon.append("path") + .attr("d", "M-24 18 L-24 3 L-15 3 L-15 18 M-9 18 L-9 -8 L0 -8 L0 18 M6 18 L6 -22 L18 -22 L18 18") + .attr("fill", "none") + .attr("stroke", blue) + .attr("stroke-width", 5) + .attr("stroke-linejoin", "round"); + footerIcon.append("path") + .attr("d", "M-26 -4 L-9 -16 L0 -8 L21 -31") + .attr("fill", "none") + .attr("stroke", "#0f8fd0") + .attr("stroke-width", 5) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + footerIcon.append("path") + .attr("d", "M21 -31 L20 -15 M21 -31 L6 -28") + .attr("fill", "none") + .attr("stroke", "#0f8fd0") + .attr("stroke-width", 5) + .attr("stroke-linecap", "round"); + + footer.append("line") + .attr("class", "footer-divider") + .attr("x1", 102) + .attr("x2", 102) + .attr("y1", 14) + .attr("y2", footerH - 14) + .attr("stroke", "#bfd3e8") + .attr("stroke-width", 1.4); + + const highY = rows.reduce((best, row) => row.y > best.y ? row : best, rows[0]); + const highY2 = rows.reduce((best, row) => row.y2 > best.y2 ? row : best, rows[0]); + const insightText = `${fitText(highY.category, 20)} leads ${fitText(yLabel, 24)}; ${fitText(highY2.category, 20)} leads ${fitText(y2Label, 24)}.`; + const insightLines = wrapLines(insightText, Math.max(34, Math.floor((footerW - 190) / 7)), 2); + insightLines.forEach((line, index) => { + footer.append("text") + .attr("class", "footer-insight-title") + .attr("x", 122) + .attr("y", 25 + index * 15) + .attr("fill", navy) + .style("font-family", annotationFamily) + .style("font-size", "13.5px") + .style("font-weight", "900") + .text(line); + }); + footer.append("text") + .attr("class", "source-row source-text") + .attr("x", 122) + .attr("y", insightLines.length > 1 ? 58 : 51) + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", "10.5px") + .text(fitText(`Source: ${fitText(xLabel, 20)} order is ${sortMode}; ${fitText(y2Label, 22)} uses circle size.`, Math.max(38, Math.floor((footerW - 245) / 5.6)))); + + const footerDecor = footer.append("g") + .attr("class", "footer-decorative-image-slot wave-icon-slot") + .attr("transform", `translate(${footerW - 72}, 39)`); + footerDecor.append("path") + .attr("d", "M-36 6 C-22 -13,-8 19,8 -1 S28 -12,38 4") + .attr("fill", "none") + .attr("stroke", "#93c5e8") + .attr("stroke-width", 5) + .attr("stroke-linecap", "round"); + footerDecor.append("path") + .attr("d", "M-32 18 C-16 1,-2 29,16 10 S30 3,40 15") + .attr("fill", "none") + .attr("stroke", "#57aee2") + .attr("stroke-width", 4) + .attr("stroke-linecap", "round"); + footerDecor.append("circle") + .attr("cx", 35) + .attr("cy", -17) + .attr("r", 10) + .attr("fill", "#9bcdf0"); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_13.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_13.js new file mode 100644 index 0000000000000000000000000000000000000000..af2c0dea34f71f6ef6f65d993fd25b6cdbfe5b05 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_13.js @@ -0,0 +1,516 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart With Circle", + "chart_name": "vertical_bar_chart_13", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [["categorical"], ["numerical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直条形图与比例方形复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#008080", secondary: "#FF0000" }, // 默认颜色: 蓝绿色和红色 + available_colors: ["#FFBF00"] // 默认: 黄色 + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 数值单位规范 + // 添加数值格式化函数 + + // *** 添加: 创建用于文本测量的Canvas Context *** + const canvas = document.createElement('canvas'); + const context = canvas.getContext('2d'); + + // *** 修改: 提前提取字段名和单位 *** + const dimensionField = chartUtils.schema.channel(jsonData, "x").key ; + const valueField = chartUtils.schema.channel(jsonData, "y").key ; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key ; + + let valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit || ""; // 默认为百分号 + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit || ""; + + // 确保单位是字符串 + valueUnit = valueUnit || ""; + valueUnit2 = valueUnit2 || ""; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距 - 减少底部边距，因为标签上移 + const margin = { top: 90, right: 50, bottom: 30, left: 50 }; // *** 修改: 减少 bottom *** + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; // *** 修改: 重新计算 innerHeight *** + + // 定义中间区域的高度 (保持不变或按需调整) + const centralBandHeight = innerHeight * 0.20; // 中间区域占20%高度 + + // 上下条形图的总可用高度 + const barAreaHeight = innerHeight - centralBandHeight; + + // 按正负最大值比例分配高度 + const maxPositiveY = d3.max(chartData, d => Math.max(0, +d[valueField])) || 0; + const maxNegativeY = Math.abs(d3.min(chartData, d => Math.min(0, +d[valueField])) || 0); + const totalMagnitudeRange = maxPositiveY + maxNegativeY; + + let topBarAreaHeight; + let bottomBarAreaHeight; + + if (totalMagnitudeRange > 0) { + topBarAreaHeight = barAreaHeight * (maxPositiveY / totalMagnitudeRange); + bottomBarAreaHeight = barAreaHeight * (maxNegativeY / totalMagnitudeRange); + } else { + topBarAreaHeight = barAreaHeight / 2; + bottomBarAreaHeight = barAreaHeight / 2; + } + + // *** 修改: 重新计算中间区域的 Y 坐标 *** + const centralBandTopY = margin.top + topBarAreaHeight; + const centralBandBottomY = centralBandTopY + centralBandHeight; + + // *** 修改: 移除图标尺寸定义 *** + // const iconSize = 20; + // const iconMargin = 3; + const labelMargin = 3; + const circlePadding = 5; // 重命名为 shapePadding? + + const baseFontSizeLabel = parseFloat(typography.label.font_size) || 14; + const baseFontSizeAnnotation = parseFloat(typography.annotation.font_size) || 12; + const minFontSize = 8; + + // *** 修改: 仅在此处预估中间区域元素 Y 坐标 *** + const estDimensionLabelY = centralBandTopY + centralBandHeight * 0.30; + const estShapeY = centralBandTopY + centralBandHeight * 0.70; // *** 重命名: estCircleY -> estShapeY *** + + // ---------- 4. 数据处理 ---------- + + // 转换数值类型 + chartData.forEach(d => { + d[valueField] = +d[valueField]; + d[valueField2] = +d[valueField2]; + }); + + // *** 修改: 按 y 值 (valueField) 降序排序数据 *** + chartData.sort((a, b) => +b[valueField] - +a[valueField]); + + // 获取排序后的维度列表 + const dimensions = chartData.map(d => d[dimensionField]); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 (类别) + const xScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerWidth]) + .padding(0.2); // 柱子之间的间距 + + // *** 修改: 更新 Y 轴比例尺范围以适应中间区域 *** + const yScalePositive = d3.scaleLinear() + .domain([0, maxPositiveY === 0 ? 1 : maxPositiveY]) + .range([centralBandTopY, margin.top]); // 从中间区域顶部到图表顶部边距 + + const yScaleNegative = d3.scaleLinear() + .domain([0, maxNegativeY === 0 ? 1 : maxNegativeY]) + .range([centralBandBottomY, height - margin.bottom]); // 从中间区域底部到图表底部边距 + + // *** 修改: 方形面积比例尺 (y2值) *** + const maxValue2 = d3.max(chartData, d => +d[valueField2]) || 0; + const minSideLength = 3; // *** 重命名: minRadius -> minSideLength (方形最小边长) *** + + // *** 修改: 计算精确的中间区域 Y 坐标和最大方形边长 *** + const dimensionLabelY = centralBandTopY + centralBandHeight * 0.35; + const shapeY = centralBandTopY + centralBandHeight * 0.75; // *** 重命名: circleY -> shapeY *** + + const maxSideLengthFromBarWidth = xScale.bandwidth() * 0.9; // *** 重命名并调整: 方形边长不能超过 bar 宽度的 90% *** + const actualShapeAreaTopY = dimensionLabelY + baseFontSizeLabel + labelMargin; // *** 重命名: actualCircleAreaTopY -> actualShapeAreaTopY *** + const shapeAreaHeight = centralBandBottomY - actualShapeAreaTopY; // *** 重命名: circleAreaHeight -> shapeAreaHeight *** + // *** 修改: 最大边长受可用高度限制 *** + const maxSideLengthAvailableBasedOnHeight = Math.max(0, shapeAreaHeight * 0.9); + const maxSideLengthAvailable = Math.min(maxSideLengthAvailableBasedOnHeight, maxSideLengthFromBarWidth); + const maxSideLength = Math.max(minSideLength, maxSideLengthAvailable); // *** 重命名: maxRadius -> maxSideLength *** + + // *** 重命名: radiusScale -> sideLengthScale *** + const sideLengthScale = d3.scaleSqrt() + .domain([0, maxValue2]) + .range([minSideLength, maxSideLength]); // 输出边长范围 + + // *** 添加: 文本换行辅助函数 *** + function wrapText(textElement, text, width, x, y, fontSize, fontWeight, fontFamily) { + textElement.each(function() { + let words = text.split(/\s+/).reverse(), + word, + line = [], + lineNumber = 0, + lineHeight = 1.1, // ems + tspan = textElement.text(null).append("tspan").attr("x", x).attr("y", y), + dy = 0; // Initial dy for first line + + // Estimate width function (simple version) + const estimate = (txt) => txt.length * fontSize * 0.6; + + // Check total estimated width first + if (measureTextWidth(text, fontSize, fontWeight, fontFamily) <= width) { + tspan.text(text); + return; // No wrapping needed + } + + // Try to wrap (limit to max 2 lines for simplicity here) + let lines = []; + let currentLine = ""; + while (word = words.pop()) { + line.push(word); + currentLine = line.join(" "); + if (measureTextWidth(currentLine, fontSize, fontWeight, fontFamily) > width && line.length > 1) { + // Line exceeds width, back up one word + line.pop(); // remove the word that broke the limit + lines.push(line.join(" ")); // Add the previous line + line = [word]; // Start new line with the current word + if (lines.length >= 1) { // Stop after creating the first line break potential + line = [word].concat(words.reverse()); // Put remaining words on the second line + break; + } + } + } + lines.push(line.join(" ")); // Add the last line + + // Render the lines (max 4) + lines.slice(0, 4).forEach((lineText, i) => { + if (i > 0) dy = lineHeight; + tspan = textElement.append("tspan") + .attr("x", x) + .attr("y", y) + .attr("dy", `${dy}em`) + .text(lineText); + }); + // If more than 2 lines would be needed, the second line might truncate + + }); + } + + // *** 修改: 字体大小计算函数 -> 精确测量 *** + function measureTextWidth(text, fontSize, fontWeight, fontFamily) { + return chartUtils.text.measure(null, text, { fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight }).width; + } + + let minDimensionLabelRatio = 1.0; + let minCircleLabelRatio = 1.0; + let minBarLabelRatio = 1.0; + + const maxDimensionLabelWidth = xScale.bandwidth() * 0.90; + const maxCircleLabelWidth = xScale.bandwidth() * 1.03; + const maxBarLabelWidth = xScale.bandwidth(); + + // *** 注意: 这里的 finalDimensionFontSize, finalCircleFontSize, finalBarFontSize + // 是在循环之后计算的，但在循环内部以及半径计算中可能需要提前估算或使用基础值。 + // 当前代码在半径计算中使用了 finalDimensionFontSize || baseFontSizeLabel + + chartData.forEach(d => { + // 维度标签 + const dimensionText = String(d[dimensionField]); // Ensure string + // *** 修改: 使用精确宽度计算 *** + let currentWidth = measureTextWidth(dimensionText, baseFontSizeLabel, typography.label.font_weight, typography.label.font_family); + if (currentWidth > maxDimensionLabelWidth) { + minDimensionLabelRatio = Math.min(minDimensionLabelRatio, maxDimensionLabelWidth / currentWidth); + } + + // 圆圈标签 + const circleText = chartUtils.format.autoText(+d[valueField2]) + valueUnit2; // *** 修改: 单位放在后面 *** + currentWidth = measureTextWidth(circleText, baseFontSizeLabel, typography.label.font_weight, typography.label.font_family); + // *** 修改: 圆圈标签宽度只受bar宽度限制 *** + const effectiveMaxCircleWidth = maxCircleLabelWidth; // Remove constraint from maxAllowedCircleWidth + if (currentWidth > effectiveMaxCircleWidth) { + minCircleLabelRatio = Math.min(minCircleLabelRatio, effectiveMaxCircleWidth / currentWidth); + } + + // 条形图标签 + const barValue = d[valueField]; + const barText = (barValue > 0 ? "+" : "") + chartUtils.format.autoText(barValue) + valueUnit; + // *** 修改: 使用精确宽度计算 *** + currentWidth = measureTextWidth(barText, baseFontSizeAnnotation, typography.annotation.font_weight, typography.annotation.font_family); + if (currentWidth > maxBarLabelWidth) { + minBarLabelRatio = Math.min(minBarLabelRatio, maxBarLabelWidth / currentWidth); + } + }); + + // 计算最终字体大小 (应用最小比例并限制最小值) + const finalDimensionFontSize = Math.max(minFontSize, baseFontSizeLabel * minDimensionLabelRatio); + const finalCircleFontSize = Math.max(minFontSize, baseFontSizeLabel * minCircleLabelRatio); + const finalBarFontSize = Math.max(minFontSize, baseFontSizeAnnotation * minBarLabelRatio); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") // 保持宽高比 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 7. 创建主图表组 ---------- + + // *** 添加: 定义渐变 *** + const defs = svg.append("defs"); + + // 获取基础颜色 (已在图例部分定义) + const positiveColor = colorResolver.other("primary", { fallback: "#008080" }).value; + const negativeColor = colorResolver.other("secondary", { fallback: "#FF0000" }).value; + + // --- 正值条形图渐变 --- + const gradientPositive = defs.append("linearGradient") + .attr("id", "gradient-positive") + .attr("x1", "0%") + .attr("y1", "0%") // 从顶部开始 + .attr("x2", "0%") + .attr("y2", "100%"); // 到顶部结束 (垂直) + + gradientPositive.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(positiveColor, { mode: "darker", amount: 0.5 })); // 顶部稍暗 + + gradientPositive.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(positiveColor, { mode: "brighter", amount: 1.5 })); // 中间最亮 + + gradientPositive.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(positiveColor, { mode: "darker", amount: 0.5 })); // 底部稍暗 + + // --- 负值条形图渐变 --- + const gradientNegative = defs.append("linearGradient") + .attr("id", "gradient-negative") + .attr("x1", "0%") + .attr("y1", "0%") // 从顶部开始 + .attr("x2", "0%") + .attr("y2", "100%"); // 到底部结束 (垂直) + + gradientNegative.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(negativeColor, { mode: "darker", amount: 0.5 })); // 顶部稍暗 + + gradientNegative.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(negativeColor, { mode: "brighter", amount: 1.5 })); // 中间最亮 + + gradientNegative.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(negativeColor, { mode: "darker", amount: 0.5 })); // 底部稍暗 + + // --- 创建主绘图区域 --- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, 0)`); + + // ---------- 7.5 添加图例 (恢复原始逻辑) ---------- + const legendY = margin.top / 2; // 保持较高的位置 + const legendSquareSize = 12; + // const legendCircleRadius = 6; // 使用方形，移除半径 + const legendPadding = 15; + const legendItemPadding = 5; + + // *** 恢复: 获取图例文本和颜色 (positive, negative, shape) *** + const yName = valueField; + const y2Name = valueField2; + const shapeLegendColor = colorResolver.available(0, { fallback: "#FFBF00" }).value; + + const legendFontFamily = typography.annotation.font_family; + const legendFontSize = parseFloat(typography.annotation.font_size); + const legendFontWeight = typography.annotation.font_weight; + + const yNameWidth = measureTextWidth(yName, legendFontSize, legendFontWeight, legendFontFamily); + const y2NameWidth = measureTextWidth(y2Name, legendFontSize, legendFontWeight, legendFontFamily); + chartUtils.legend.segmentsCentered(svg, [ + { type: "rect", size: legendSquareSize, color: positiveColor }, + { type: "rect", size: legendSquareSize, color: negativeColor }, + { type: "text", label: yName }, + { type: "rect", size: legendSquareSize, color: shapeLegendColor }, + { type: "text", label: y2Name }, + ], { + centerX: margin.left + innerWidth / 2, + y: legendY, + itemGap: legendItemPadding, + sectionGap: legendPadding, + fontSize: legendFontSize, + fontFamily: legendFontFamily, + fontWeight: legendFontWeight, + textColor: colorResolver.text({ fallback: "#000000" }).value, + }); + // ---------- 9. 绘制图表元素 (循环处理每个数据点) ---------- + + chartData.forEach((d, i) => { + const x = xScale(d[dimensionField]); // 获取当前类别的X坐标 + const barWidth = xScale.bandwidth(); // 获取条形的宽度 + const centerX = x + barWidth / 2; // 当前类别的中心X坐标 + + // 9.1 绘制垂直条形图 (y值) + const yValue = d[valueField]; + let barHeight, barY, barColor; // *** 恢复: barColor 变量 *** + + // *** 修改: 使用更新后的 yScale 和边界计算高度/位置, 并恢复原始颜色逻辑 *** + if (yValue > 0) { + barY = yScalePositive(yValue); + barHeight = centralBandTopY - barY; + barColor = colorResolver.other("primary", { fallback: "#008080" }).value; // *** 恢复: 正值颜色 *** + } else if (yValue < 0) { + barY = centralBandBottomY; + const scaledY = yScaleNegative(Math.abs(yValue)); + barHeight = scaledY - barY; + barColor = colorResolver.other("secondary", { fallback: "#FF0000" }).value; // *** 恢复: 负值颜色 *** + } else { + barHeight = 0; + barY = centralBandTopY; + barColor = "none"; // *** 恢复: 零值颜色 *** + } + + if (barHeight < 0) barHeight = 0; + + if (barHeight > 0) { // 只有高度大于0才绘制 + // *** 修改: 使用 path 绘制带半圆顶底的条形 *** + const r = barWidth / 2; // 半圆半径 + let pathData; + + if (yValue > 0) { + // 正值条形路径 + pathData = ` + M ${x},${centralBandTopY} + A ${r},${r} 0 0 0 ${x + barWidth},${centralBandTopY} + L ${x + barWidth},${barY} + A ${r},${r} 0 0 0 ${x},${barY} + Z + `; + } else { // yValue < 0 + // 负值条形路径 + const scaledY = yScaleNegative(Math.abs(yValue)); // 底部Y坐标 + pathData = ` + M ${x},${barY} + A ${r},${r} 0 0 1 ${x + barWidth},${barY} + L ${x + barWidth},${scaledY} + A ${r},${r} 0 0 1 ${x},${scaledY} + Z + `; + } + + g.append("path") + .attr("d", pathData) + // *** 修改: 根据正负值应用不同的渐变填充 *** + .attr("fill", yValue >= 0 ? "url(#gradient-positive)" : "url(#gradient-negative)"); + // .attr("fill", barColor); // 旧的纯色填充 + + // 9.2 添加条形图数值标签 (y值) + const labelText = (yValue > 0 ? "+" : "") + chartUtils.format.autoText(yValue) + valueUnit; + const labelY = (yValue >= 0) ? barY + 3 : barY + barHeight + (finalBarFontSize * 0.8); + const textAnchor = "middle"; + + g.append("text") + .attr("x", centerX) + .attr("y", labelY) + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${finalBarFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#ffffff") + .text(labelText); + + // 9.3 绘制形状 (y2值) - 方形 + const squareSideLength = sideLengthScale(d[valueField2]); + // *** 恢复: 使用 available_colors[0] 作为形状颜色 *** + const shapeColor = colorResolver.available(0, { fallback: "#FFBF00" }).value; + + g.append("rect") + .attr("x", centerX - squareSideLength / 2) + .attr("y", shapeY - squareSideLength / 2) + .attr("width", squareSideLength) + .attr("height", squareSideLength) + .attr("fill", shapeColor) // *** 恢复: 使用 shapeColor *** + .attr("opacity", 0.8); + + // 9.4 添加形状数值标签 (y2值) - 基于方形调整 + const shapeLabelText = chartUtils.format.autoText(+d[valueField2]) + valueUnit2; // *** 重命名 *** + const textWidth = measureTextWidth(shapeLabelText, finalCircleFontSize, typography.label.font_weight, typography.label.font_family); + // *** 修改: 判断条件基于方形边长 *** + const isShapeBigEnough = textWidth < (squareSideLength * 0.9); // 例如，宽度小于边长的90% + let labelColor, labelActualY, labelDy; + + // *** 修改: 判断条件使用 squareSideLength *** + if (isShapeBigEnough && squareSideLength > minFontSize * 1.2) { // 边长至少比最小字体大一点 + labelColor = "#ffffff"; + labelActualY = shapeY; // *** 内部标签使用 shapeY *** + labelDy = "0.35em"; // 垂直居中 + } else { + labelColor = colorResolver.text({ fallback: "#000000" }).value; + // *** 修改: 外部标签基于 shapeY 和方形边长定位 *** + labelActualY = shapeY + squareSideLength / 2 + (finalCircleFontSize * 0.6) + 6; // 方形底部再往下一点 + labelDy = "0em"; + } + + g.append("text") + .attr("x", centerX) + .attr("y", labelActualY) + .attr("dy", labelDy) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + // *** 注意: 这里仍然使用 finalCircleFontSize，如果需要可以区分 *** + .style("font-size", `${finalCircleFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", labelColor) + .text(shapeLabelText); // *** 使用重命名后的变量 *** + + // 9.5 添加维度标签 (x值) + g.append("text") + .attr("x", centerX) + .attr("y", dimensionLabelY) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimensionFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .call(wrapText, d[dimensionField], maxDimensionLabelWidth, centerX, dimensionLabelY, finalDimensionFontSize, typography.label.font_weight, typography.label.font_family); + + } + }); + + // ---------- 10. 返回SVG节点 ---------- + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_15.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_15.js new file mode 100644 index 0000000000000000000000000000000000000000..0542d08a57b6cbd0d35fbf89eb7cc27b2f49d253 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_15.js @@ -0,0 +1,233 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_15", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加椭圆形装饰 + const ellipses = chartGroup.selectAll(".bar-top-ellipse") + .data(processedData) + .enter() + .append("ellipse") + .attr("class", "bar-top-ellipse") + .attr("cx", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("cy", d => yScale(d.value)) + .attr("rx", xScale.bandwidth() / 2) // 修改为柱子宽度的一半（因为rx是半径） + .attr("ry", 4) + .attr("fill", (d, i) => chartUtils.color.variant(colorResolver.other("secondary").value, { mode: "brighter", amount: 0.5 })) // 使用secondary颜色并调亮 + .attr("stroke", "none"); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_16.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_16.js new file mode 100644 index 0000000000000000000000000000000000000000..d458737eb2702a7551e41d32b91c1a79a2385248 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_16.js @@ -0,0 +1,422 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_16", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 12], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 数值单位规范 + // 添加数值格式化函数 + + // 辅助函数 - 用于测量文本宽度 + function measureTextWidth(text, fontFamily = typography.label.font_family, fontSize = typography.label.font_size) { + return chartUtils.text.measure(null, text, { fontFamily: fontFamily, fontSize: fontSize }).width; + } + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = measureTextWidth(xLabelText) + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建渐变定义 + const defs = svg.append("defs"); + + // 为每个柱子创建独立的渐变 + processedData.forEach((d, i) => { + // 使用金色系调色板 + let baseColor; + if (i === 0) { + // 第一个柱子使用深一点的金色 + baseColor = d3.rgb("#D4AF37"); // 金色 + } else { + // 从金色到浅金色的变化 + const goldColors = [ + "#D4AF37", // 金色 + "#CFB53B", // 旧金色 + "#E6BE8A", // 香槟金 + "#F7E98E", // 浅金色 + "#FFDF00", // 金黄色 + "#B8860B", // 暗金色 + "#DAA520", // 金菊色 + "#FFD700", // 纯金色 + "#FFC125" // 深黄金色 + ]; + + // 在数组范围内循环选择颜色 + baseColor = d3.rgb(goldColors[i % goldColors.length]); + } + + // 创建金属光泽渐变ID + const gradientId = `metalGradient-${i}`; + + // 创建线性渐变 - 从中间向两侧渐变 + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + // 金色金属光泽效果 - 更复杂的渐变 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "darker", amount: 1.5 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "15%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "darker", amount: 0.5 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "40%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "brighter", amount: 1.8 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "brighter", amount: 2.0 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "60%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "brighter", amount: 1.8 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "85%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "darker", amount: 0.5 })) + .attr("stop-opacity", 1); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "darker", amount: 1.5 })) + .attr("stop-opacity", 1); + + // 创建第二个渐变用于3D立体效果 + const gradientId3D = `metalGradient3D-${i}`; + const gradient3D = defs.append("linearGradient") + .attr("id", gradientId3D) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + + gradient3D.append("stop") + .attr("offset", "0%") + .attr("stop-color", "rgba(255, 255, 255, 0.7)") + .attr("stop-opacity", 0.7); + + gradient3D.append("stop") + .attr("offset", "10%") + .attr("stop-color", "rgba(255, 255, 255, 0.2)") + .attr("stop-opacity", 0.2); + + gradient3D.append("stop") + .attr("offset", "100%") + .attr("stop-color", "rgba(0, 0, 0, 0.05)") + .attr("stop-opacity", 0.05); + + // 添加纹理效果的渐变 + const textureId = `goldTexture-${i}`; + const textureGradient = defs.append("linearGradient") + .attr("id", textureId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "100%"); + + // 添加细微的纹理变化 + for (let j = 0; j < 10; j++) { + const offset = j * 10 + "%"; + const opacity = 0.1 + chartUtils.random.value(jsonData, `gold-texture-${i}-${j}`) * 0.05; // 轻微变化 + + textureGradient.append("stop") + .attr("offset", offset) + .attr("stop-color", j % 2 === 0 ? "#FFFFFF" : "#000000") + .attr("stop-opacity", opacity); + } + }); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => `url(#metalGradient-${i})`) + .attr("stroke", (d, i) => { + // 深金色边框 + return colorResolver.variant("#B8860B", { mode: "darker", amount: 0.5 }); + }) + .attr("stroke-width", 1) + .attr("rx", 3) // 增加圆角 + .attr("ry", 3); + + // 添加柱顶倒影效果 - 较浅的光线效果 + chartGroup.selectAll(".bar-top-reflection") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar-top-reflection") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", 2) + .attr("fill", "rgba(255, 255, 255, 0.8)") + .attr("rx", 3) + .attr("ry", 3); + + // 增强3D效果 - 添加顶部高光 + chartGroup.selectAll(".bar-top-highlight") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar-top-highlight") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.min(15, (chartHeight - yScale(d.value)) * 0.15)) + .attr("fill", (d, i) => `url(#metalGradient3D-${i})`) + .attr("rx", 3) + .attr("ry", 3) + .attr("opacity", 0.7); + + // 添加纹理层 - 为金属添加一些细微的纹理 + chartGroup.selectAll(".bar-texture") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar-texture") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value)) + .attr("width", xScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => `url(#goldTexture-${i})`) + .attr("opacity", 0.05) + .attr("rx", 3) + .attr("ry", 3); + + // 添加侧边高光效果 - 模拟光源从左侧照射 + chartGroup.selectAll(".bar-side-highlight") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar-side-highlight") + .attr("x", d => xScale(d.category)) + .attr("y", d => yScale(d.value) + 3) + .attr("width", xScale.bandwidth() * 0.15) + .attr("height", d => chartHeight - yScale(d.value) - 6) + .attr("fill", "rgba(255, 255, 255, 0.25)") + .attr("opacity", 0.4); + + // 添加右侧阴影效果 - 模拟光源从左侧照射 + chartGroup.selectAll(".bar-shadow") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar-shadow") + .attr("x", d => xScale(d.category) + xScale.bandwidth() * 0.85) + .attr("y", d => yScale(d.value) + 3) + .attr("width", xScale.bandwidth() * 0.15) + .attr("height", d => chartHeight - yScale(d.value) - 6) + .attr("fill", "rgba(0, 0, 0, 0.15)") + .attr("opacity", 0.5); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17.js new file mode 100644 index 0000000000000000000000000000000000000000..d5127c68ce4d4c4eb7318cc9e6d66947a56a338f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17.js @@ -0,0 +1,368 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_17", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.number(d, { unit: yUnit, spaceBeforeUnit: true }).text) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + const barWidth = xScale.bandwidth(); + + // 添加主柱体 + bars.append("rect") + .attr("class", "main-bar") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", barWidth) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加斜向延伸部分 + const extensionHeight = 120; // 斜向延伸的高度 + const midIndex = Math.floor(processedData.length / 2); // 中间柱子的索引 + const offsetStep = 30; // 左右柱子每相邻一列，向左右偏移的像素数 + + // 给每项数据增加偏移量 + processedData.forEach((d, i) => { + d.offset = (i - midIndex) * offsetStep; + }); + + // 添加斜向延伸路径 + bars.append("path") + .attr("class", "extended-path") + .attr("d", d => { + // 主柱底部两个点 + const topLeftX = 0; + const topLeftY = chartHeight; + const topRightX = barWidth; + const topRightY = chartHeight; + // 底部两个点：在 chartHeight + extensionHeight 上，再加上水平方向 offset + const bottomRightX = barWidth + d.offset; + const bottomRightY = chartHeight + extensionHeight; + const bottomLeftX = 0 + d.offset; + const bottomLeftY = chartHeight + extensionHeight; + + return ` + M ${topLeftX},${topLeftY} + L ${topRightX},${topRightY} + L ${bottomRightX},${bottomRightY} + L ${bottomLeftX},${bottomLeftY} + Z + `; + }) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.8); + + // 添加渐变线条 + bars.append("path") + .attr("class", "gradient-line") + .attr("d", d => { + // 计算斜向延伸的角度 + const angle = Math.atan2(d.offset, extensionHeight); + // 计算线条的起点和终点 + const topX = barWidth / 2; + const topY = chartHeight; + const bottomX = topX + d.offset; + const bottomY = topY + extensionHeight; + + return ` + M ${topX},${topY} + L ${bottomX},${bottomY} + `; + }) + .attr("stroke", "#000") + .attr("stroke-width", 1.5) + .attr("stroke-linecap", "round") + .attr("stroke-opacity", 0.5) + .attr("stroke-dasharray", "5,5"); // 添加虚线效果 + + // 沿线条添加文本 + bars.append("text") + .attr("class", "line-text") + .attr("dy", -3) // 文本垂直偏移 + .attr("text-anchor", "middle") + .style("fill", "#fff") + .style("font-size", "12px") + .style("font-weight", "bold") + .text(d => d.category) + .attr("transform", d => { + // 计算线条靠近起点的位置（从顶部往下约1/3处） + const posX = barWidth / 2 + d.offset / 3; + const posY = chartHeight + extensionHeight / 3; + // 计算文本旋转角度 + let textAngle = -(Math.atan2(d.offset, extensionHeight) * (180 / Math.PI) - 90); + if (textAngle > 90){ + textAngle = textAngle + 180 + } + return `translate(${posX}, ${posY}) rotate(${textAngle})`; + }); + + + // 添加柱体顶部标签 - 自适应字号 + rect 宽度，避免硬编码 40px 溢出到相邻柱 + const LABEL_PAD_X = 4; + const LABEL_PAD_Y = 3; + const LABEL_MAX_FS = 12; + const LABEL_MIN_FS = 7; + const LABEL_GAP_TO_BAR = 6; // rect 距柱顶的间距 + + processedData.forEach(d => { + const txt = chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text; + // 起始字号按 bar 宽度估算 (狭窄 bar 用更小字号) + let fs = Math.max(LABEL_MIN_FS, + Math.min(LABEL_MAX_FS, Math.floor(barWidth * 0.42))); + // 若文字仍超出 barWidth - 2*pad, 继续按比例缩到不溢出或触底 + const maxTextW = Math.max(8, barWidth - 2 * LABEL_PAD_X); + let w = chartUtils.text.measure(null, txt, { fontSize: fs }).width; + while (w > maxTextW && fs > LABEL_MIN_FS) { + fs -= 0.5; + w = chartUtils.text.measure(null, txt, { fontSize: fs }).width; + } + d._labelText = txt; + d._labelFs = fs; + d._labelW = Math.min(barWidth, Math.ceil(w) + 2 * LABEL_PAD_X); + d._labelH = Math.ceil(fs) + 2 * LABEL_PAD_Y; + }); + + bars.append("rect") + .attr("class", "bar-top-label-bg") + .attr("x", d => barWidth / 2 - d._labelW / 2) + .attr("y", d => yScale(d.value) - d._labelH - LABEL_GAP_TO_BAR) + .attr("width", d => d._labelW) + .attr("height", d => d._labelH) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 4) + .attr("ry", 4); + + bars.append("text") + .attr("class", "bar-top-label") + .attr("x", barWidth / 2) + .attr("y", d => yScale(d.value) - d._labelH / 2 - LABEL_GAP_TO_BAR) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .style("font-size", d => `${d._labelFs}px`) + .text(d => d._labelText); + + + // 创建线性渐变定义 + const gradient = chartGroup.append("defs") + .append("linearGradient") + .attr("id", "intersection-gradient") + .attr("x1", "50%") + .attr("y1", "100%") + .attr("x2", "50%") + .attr("y2", "0%"); + + // 添加渐变色标 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0.5); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + // 添加使用渐变的矩形 + chartGroup.append("rect") + .attr("class", "intersection-line") + .attr("x", 0) + .attr("y", chartHeight-20) + .attr("width", chartWidth) + .attr("height", 40) + .attr("fill", "url(#intersection-gradient)") + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17_1.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17_1.js new file mode 100644 index 0000000000000000000000000000000000000000..eb19d3eba99f37d9f8fca10d1d48db7c1d5c434b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_17_1.js @@ -0,0 +1,366 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_17_01", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.number(d, { unit: yUnit, spaceBeforeUnit: true }).text) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + const barWidth = xScale.bandwidth(); + + // 添加主柱体 + bars.append("rect") + .attr("class", "main-bar") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", barWidth) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加斜向延伸部分 + const extensionHeight = 120; // 斜向延伸的高度 + const midIndex = Math.floor(processedData.length / 2); // 中间柱子的索引 + const offsetStep = 30; // 左右柱子每相邻一列，向左右偏移的像素数 + + // 给每项数据增加偏移量 + processedData.forEach((d, i) => { + d.offset = (i - midIndex) * offsetStep; + }); + + // 添加斜向延伸路径 + bars.append("path") + .attr("class", "extended-path") + .attr("d", d => { + // 主柱底部两个点 + const topLeftX = 0; + const topLeftY = chartHeight; + const topRightX = barWidth; + const topRightY = chartHeight; + // 底部两个点：在 chartHeight + extensionHeight 上，再加上水平方向 offset + const bottomRightX = barWidth + d.offset; + const bottomRightY = chartHeight + extensionHeight; + const bottomLeftX = 0 + d.offset; + const bottomLeftY = chartHeight + extensionHeight; + + return ` + M ${topLeftX},${topLeftY} + L ${topRightX},${topRightY} + L ${bottomRightX},${bottomRightY} + L ${bottomLeftX},${bottomLeftY} + Z + `; + }) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.8); + + // 添加渐变线条 + bars.append("path") + .attr("class", "gradient-line") + .attr("d", d => { + // 计算斜向延伸的角度 + const angle = Math.atan2(d.offset, extensionHeight); + // 计算线条的起点和终点 + const topX = barWidth / 2; + const topY = chartHeight; + const bottomX = topX + d.offset; + const bottomY = topY + extensionHeight; + + return ` + M ${topX},${topY} + L ${bottomX},${bottomY} + `; + }) + .attr("stroke", "#000") + .attr("stroke-width", 1.5) + .attr("stroke-linecap", "round") + .attr("stroke-opacity", 0.5) + .attr("stroke-dasharray", "5,5"); // 添加虚线效果 + + // 沿线条添加文本 + bars.append("text") + .attr("class", "line-text") + .attr("dy", -3) // 文本垂直偏移 + .attr("text-anchor", "middle") + .style("fill", "#fff") + .style("font-size", "12px") + .style("font-weight", "bold") + .text(d => d.category) + .attr("transform", d => { + // 计算线条靠近起点的位置（从顶部往下约1/3处） + const posX = barWidth / 2 + d.offset / 3; + const posY = chartHeight + extensionHeight / 3; + // 计算文本旋转角度 + let textAngle = -(Math.atan2(d.offset, extensionHeight) * (180 / Math.PI) - 90); + if (textAngle > 90){ + textAngle = textAngle + 180 + } + return `translate(${posX}, ${posY}) rotate(${textAngle})`; + }); + + + // 添加柱体顶部标签 - 自适应字号 + rect 宽度，避免硬编码 40px 溢出到相邻柱 + const LABEL_PAD_X = 4; + const LABEL_PAD_Y = 3; + const LABEL_MAX_FS = 12; + const LABEL_MIN_FS = 7; + const LABEL_GAP_TO_BAR = 6; + + processedData.forEach(d => { + const txt = chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text; + let fs = Math.max(LABEL_MIN_FS, + Math.min(LABEL_MAX_FS, Math.floor(barWidth * 0.42))); + const maxTextW = Math.max(8, barWidth - 2 * LABEL_PAD_X); + let w = chartUtils.text.measure(null, txt, { fontSize: fs }).width; + while (w > maxTextW && fs > LABEL_MIN_FS) { + fs -= 0.5; + w = chartUtils.text.measure(null, txt, { fontSize: fs }).width; + } + d._labelText = txt; + d._labelFs = fs; + d._labelW = Math.min(barWidth, Math.ceil(w) + 2 * LABEL_PAD_X); + d._labelH = Math.ceil(fs) + 2 * LABEL_PAD_Y; + }); + + bars.append("rect") + .attr("class", "bar-top-label-bg") + .attr("x", d => barWidth / 2 - d._labelW / 2) + .attr("y", d => yScale(d.value) - d._labelH - LABEL_GAP_TO_BAR) + .attr("width", d => d._labelW) + .attr("height", d => d._labelH) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 4) + .attr("ry", 4); + + bars.append("text") + .attr("class", "bar-top-label") + .attr("x", barWidth / 2) + .attr("y", d => yScale(d.value) - d._labelH / 2 - LABEL_GAP_TO_BAR) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .style("font-size", d => `${d._labelFs}px`) + .text(d => d._labelText); + + + // 创建线性渐变定义 + const gradient = chartGroup.append("defs") + .append("linearGradient") + .attr("id", "intersection-gradient") + .attr("x1", "50%") + .attr("y1", "100%") + .attr("x2", "50%") + .attr("y2", "0%"); + + // 添加渐变色标 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0.5); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + // 添加使用渐变的矩形 + chartGroup.append("rect") + .attr("class", "intersection-line") + .attr("x", 0) + .attr("y", chartHeight-20) + .attr("width", chartWidth) + .attr("height", 40) + .attr("fill", "url(#intersection-gradient)") + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18.js new file mode 100644 index 0000000000000000000000000000000000000000..b1fc1d4c7c103759f0fd587e7e65bd201291aea3 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18.js @@ -0,0 +1,416 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_18", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + const barWidth = xScale.bandwidth(); + + // 添加主柱体 + bars.append("rect") + .attr("class", "main-bar") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", barWidth) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加斜向延伸部分 + const extensionHeight = 100; // 斜向延伸的高度 + const midIndex = Math.floor(processedData.length / 2); // 中间柱子的索引 + const offsetStep = 50; // 左右柱子每相邻一列，向左右偏移的像素数 + + // 给每项数据增加偏移量 + processedData.forEach((d, i) => { + d.offset = (i - midIndex) * offsetStep; + }); + + // 添加斜向延伸路径 + bars.append("path") + .attr("class", "extended-path") + .attr("d", d => { + // 主柱底部两个点 + const topLeftX = 0; + const topLeftY = chartHeight; + const topRightX = barWidth; + const topRightY = chartHeight; + + // 计算底部两个点，保持与主体bar chart相同的间距 + // 使用xScale.padding()的值来确定间距比例 + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding) + const paddingWidth = totalWidth * padding + // 计算底部宽度，适当放宽（减小padding效果） + const bottomPadding = padding; // 减小padding效果，放宽间距 + const bottomWidth = totalWidth + offsetStep - paddingWidth; + + // 底部两个点：在 chartHeight + extensionHeight 上，再加上水平方向 offset + const bottomRightX = topRightX + (bottomWidth - barWidth) / 2 + d.offset; + const bottomRightY = chartHeight + extensionHeight; + const bottomLeftX = topLeftX - (bottomWidth - barWidth) / 2 + d.offset; + const bottomLeftY = chartHeight + extensionHeight; + + return ` + M ${topLeftX},${topLeftY} + L ${topRightX},${topRightY} + L ${bottomRightX},${bottomRightY} + L ${bottomLeftX},${bottomLeftY} + Z + `; + }) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.8); + + // 添加底部矩形 + bars.append("rect") + .attr("class", "bottom-rect") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset; + }) + .attr("y", chartHeight + extensionHeight) + .attr("width", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth; + }) + .attr("height", 50) // 底部矩形的高度 + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.9); + + + // 添加底部矩形 + bars.append("image") + .attr("class", "bottom-image") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset; + }) + .attr("y", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return chartHeight + extensionHeight - (totalWidth + offsetStep - paddingWidth); + }) + .attr("width", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth; + }) + .attr("xlink:href", d => jsonData.images.field[d.category]) + + + // 在底部矩形中添加文本 + bars.append("text") + .attr("class", "bottom-text") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset + (bottomWidth / 2); + }) + .attr("y", chartHeight + extensionHeight + 25) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .each(function(d) { + const text = d3.select(this); + const textContent = d.category; + const maxWidth = d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth - 10; // 减去10px的边距 + }; + + // 计算文本宽度 + const availableWidth = maxWidth(d); + let fontSize = 12; // 初始字体大小 + let textWidth = chartUtils.text.measure(null, textContent, { fontSize: `${fontSize}px Arial` }).width; + + // 如果文本宽度超过可用宽度，逐步减小字体大小 + while (textWidth > availableWidth && fontSize > 8) { + fontSize -= 1; + textWidth = chartUtils.text.measure(null, textContent, { fontSize: `${fontSize}px Arial` }).width; + } + + // 设置最终的字体大小和文本内容 + text.style("font-size", `${fontSize}px`) + .text(textContent); + }); + + // 添加渐变线条 + bars.append("path") + .attr("class", "gradient-line") + .attr("d", d => { + // 计算斜向延伸的角度 + const angle = Math.atan2(d.offset, extensionHeight); + // 计算线条的起点和终点 + const topX = barWidth / 2; + const topY = chartHeight; + const bottomX = topX + d.offset; + const bottomY = topY + extensionHeight; + + return ` + M ${topX},${topY} + L ${bottomX},${bottomY} + `; + }) + .attr("stroke", "#000") + .attr("stroke-width", 1.5) + .attr("stroke-linecap", "round") + .attr("stroke-opacity", 0.5) + .attr("stroke-dasharray", "5,5"); // 添加虚线效果 + + // 添加柱体顶部标签 + bars.append("rect") + .attr("x", barWidth / 2 - 20) + .attr("y", d => yScale(d.value) - 35) + .attr("width", 40) + .attr("height", 20) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 4) + .attr("ry", 4); + + bars.append("text") + .attr("class", "bar-top-label") + .attr("x", barWidth / 2) + .attr("y", d => yScale(d.value) - 22) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .text(d => chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text); + + + // 创建线性渐变定义 + const gradient = chartGroup.append("defs") + .append("linearGradient") + .attr("id", "intersection-gradient") + .attr("x1", "50%") + .attr("y1", "100%") + .attr("x2", "50%") + .attr("y2", "0%"); + + // 添加渐变色标 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0.5); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + // 添加使用渐变的矩形 + chartGroup.append("rect") + .attr("class", "intersection-line") + .attr("x", 0) + .attr("y", chartHeight-20) + .attr("width", chartWidth) + .attr("height", 40) + .attr("fill", "url(#intersection-gradient)") + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18_1.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18_1.js new file mode 100644 index 0000000000000000000000000000000000000000..22d90f14ef585aa736b239c40c0facd711d269f4 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_18_1.js @@ -0,0 +1,416 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_18_01", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + const barWidth = xScale.bandwidth(); + + // 添加主柱体 + bars.append("rect") + .attr("class", "main-bar") + .attr("x", 0) + .attr("y", d => yScale(d.value)) + .attr("width", barWidth) + .attr("height", d => chartHeight - yScale(d.value)) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加斜向延伸部分 + const extensionHeight = 100; // 斜向延伸的高度 + const midIndex = Math.floor(processedData.length / 2); // 中间柱子的索引 + const offsetStep = 50; // 左右柱子每相邻一列，向左右偏移的像素数 + + // 给每项数据增加偏移量 + processedData.forEach((d, i) => { + d.offset = (i - midIndex) * offsetStep; + }); + + // 添加斜向延伸路径 + bars.append("path") + .attr("class", "extended-path") + .attr("d", d => { + // 主柱底部两个点 + const topLeftX = 0; + const topLeftY = chartHeight; + const topRightX = barWidth; + const topRightY = chartHeight; + + // 计算底部两个点，保持与主体bar chart相同的间距 + // 使用xScale.padding()的值来确定间距比例 + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding) + const paddingWidth = totalWidth * padding + // 计算底部宽度，适当放宽（减小padding效果） + const bottomPadding = padding; // 减小padding效果，放宽间距 + const bottomWidth = totalWidth + offsetStep - paddingWidth; + + // 底部两个点：在 chartHeight + extensionHeight 上，再加上水平方向 offset + const bottomRightX = topRightX + (bottomWidth - barWidth) / 2 + d.offset; + const bottomRightY = chartHeight + extensionHeight; + const bottomLeftX = topLeftX - (bottomWidth - barWidth) / 2 + d.offset; + const bottomLeftY = chartHeight + extensionHeight; + + return ` + M ${topLeftX},${topLeftY} + L ${topRightX},${topRightY} + L ${bottomRightX},${bottomRightY} + L ${bottomLeftX},${bottomLeftY} + Z + `; + }) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.8); + + // 添加底部矩形 + bars.append("rect") + .attr("class", "bottom-rect") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset; + }) + .attr("y", chartHeight + extensionHeight) + .attr("width", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth; + }) + .attr("height", 50) // 底部矩形的高度 + .attr("fill", (d, i) => colorScale(d, i)) + .attr("opacity", 0.9); + + + // 添加底部矩形 + bars.append("image") + .attr("class", "bottom-image") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset; + }) + .attr("y", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return chartHeight + extensionHeight - (totalWidth + offsetStep - paddingWidth); + }) + .attr("width", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth; + }) + .attr("xlink:href", d => jsonData.images.field[d.category]) + + + // 在底部矩形中添加文本 + bars.append("text") + .attr("class", "bottom-text") + .attr("x", d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + const bottomWidth = totalWidth + offsetStep - paddingWidth; + return -((bottomWidth - barWidth) / 2) + d.offset + (bottomWidth / 2); + }) + .attr("y", chartHeight + extensionHeight + 25) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .each(function(d) { + const text = d3.select(this); + const textContent = d.category; + const maxWidth = d => { + const padding = xScale.padding(); + const totalWidth = xScale.bandwidth() * (1 + padding); + const paddingWidth = totalWidth * padding; + return totalWidth + offsetStep - paddingWidth - 10; // 减去10px的边距 + }; + + // 计算文本宽度 + const availableWidth = maxWidth(d); + let fontSize = 12; // 初始字体大小 + let textWidth = chartUtils.text.measure(null, textContent, { fontSize: `${fontSize}px Arial` }).width; + + // 如果文本宽度超过可用宽度，逐步减小字体大小 + while (textWidth > availableWidth && fontSize > 8) { + fontSize -= 1; + textWidth = chartUtils.text.measure(null, textContent, { fontSize: `${fontSize}px Arial` }).width; + } + + // 设置最终的字体大小和文本内容 + text.style("font-size", `${fontSize}px`) + .text(textContent); + }); + + // 添加渐变线条 + bars.append("path") + .attr("class", "gradient-line") + .attr("d", d => { + // 计算斜向延伸的角度 + const angle = Math.atan2(d.offset, extensionHeight); + // 计算线条的起点和终点 + const topX = barWidth / 2; + const topY = chartHeight; + const bottomX = topX + d.offset; + const bottomY = topY + extensionHeight; + + return ` + M ${topX},${topY} + L ${bottomX},${bottomY} + `; + }) + .attr("stroke", "#000") + .attr("stroke-width", 1.5) + .attr("stroke-linecap", "round") + .attr("stroke-opacity", 0.5) + .attr("stroke-dasharray", "5,5"); // 添加虚线效果 + + // 添加柱体顶部标签 + bars.append("rect") + .attr("x", barWidth / 2 - 20) + .attr("y", d => yScale(d.value) - 35) + .attr("width", 40) + .attr("height", 20) + .attr("fill", (d, i) => colorScale(d, i)) + .attr("rx", 4) + .attr("ry", 4); + + bars.append("text") + .attr("class", "bar-top-label") + .attr("x", barWidth / 2) + .attr("y", d => yScale(d.value) - 22) + .style("fill", "#fff") + .style("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-weight", "bold") + .text(d => chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text); + + + // 创建线性渐变定义 + const gradient = chartGroup.append("defs") + .append("linearGradient") + .attr("id", "intersection-gradient") + .attr("x1", "50%") + .attr("y1", "100%") + .attr("x2", "50%") + .attr("y2", "0%"); + + // 添加渐变色标 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0.5); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#000") + .attr("stop-opacity", 0); + + // 添加使用渐变的矩形 + chartGroup.append("rect") + .attr("class", "intersection-line") + .attr("x", 0) + .attr("y", chartHeight-20) + .attr("width", chartWidth) + .attr("height", 40) + .attr("fill", "url(#intersection-gradient)") + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_19_1.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_19_1.js new file mode 100644 index 0000000000000000000000000000000000000000..09aa9b38642200148da853fc4b1db54cd5ab951f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_19_1.js @@ -0,0 +1,250 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_19_01", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 10], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([chartHeight, 0]) + .nice(); + + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === 0) { + // 第一个柱子使用更深的颜色 + return colorResolver.variant(colorResolver.other("primary").value, { mode: "darker", amount: 0.7 }); + } + // 其他柱子使用primary颜色 + return colorResolver.other("primary").value; + }; + + + // 确定标签的最大长度： + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + const imageBase64 = "data:image/png;base64,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" + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)}, 0)`); + + // 计算图片的宽高比 + const imgAspectRatio = 1 + + // 为每个柱子添加图片叠加 + bars.each(function(d) { + const barHeight = chartHeight - yScale(d.value); + const barWidth = xScale.bandwidth(); + + // 计算单个图片的尺寸 + const imgWidth = barWidth; + const imgHeight = imgWidth / imgAspectRatio; + + // 计算需要叠加的图片数量 + const numImages = Math.ceil(barHeight / imgHeight)/0.353; + + // 创建图片叠加 + for (let i = 0; i < numImages; i++) { + d3.select(this) + .append("image") + .attr("xlink:href", imageBase64) + .attr("x", 0) + .attr("y", chartHeight-imgHeight*0.7 - (i + 1) * imgHeight*0.353) + .attr("width", imgWidth) + .attr("height", imgHeight); + } + }); + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.category) + xScale.bandwidth() / 2) + .attr("y", d => { + // 计算图片堆叠的实际高度 + const barHeight = chartHeight - yScale(d.value); + const imgWidth = xScale.bandwidth(); + const imgHeight = imgWidth / imgAspectRatio; + const numImages = Math.ceil(barHeight / imgHeight) / 0.353; + const stackHeight = numImages * imgHeight * 0.353; + + // 确保标签位于图片堆叠的顶部上方 + return chartHeight - stackHeight - imgHeight-10; + }) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text) + .style("opacity", 1); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_23.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_23.js new file mode 100644 index 0000000000000000000000000000000000000000..e356d4b90230923987e08f81a2a8a691715fa3e2 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_23.js @@ -0,0 +1,521 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_23", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 10], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 使用D3.js创建简单的垂直条形图 plain chart#3 顶端三角形 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列 + + // 数值格式化函数 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + xField = xChannel.key; + yField = yChannel.key; + + // 获取字段单位(如果存在) + if (xChannel.unit) { + xUnit = xChannel.unit; + } + + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField] // 确保y是数值类型 + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colorResolver.other("primary").value; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.1 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.1 })); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = measureTextWidth(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 10; // 标签开始的 Y 位置 (靠近柱子底部) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加柱子 (修改高度) + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("path") + .attr("class", "bar") + .attr("d", d => { + const x = xScale(d.x); + const y = yScale(d.y); + const width = xScale.bandwidth(); + const height = Math.max(0, innerHeight - yScale(d.y)); + + // 如果高度为0，返回空路径 + if (height <= 0) return ""; + + // 三角形的高度，设置为条形图宽度，但最小10px，最大30px + const triangleHeight = Math.min(30, Math.max(10, width)); + + // 确保三角形高度不超过总高度 + const actualTriangleHeight = Math.min(triangleHeight, height); + + // 矩形部分的高度 + const rectHeight = height - actualTriangleHeight; + + // 构建路径 + // 从左下角开始 + let path = `M ${x} ${innerHeight}`; + + // 到左上角（矩形顶部） + path += ` L ${x} ${y + actualTriangleHeight}`; + + // 到三角形左侧点 + path += ` L ${x + width * 0} ${y + actualTriangleHeight}`; + + // 到三角形顶点 + path += ` L ${x + width / 2} ${y}`; + + // 到三角形右侧点 + path += ` L ${x + width * 1} ${y + actualTriangleHeight}`; + + // 到右上角（矩形顶部） + path += ` L ${x + width} ${y + actualTriangleHeight}`; + + // 到右下角 + path += ` L ${x + width} ${innerHeight}`; + + // 闭合路径 + path += ` Z`; + + return path; + }) + .attr("fill", d => { + if (variables.has_gradient) { + const safeCategory = typeof d.x === 'string' ? + d.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${sortedData.findIndex(item => item.x === d.x)}`; // 修正: 使用 findIndex 确保唯一性 + return `url(#gradient-${safeCategory})`; + } + return getColor(); + }) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const valueText = chartUtils.format.autoText(d.y) + (yUnit ? ` ${yUnit}` : ''); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = measureTextWidth(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加图标 (移除圆形) - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-group") // 修改类名以反映不再是圆形 + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-group") // 修改类名 + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_24.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_24.js new file mode 100644 index 0000000000000000000000000000000000000000..39df12807dc6e23c4367e0312a588299748009ad --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_bar_chart_24.js @@ -0,0 +1,518 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Bar Chart", + "chart_name": "vertical_bar_chart_24", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 10], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 使用D3.js创建简单的垂直条形图 plain chart#5 曲线形 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列 + + // 数值格式化函数 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + xField = xChannel.key; + yField = yChannel.key; + + // 获取字段单位(如果存在) + if (xChannel.unit) { + xUnit = xChannel.unit; + } + + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField] // 确保y是数值类型 + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colorResolver.other("primary").value; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.1 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.1 })); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(0); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = measureTextWidth(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 10; // 标签开始的 Y 位置 (靠近柱子底部) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加柱子 (修改为高斯曲线型) + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("path") + .attr("class", "bar") + .attr("d", d => { + const x_start = xScale(d.x); + const y_top = yScale(d.y); + const bar_width = xScale.bandwidth(); + const bar_height = Math.max(0, innerHeight - y_top); + + // 如果高度为0，返回空路径 + if (bar_height <= 0) return ""; + + // 高斯曲线参数 + const x_center = x_start + bar_width / 2; + const y_bottom = innerHeight; + const half = bar_width / 2; + const sigma = half / 3.2; // 让 ±3σ ≈ half，曲线边缘落在条形图边界内 + const samples = 50; // 采样点数 + + // 高斯函数 + function gaussian(x, s = 1) { + return Math.exp(-(x * x) / (2 * s * s)); + } + + // 生成采样点 + const points = []; + const step = (half * 2) / samples; + + for (let i = 0; i <= samples; i++) { + const t = -half + i * step; + const x_point = x_center + t; + const gauss_value = gaussian(t, sigma); + const y_point = y_bottom - (bar_height * gauss_value); + points.push({x: x_point, y: y_point}); + } + + // 使用d3.area()创建路径 + const area = d3.area() + .x(p => p.x) + .y0(y_bottom) // 底部基线 + .y1(p => p.y) // 曲线顶部 + .curve(d3.curveBasis); // 平滑曲线 + + return area(points); + }) + .attr("fill", d => { + if (variables.has_gradient) { + const safeCategory = typeof d.x === 'string' ? + d.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${sortedData.findIndex(item => item.x === d.x)}`; // 修正: 使用 findIndex 确保唯一性 + return `url(#gradient-${safeCategory})`; + } + return getColor(); + }) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const valueText = chartUtils.format.autoText(d.y) + (yUnit ? ` ${yUnit}` : ''); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = measureTextWidth(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = measureTextWidth(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (measureTextWidth(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加图标 (移除圆形) - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-group") // 修改类名以反映不再是圆形 + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-group") // 修改类名 + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_dot_bar_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_dot_bar_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..b95e841e1f346149d49ad6a67aadcc437a928224 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_dot_bar_chart_01.js @@ -0,0 +1,477 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Dot Bar Chart", + "chart_name": "vertical_dot_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 6], [3, 20]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["shadow", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colorResolver = chartUtils.color.resolver(jsonData); + const fontFamily = typography.label.font_family || "Arial"; + const annotationFamily = typography.annotation.font_family || fontFamily; + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const dimensionField = xChannel.key || xChannel.raw?.name || "dimension"; + const valueField = yChannel.key || yChannel.raw?.name || "value"; + const dimensionColumn = xChannel.raw || {}; + const valueColumn = yChannel.raw || {}; + const valueUnit = valueColumn.unit && valueColumn.unit !== "none" ? valueColumn.unit : ""; + const primaryColor = colorResolver.other("primary", { fallback: "#0B64B0" }).value; + const palette = [ + "#073F80", + "#D52E38", + "#176DB8", + "#0A3767", + "#1F80CD", + "#F4B51E", + "#268C64", + "#E66E2D", + "#7648B8", + "#2A9AA5", + primaryColor + ]; + + const measureText = (text, fontSize, fontWeight = "500", family = fontFamily) => { + const canvas = document.createElement("canvas"); + const ctx = canvas.getContext("2d"); + ctx.font = `${fontWeight} ${fontSize}px ${family}`; + return chartUtils.text.contextWidth(ctx, String(text)); + }; + + const fitFont = (text, maxWidth, baseSize, minSize = 6, fontWeight = "600", family = fontFamily) => { + let size = baseSize; + while (size > minSize && measureText(text, size, fontWeight, family) > maxWidth) { + size -= 0.5; + } + return Math.max(minSize, size); + }; + + const applyTextFit = (selection, text, maxWidth, fontSize, fontWeight = "600", family = fontFamily) => { + selection.text(text); + if (measureText(text, fontSize, fontWeight, family) > maxWidth) { + selection.attr("textLength", maxWidth).attr("lengthAdjust", "spacingAndGlyphs"); + } + }; + + const formatLocalValue = (value) => { + if (Math.abs(value) >= 1000000000) return d3.format("~g")(value / 1000000000) + "B"; + if (Math.abs(value) >= 1000000) return d3.format("~g")(value / 1000000) + "M"; + if (Math.abs(value) >= 1000) return d3.format("~g")(value / 1000) + "K"; + return d3.format("~g")(value); + }; + + const formatValueWithUnit = (value) => { + const formatted = formatLocalValue(value); + const unit = String(valueUnit || "").trim(); + if (!unit) return formatted; + if (unit === "$") return `$${formatted}`; + if (unit.startsWith("$")) return `$${formatted}${unit.slice(1)}`; + if (unit === "%") return `${formatted}%`; + return `${formatted}${unit}`; + }; + + const labelTokens = (text) => String(text) + .replace(/[()[\]{}]/g, " ") + .replace(/[,:;/\\|_-]+/g, " ") + .split(/\s+/) + .map(token => token.trim()) + .filter(Boolean); + + const splitLabel = (text, maxWidth, fontSize) => { + const str = String(text || "").trim(); + const tokens = labelTokens(str); + if (tokens.length <= 1) return [str]; + const lines = []; + let current = ""; + tokens.forEach(token => { + const next = current ? `${current} ${token}` : token; + if (lines.length < 1 && measureText(next, fontSize, "700", fontFamily) <= maxWidth) { + current = next; + } else if (lines.length < 1) { + if (current) lines.push(current); + current = token; + } else { + current = current ? `${current} ${token}` : token; + } + }); + if (current) lines.push(current); + return lines.slice(0, 2); + }; + + const temporalKey = (value) => { + if (value instanceof Date) return value.getTime(); + if (typeof value === "number") return value; + const str = String(value || "").trim(); + const lower = str.toLowerCase(); + const seasonOrder = { spring: 0, summer: 1, fall: 2, autumn: 2, winter: 3 }; + if (seasonOrder[lower] !== undefined) return seasonOrder[lower]; + const monthOrder = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, + sep: 9, sept: 9, september: 9, oct: 10, october: 10, + nov: 11, november: 11, dec: 12, december: 12 + }; + if (monthOrder[lower] !== undefined) return monthOrder[lower]; + const yearSeason = lower.match(/^(-?\d{1,4})\s+(winter|spring|summer|fall|autumn)$/); + if (yearSeason) return (+yearSeason[1]) * 10 + seasonOrder[yearSeason[2]]; + const seasonYear = lower.match(/^(winter|spring|summer|fall|autumn)\s+(-?\d{1,4})$/); + if (seasonYear) return (+seasonYear[2]) * 10 + seasonOrder[seasonYear[1]]; + const parsed = Date.parse(str); + if (!Number.isNaN(parsed) && /[-/]|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/i.test(str)) return parsed; + if (/^-?\d{4}$/.test(str)) return +str; + return null; + }; + + const looksTemporal = () => { + const name = String(dimensionField || dimensionColumn.name || "").toLowerCase(); + if (/year|date|month|season|quarter|time/.test(name)) return true; + const validKeys = chartData.map(d => temporalKey(d[dimensionField])).filter(v => v !== null); + return chartData.length > 0 && validKeys.length === chartData.length; + }; + + d3.select(containerSelector).html(""); + + const width = variables.width || 800; + const height = variables.height || 600; + const normalizedData = chartData.map((d, index) => ({ + ...d, + __index: index, + __dimension: d[dimensionField], + __rawValue: Math.max(0, +d[valueField] || 0), + __temporalKey: temporalKey(d[dimensionField]) + })); + const isTemporal = dimensionColumn.data_type === "temporal" || looksTemporal(); + const sortedData = [...normalizedData].sort((a, b) => { + if (isTemporal) { + return d3.ascending(a.__temporalKey, b.__temporalKey) || d3.ascending(a.__index, b.__index); + } + return d3.descending(a.__rawValue, b.__rawValue) || d3.ascending(a.__index, b.__index); + }).slice(0, 12); + const sortedDimensions = sortedData.map(d => d.__dimension); + const maxValue = d3.max(sortedData, d => d.__rawValue) || 0; + const tickStep = maxValue <= 20 ? 5 : maxValue <= 60 ? 10 : Math.ceil(maxValue / 5 / 10) * 10; + const niceMax = Math.max(tickStep, Math.ceil(maxValue / tickStep) * tickStep); + const ticks = d3.range(0, niceMax + tickStep * 0.5, tickStep); + const maxVisibleMarks = 22; + const directCounts = maxValue <= maxVisibleMarks; + sortedData.forEach(d => { + if (d.__rawValue <= 0 || maxValue <= 0) { + d.__dotCount = 0; + } else if (directCounts) { + d.__dotCount = Math.max(1, Math.round(d.__rawValue)); + } else { + d.__dotCount = Math.max(1, Math.round(d.__rawValue / maxValue * maxVisibleMarks)); + } + }); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", "vertical-dot-card-shadow") + .attr("x", "-8%") + .attr("y", "-8%") + .attr("width", "116%") + .attr("height", "116%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 9) + .attr("flood-color", "#4B79A0") + .attr("flood-opacity", 0.15); + + sortedData.forEach((d, index) => { + const accent = palette[index % palette.length]; + const grad = defs.append("linearGradient") + .attr("id", `vertical-dot-value-gradient-${index}`) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + grad.append("stop").attr("offset", "0%").attr("stop-color", chartUtils.color.variant(accent, { mode: "darker", amount: 0.16 })); + grad.append("stop").attr("offset", "100%").attr("stop-color", chartUtils.color.variant(accent, { mode: "brighter", amount: 0.18 })); + }); + + svg.append("rect") + .attr("class", "vertical-dot-canvas") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "#F5FAFF"); + + const panelX = 28; + const panelY = 18; + const panelW = width - panelX * 2; + const panelH = height - 48; + svg.append("rect") + .attr("class", "chart-panel") + .attr("x", panelX) + .attr("y", panelY) + .attr("width", panelW) + .attr("height", panelH) + .attr("rx", 22) + .attr("ry", 22) + .attr("fill", "#FFFFFF") + .attr("stroke", "#CFE0EF") + .attr("stroke-width", 1.2) + .attr("filter", "url(#vertical-dot-card-shadow)"); + + const axisPad = 50; + const plotLeft = panelX + axisPad; + const plotRight = panelX + panelW - 22; + const headerLabelY = panelY + 48; + const headerIconY = panelY + 100; + const plotTop = panelY + 145; + const plotBottom = panelY + panelH - 88; + const valueBaseY = panelY + panelH - 70; + const xScale = d3.scaleBand() + .domain(sortedDimensions) + .range([plotLeft, plotRight]) + .padding(sortedData.length > 7 ? 0.18 : 0.10); + const yScale = d3.scaleLinear() + .domain([0, niceMax]) + .range([plotBottom, plotTop]); + + ticks.forEach(tick => { + const y = yScale(tick); + svg.append("line") + .attr("class", "grid-line") + .attr("x1", plotLeft - 5) + .attr("x2", plotRight) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", "#BAD0E5") + .attr("stroke-width", tick === 0 ? 1.4 : 1) + .attr("stroke-dasharray", tick === 0 ? null : "5 5") + .attr("opacity", tick === 0 ? 0.85 : 0.65); + svg.append("text") + .attr("class", "axis-tick-label") + .attr("x", plotLeft - 12) + .attr("y", y + 4) + .attr("text-anchor", "end") + .style("font-family", annotationFamily) + .style("font-size", "13px") + .style("font-weight", "600") + .style("fill", "#516B89") + .text(`${formatLocalValue(tick)}${valueUnit === "%" ? "%" : ""}`); + }); + + const columnMaxW = xScale.bandwidth(); + const maxDotCount = d3.max(sortedData, d => d.__dotCount) || 1; + const markerSize = Math.max(18, Math.min(35, columnMaxW * 0.34, (plotBottom - plotTop) / Math.max(8, maxDotCount) - 2)); + const markerGap = Math.max(3, Math.min(8, markerSize * 0.22)); + const valuePillH = 46; + + sortedData.forEach((dataPoint, dataIndex) => { + const dimension = dataPoint.__dimension; + const centerX = xScale(dimension) + xScale.bandwidth() / 2; + const bandX = xScale(dimension); + const bandW = xScale.bandwidth(); + const accent = palette[dataIndex % palette.length]; + const iconHref = jsonData.images?.field?.[dimension]; + const labelMaxWidth = Math.max(48, bandW * 0.94); + const labelBaseSize = Math.max(9, Math.min(16, bandW / 7.2)); + const labelLines = splitLabel(dimension, labelMaxWidth, labelBaseSize); + + svg.append("rect") + .attr("class", "category-band") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("x", bandX + 2) + .attr("y", plotTop - 8) + .attr("width", Math.max(2, bandW - 4)) + .attr("height", plotBottom - plotTop + valuePillH + 22) + .attr("rx", Math.min(18, bandW / 6)) + .attr("fill", dataIndex % 2 === 0 ? "#F0F7FD" : "#F8FBFE") + .attr("opacity", 0.92); + + const label = svg.append("text") + .attr("class", "category-label") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("x", centerX) + .attr("y", headerLabelY) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-weight", "800") + .style("fill", "#0B2148"); + labelLines.forEach((line, lineIndex) => { + const lineSize = fitFont(line, labelMaxWidth, labelBaseSize, 7, "800", fontFamily); + const tspan = label.append("tspan") + .attr("x", centerX) + .attr("dy", lineIndex === 0 ? 0 : `${lineSize + 2}px`) + .style("font-size", `${lineSize}px`); + applyTextFit(tspan, line, labelMaxWidth, lineSize, "800", fontFamily); + }); + + const headerR = Math.max(17, Math.min(27, bandW * 0.22)); + svg.append("circle") + .attr("class", "category-icon-frame") + .attr("data-asset-source", iconHref ? "input_field_icon" : "neutral_fallback") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("cx", centerX) + .attr("cy", headerIconY) + .attr("r", headerR) + .attr("fill", "#FFFFFF") + .attr("stroke", "#D3E2F0") + .attr("stroke-width", 1.5); + if (iconHref) { + const clipId = `vertical-dot-header-clip-${dataIndex}`; + defs.append("clipPath") + .attr("id", clipId) + .append("circle") + .attr("cx", centerX) + .attr("cy", headerIconY) + .attr("r", headerR - 2); + svg.append("image") + .attr("class", "category-icon-image") + .attr("data-asset-source", "input_field_icon") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("x", centerX - headerR + 2) + .attr("y", headerIconY - headerR + 2) + .attr("width", (headerR - 2) * 2) + .attr("height", (headerR - 2) * 2) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("clip-path", `url(#${clipId})`) + .attr("xlink:href", iconHref); + } else { + svg.append("text") + .attr("class", "category-icon-letter") + .attr("x", centerX) + .attr("y", headerIconY + 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFamily) + .style("font-size", `${headerR * 0.82}px`) + .style("font-weight", "850") + .style("fill", accent) + .text(String(dimension).trim().charAt(0).toUpperCase() || "?"); + } + + const step = markerSize + markerGap; + for (let dotIndex = 0; dotIndex < dataPoint.__dotCount; dotIndex++) { + const y = plotBottom - markerSize - dotIndex * step; + if (y < plotTop + 2) break; + if (iconHref) { + const clipId = `vertical-dot-mark-clip-${dataIndex}-${dotIndex}`; + defs.append("clipPath") + .attr("id", clipId) + .append("circle") + .attr("cx", centerX) + .attr("cy", y + markerSize / 2) + .attr("r", markerSize / 2); + svg.append("circle") + .attr("class", "mark icon-dot-frame") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("data-value", dataPoint.__rawValue) + .attr("data-dot-index", dotIndex) + .attr("cx", centerX) + .attr("cy", y + markerSize / 2) + .attr("r", markerSize / 2) + .attr("fill", "#FFFFFF") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 2) + .attr("filter", "url(#vertical-dot-card-shadow)"); + svg.append("image") + .attr("class", "mark icon-dot") + .attr("data-asset-source", "input_field_icon") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("data-value", dataPoint.__rawValue) + .attr("data-dot-index", dotIndex) + .attr("x", centerX - markerSize / 2) + .attr("y", y) + .attr("width", markerSize) + .attr("height", markerSize) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("clip-path", `url(#${clipId})`) + .attr("xlink:href", iconHref); + } else { + svg.append("circle") + .attr("class", "mark fallback-dot") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("data-value", dataPoint.__rawValue) + .attr("data-dot-index", dotIndex) + .attr("cx", centerX) + .attr("cy", y + markerSize / 2) + .attr("r", markerSize / 2) + .attr("fill", accent) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 2); + } + } + + const pillW = Math.max(54, Math.min(bandW * 0.92, 94)); + const pillX = centerX - pillW / 2; + svg.append("rect") + .attr("class", "value-base-pill") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("data-value", dataPoint.__rawValue) + .attr("x", pillX) + .attr("y", valueBaseY) + .attr("width", pillW) + .attr("height", valuePillH) + .attr("rx", 9) + .attr("ry", 9) + .attr("fill", `url(#vertical-dot-value-gradient-${dataIndex})`); + + const formattedValue = formatValueWithUnit(dataPoint.__rawValue); + const valueSize = fitFont(formattedValue, pillW - 10, 26, 11, "850", annotationFamily); + const valueText = svg.append("text") + .attr("class", "value-label") + .attr("data-source-index", dataPoint.__index) + .attr("data-category", String(dimension)) + .attr("data-value", dataPoint.__rawValue) + .attr("x", centerX) + .attr("y", valueBaseY + valuePillH / 2 + valueSize * 0.35) + .attr("text-anchor", "middle") + .style("font-family", annotationFamily) + .style("font-size", `${valueSize}px`) + .style("font-weight", "850") + .style("fill", "#FFFFFF"); + applyTextFit(valueText, formattedValue, pillW - 10, valueSize, "850", annotationFamily); + + svg.append("title").text(`${dimension}: ${formattedValue}`); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..eb7ab44bfa250e809fdff7e95798265b99619f88 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_0.js @@ -0,0 +1,370 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_plain_chart_01", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [2, 4]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值单位规范 + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField]) || 1]) // Ensure domain is not [0,0] + .range([chartHeight, 0]) + .nice(); + // +++ 辅助函数区 +++ + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return chartUtils.text.contextWidth(ctx, text); + } + + const calculateFontSize = (text, maxWidth, baseSize = 14) => { + if (!text || typeof text !== 'string' || !maxWidth || maxWidth <= 0 || !baseSize || baseSize <= 0) { + return Math.max(10, baseSize || 14); + } + const avgCharWidth = baseSize * 0.6; + const textWidth = text.length * avgCharWidth; + if (textWidth < maxWidth) { + return baseSize; + } + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + function wrapText(textElement, str, width, lineHeight = 1.1, alignment = 'middle') { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const initialY = parseFloat(textElement.attr("data-initial-y")); // 从data属性获取初始Y + // const initialX = parseFloat(textElement.attr("x")); // 这一行应该被注释掉或移除 + + textElement.text(null); + let tspans = []; + + if (words.length > 1) { + let currentLine = []; + while (word = words.pop()) { + currentLine.push(word); + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: textElement.style("font-family"), + fontSize: parseFloat(textElement.style("font-size")), + fontWeight: textElement.style("font-weight") + }).width > width; + if (isOverflow && currentLine.length > 1) { + currentLine.pop(); + tspans.push(currentLine.join(" ")); + currentLine = [word]; + lineNumber++; + } + } + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } else { + const chars = str.split(''); + let currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const nextLine = currentLine + chars[i]; + const isOverflow = chartUtils.text.measure(null, nextLine, { + fontFamily: textElement.style("font-family"), + fontSize: parseFloat(textElement.style("font-size")), + fontWeight: textElement.style("font-weight") + }).width > width; + if (isOverflow && currentLine.length > 0) { + tspans.push(currentLine); + currentLine = chars[i]; + lineNumber++; + } else { + currentLine = nextLine; + } + } + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } + + const totalLines = tspans.length; + let startDy = 0; + textElement.attr("y", initialY); // 重置Y到初始值 + + if (alignment === 'middle') { + startDy = -( (totalLines - 1) * lineHeight / 2); + } else if (alignment === 'bottom') { + const totalHeightEm = totalLines * lineHeight; + startDy = -(totalHeightEm - lineHeight); + } + + tspans.forEach((lineText, i) => { + textElement.append("tspan") + // .attr("x", initialX) // 关键：确保这一行被注释掉或移除 + .attr("dy", (i === 0 ? startDy : lineHeight) + "em") + .text(lineText); + }); + textElement.attr("data-lines", totalLines); + } + // +++ 辅助函数区结束 +++ + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xCategories = processedData.map(d => d.category); + const baseLabelFontSize = parseFloat(typography.label.font_size) || 14; + const xLabelMaxWidth = xScale.bandwidth() * 0.95; + const longestXLabel = xCategories.reduce((a, b) => String(a).length > String(b).length ? a : b, "").toString(); + const uniformXLabelFontSize = calculateFontSize(longestXLabel, xLabelMaxWidth, baseLabelFontSize); + + // +++ Pre-calculate for Value Labels +++ + let longestValueLabelStr = ""; + processedData.forEach(pd => { + groups.forEach(group => { + const value = pd.groups[group] || 0; + const labelStr = chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : ''); + if (labelStr.length > longestValueLabelStr.length) { + longestValueLabelStr = labelStr; + } + }); + }); + const baseValueLabelFontSize = parseFloat(typography.annotation.font_size) || 12; // Use annotation font size as base + const valueLabelMaxWidth = groupScale.bandwidth(); + const uniformValueLabelFontSize = calculateFontSize(longestValueLabelStr, valueLabelMaxWidth, baseValueLabelFontSize); + // +++ End Pre-calculate for Value Labels +++ + + const xAxis = d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加标签和轴线的间距 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll(".tick text") // 选择刻度文本 + .attr("data-initial-y", typography.label.font_size) + .style("font-family", typography.label.font_family) + .style("font-size", `${uniformXLabelFontSize}px`) + .style("text-anchor", "middle") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const textElement = d3.select(this); + wrapText(textElement, String(d), xLabelMaxWidth, 1.1, 'top'); + }); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + // .style("font-family", typography.label.font_family) + // .style("font-size", typography.label.font_size) + // .style("fill", colorResolver.text({ fallback: "#333333" }).value) + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + barGroups.append("rect") + .attr("class", "bar") + .attr("x", d => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.groups[group] || 0)) + .attr("fill", colorResolver.field(group, 0, { fallbackKey: "primary" }).value); + + // 添加数值标签 + barGroups.append("text") + .attr("class", "label") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${uniformValueLabelFontSize}px`) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .attr("data-initial-y", d => yScale(d.groups[group] || 0)-5) + .each(function(d_barGroup) { + const textElement = d3.select(this); + const value = d_barGroup.groups[group] || 0; + const labelText = chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : ''); + textElement.attr("x", groupScale(group) + groupScale.bandwidth() / 2); + wrapText(textElement, labelText, valueLabelMaxWidth, 1.1, 'bottom'); + }); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_1.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_1.js new file mode 100644 index 0000000000000000000000000000000000000000..f4bfe25f5b10ab2665391707ed343c895dff4c19 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_1.js @@ -0,0 +1,389 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 100], [3, 20]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" } + }; + const columns = chartUtils.schema.columns(jsonData); + const xChannel = chartUtils.schema.channel(jsonData, "x") || {}; + const yChannel = chartUtils.schema.channel(jsonData, "y") || {}; + const groupChannel = chartUtils.schema.channel(jsonData, "group") || {}; + const xField = xChannel.key || "period"; + const yField = yChannel.key || "value"; + const groupField = groupChannel.key || "group"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const width = variables.width || 600; + const height = Math.max(560, variables.height || 600); + const navy = "#071b4d"; + const axisNavy = "#13244a"; + const bg = "#f6f9fd"; + const palette = ["#f7bd13", "#22aaa2", "#f2474d", "#2f6fb0", "#f47f13", "#5ca33b", "#8d6cc6", "#d65f9e"]; + + d3.select(containerSelector).html(""); + + const columnInfo = (columns || []).find(col => col.name === xField) || {}; + const xLooksTemporal = /year|month|date|time|season|semester/i.test(xField) + || /temporal|date|time/i.test(String(columnInfo.data_type || xChannel.data_type || "")); + + function parseChronological(value) { + const text = String(value); + const year = text.match(/\b(19|20)\d{2}\b/); + if (/^\d{4}-\d{1,2}/.test(text)) return new Date(text + "-01").getTime(); + if (year) return Number(year[0]); + const monthNames = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, + apr: 4, april: 4, may: 5, jun: 6, june: 6, jul: 7, july: 7, + aug: 8, august: 8, sep: 9, sept: 9, september: 9, + oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + const lower = text.toLowerCase(); + for (const key of Object.keys(monthNames)) { + if (lower.includes(key)) return monthNames[key]; + } + return Number.POSITIVE_INFINITY; + } + + function humanize(text) { + return String(text || "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .trim(); + } + + function wrapWords(text, maxChars, maxLines) { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const trial = current ? current + " " + word : word; + if (current && trial.length > maxChars) { + lines.push(current); + current = word; + } else { + current = trial; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = kept[maxLines - 1].replace(/\.*$/, "") + "..."; + return kept; + } + return lines.length ? lines : [String(text || "")]; + } + + function legendLines(text, maxChars) { + const words = String(text || "").split(/\s+/).filter(Boolean); + if (words.length <= 1) return [String(text || "")]; + const lines = wrapWords(text, maxChars, 2); + if (lines.length > 2) return [words[0], words.slice(1).join(" ")]; + return lines; + } + + const groups = []; + chartData.forEach(d => { + const group = d[groupField]; + if (!groups.includes(group)) groups.push(group); + }); + + const categoryOrder = []; + chartData.forEach(d => { + const category = d[xField]; + if (!categoryOrder.includes(category)) categoryOrder.push(category); + }); + if (xLooksTemporal) { + categoryOrder.sort((a, b) => { + const pa = parseChronological(a); + const pb = parseChronological(b); + if (pa !== pb) return pa - pb; + return String(a).localeCompare(String(b), undefined, { numeric: true }); + }); + } + + const byCategory = new Map(); + categoryOrder.forEach(category => byCategory.set(category, { category, groups: {} })); + chartData.forEach(d => { + const category = d[xField]; + if (!byCategory.has(category)) byCategory.set(category, { category, groups: {} }); + byCategory.get(category).groups[d[groupField]] = +d[yField]; + }); + const processedData = Array.from(byCategory.values()); + + const margin = { top: 126, right: 30, bottom: 64, left: 54 }; + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + const maxValue = d3.max(chartData, d => +d[yField]) || 1; + const yMax = Math.max(maxValue * 1.08, maxValue + 1); + + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .paddingInner(0.22) + .paddingOuter(0.10); + + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.10); + + const yScale = d3.scaleLinear() + .domain([0, yMax]) + .range([chartHeight, 0]) + .nice(); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + svg.append("rect") + .attr("class", "vertical-group-bar-chart-1-chart-surface") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", bg) + .attr("opacity", 0); + + const legendX = 14; + const legendY = 14; + const legendW = width - 28; + const legendRows = groups.length > 6 || legendW / Math.max(1, groups.length) < 80 ? 2 : 1; + const legendH = legendRows === 1 ? 56 : 86; + const legendCols = Math.ceil(groups.length / legendRows); + const legendCellW = legendW / Math.max(1, legendCols); + const legendIconR = 10.5; + const legendTextX = 28; + const legendLabelW = Math.max(42, legendCellW - legendTextX - 10); + const legendFont = legendCellW < 92 ? 9.4 : 10.4; + + const legend = svg.append("g") + .attr("class", "legend legend-card") + .attr("data-reference-relationship", "independent") + .attr("data-anchor", "canvas-width-between-header-and-plot") + .attr("data-collision-rule", "inside legend card; avoid title, plot heading, and chart panel") + .attr("transform", `translate(${legendX},${legendY})`); + + legend.append("rect") + .attr("class", "legend-card-bg") + .attr("x", 0) + .attr("y", 0) + .attr("width", legendW) + .attr("height", legendH) + .attr("rx", 12) + .attr("fill", "#ffffff") + .attr("stroke", "#dde7f2") + .attr("stroke-width", 1.1) + .attr("filter", "drop-shadow(0 5px 10px rgba(20,38,66,0.10))"); + + const legendItem = legend.selectAll(".legend-item") + .data(groups) + .enter() + .append("g") + .attr("class", "legend-item") + .attr("transform", (d, i) => { + const col = i % legendCols; + const row = Math.floor(i / legendCols); + return `translate(${col * legendCellW + 10},${row * 34 + 11})`; + }); + + legendItem.append("circle") + .attr("class", "legend-icon-slot") + .attr("data-asset-slot", "legend-icon") + .attr("data-slot-policy", "neutral_placeholder_or_input_asset") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-anchor", "legend-item-left") + .attr("data-mask-policy", "circle mask; no hard-coded helmet or topic pictogram") + .attr("data-collision-rule", "stay inside legend card and left of label text") + .attr("data-bbox", `0,0,${legendIconR * 2},${legendIconR * 2}`) + .attr("cx", legendIconR) + .attr("cy", 17) + .attr("r", legendIconR) + .attr("fill", (d, i) => colorResolver.field(d, i, { fallback: palette[i % palette.length] }).value) + .attr("opacity", 0.96); + + legendItem.append("text") + .attr("x", legendTextX) + .attr("y", 13) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", legendFont) + .attr("font-weight", 800) + .attr("fill", navy) + .each(function(d) { + const text = d3.select(this); + const maxChars = Math.max(7, Math.floor(legendLabelW / (legendFont * 0.55))); + const lines = legendLines(d, maxChars).slice(0, 2); + const firstDy = lines.length === 1 ? 0 : -4; + lines.forEach((line, idx) => { + const estimatedWidth = String(line).length * legendFont * 0.58; + const tspan = text.append("tspan") + .attr("x", legendTextX) + .attr("dy", idx === 0 ? firstDy : 11.5) + .text(line); + if (estimatedWidth > legendLabelW) { + tspan.attr("textLength", legendLabelW) + .attr("lengthAdjust", "spacingAndGlyphs"); + } + }); + }); + + legend.selectAll(".legend-divider") + .data(groups.slice(1)) + .enter() + .append("line") + .attr("class", "legend-divider") + .attr("x1", (d, i) => ((i + 1) % legendCols === 0 ? -999 : (i + 1) * legendCellW)) + .attr("x2", (d, i) => ((i + 1) % legendCols === 0 ? -999 : (i + 1) * legendCellW)) + .attr("y1", 11) + .attr("y2", legendH - 11) + .attr("stroke", "#dfe8f2") + .attr("stroke-width", 1); + + const plotHeading = `${humanize(yField).toUpperCase()}${yUnit ? ` (${yUnit})` : ""}`; + svg.append("text") + .attr("class", "plot-heading") + .attr("x", margin.left - 2) + .attr("y", margin.top - 26) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 14) + .attr("font-weight", 900) + .attr("fill", navy) + .attr("letter-spacing", 0) + .text(plotHeading); + + const chartGroup = svg.append("g") + .attr("class", "plot") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + const yTicks = yScale.ticks(6); + chartGroup.append("g") + .attr("class", "gridlines") + .selectAll("line") + .data(yTicks) + .enter() + .append("line") + .attr("x1", 0) + .attr("x2", chartWidth) + .attr("y1", d => yScale(d)) + .attr("y2", d => yScale(d)) + .attr("stroke", "#cfd8e3") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "4 4") + .attr("opacity", d => d === 0 ? 0 : 0.86); + + const xAxis = d3.axisBottom(xScale).tickSize(0); + const xAxisGroup = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis); + + const xLabelTooWide = processedData.some(d => String(d.category).length * 6.5 > xScale.bandwidth() * 1.35); + xAxisGroup.select(".domain") + .attr("stroke", axisNavy) + .attr("stroke-width", 1.4); + xAxisGroup.selectAll("text") + .attr("dy", xLabelTooWide ? "0.8em" : "1.05em") + .attr("transform", xLabelTooWide ? "rotate(-28)" : null) + .style("text-anchor", xLabelTooWide ? "end" : "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", xLabelTooWide ? "10px" : "14px") + .style("font-weight", 800) + .style("fill", axisNavy); + + const yAxis = d3.axisLeft(yScale) + .tickValues(yTicks) + .tickFormat(d => chartUtils.format.autoText(d)) + .tickSize(0) + .tickPadding(10); + + const yAxisGroup = chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis); + yAxisGroup.select(".domain") + .attr("stroke", axisNavy) + .attr("stroke-width", 1.4); + yAxisGroup.selectAll("text") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "12px") + .style("font-weight", 600) + .style("fill", axisNavy); + + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("data-category", d => d.category) + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach((group, groupIndex) => { + const groupColor = colorResolver.field(group, groupIndex, { fallback: palette[groupIndex % palette.length] }).value; + barGroups.append("rect") + .attr("class", "bar") + .attr("data-group", group) + .attr("data-bar-end-shape", "square-flat") + .attr("data-corner-radius", "0") + .attr("data-value", d => d.groups[group] || 0) + .attr("x", () => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()) + .attr("height", d => Math.max(0, chartHeight - yScale(d.groups[group] || 0))) + .attr("rx", 0) + .attr("ry", 0) + .attr("fill", groupColor); + + if (groupScale.bandwidth() >= 6) { + barGroups.append("text") + .attr("class", "label value-label") + .attr("data-group", group) + .attr("data-reference-relationship", "centerline-aligned-to-bar-top") + .attr("x", () => groupScale(group) + groupScale.bandwidth() / 2) + .attr("y", d => Math.max(10, yScale(d.groups[group] || 0) - 6)) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", groupScale.bandwidth() < 10 ? "9px" : "11px") + .style("font-weight", 700) + .style("fill", groupColor) + .text(d => { + const value = d.groups[group] || 0; + return value > 0 ? chartUtils.format.autoText(value) : ""; + }) + .style("opacity", 1); + } + }); + + chartGroup.selectAll(".value-label").raise(); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..0c5824fb034e2af3f3c9e1801f019cd5749110d0 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_10.js @@ -0,0 +1,515 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_10", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const xChannel = chartUtils.schema.channel(jsonData, "x") || {}; + const yChannel = chartUtils.schema.channel(jsonData, "y") || {}; + const groupChannel = chartUtils.schema.channel(jsonData, "group") || {}; + const xField = xChannel.key || "period"; + const yField = yChannel.key || "value"; + const groupField = groupChannel.key || "group"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const columns = chartUtils.schema.columns(jsonData) || []; + const xColumn = columns.find(c => c.name === xField) || {}; + const isTemporal = /year|date|month|season|semester|time|timestamp/i.test(xField) || + /temporal|date|time/i.test(xColumn.data_type || ""); + + const width = variables.width || 600; + const height = Math.max(variables.height || 0, Math.round(width * 1.5), 840); + const palette = ["#2388d9", "#ff9d1b", "#ff6f2f", "#35a46b"]; + const navy = "#17355f"; + const muted = "#6b7d93"; + const panelStroke = "#d8e9f7"; + const labelFont = (typography.label && typography.label.font_family) || "Arial"; + const titleFont = (typography.title && typography.title.font_family) || "Arial"; + + const title = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || + "Grouped Rate Comparison"; + const subtitle = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || + ""; + + const fmtValue = value => { + const n = +value; + if (!Number.isFinite(n)) return ""; + const formatted = n >= 100 ? d3.format(".0f")(n) : d3.format(".1f")(n).replace(/\.0$/, ""); + return yUnit ? `${formatted} ${yUnit}` : formatted; + }; + + const categoryKey = value => String(value); + const categorySortValue = value => { + if (value instanceof Date) return +value; + const text = String(value); + if (/^\d{4}$/.test(text)) return +text; + const date = Date.parse(text); + return Number.isNaN(date) ? text : date; + }; + + const groups = Array.from(new Set(chartData.map(d => d[groupField]))).filter(d => d !== undefined && d !== null); + const categories = Array.from(new Set(chartData.map(d => d[xField]))).filter(d => d !== undefined && d !== null); + if (isTemporal) { + categories.sort((a, b) => d3.ascending(categorySortValue(a), categorySortValue(b))); + } + + const processedData = categories.map(category => { + const row = { category, groups: {} }; + chartData.forEach(d => { + if (categoryKey(d[xField]) === categoryKey(category)) { + row.groups[d[groupField]] = +d[yField]; + } + }); + return row; + }); + + const firstCategory = processedData[0]; + const lastCategory = processedData[processedData.length - 1]; + const maxValue = d3.max(chartData, d => +d[yField]) || 1; + const yearBadge = isTemporal && categories.length ? `SINCE ${categories[0]}` : String(xField).toUpperCase(); + + const groupColor = group => { + const idx = Math.max(0, groups.indexOf(group)); + const fallback = palette[idx % palette.length]; + try { + return colorResolver.field(group, idx, { fallback }).value || fallback; + } catch (e) { + return fallback; + } + }; + + const wrapLines = (text, maxChars, maxLines) => { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const trial = current ? `${current} ${word}` : word; + if (current && trial.length > maxChars) { + lines.push(current); + current = word; + } else { + current = trial; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = kept[maxLines - 1].replace(/\.*$/, "") + "..."; + return kept; + } + return lines; + }; + const estimateTextWidth = (text, fontSize) => { + return String(text || "").split("").reduce((sum, ch) => { + if (/\s/.test(ch)) return sum + fontSize * 0.34; + if ("ilI.,'|".includes(ch)) return sum + fontSize * 0.32; + if ("MW@#%&".includes(ch)) return sum + fontSize * 0.92; + if (/[A-Z0-9]/.test(ch)) return sum + fontSize * 0.68; + return sum + fontSize * 0.58; + }, 0); + }; + const rectsOverlap = (a, b) => !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "vertical_group_bar_chart_10") + .attr("data-temporal-order", isTemporal ? "chronological" : "input") + .attr("data-bar-end-shape", "rounded-top-flat-baseline"); + + const defs = svg.append("defs"); + const bgGradient = defs.append("linearGradient") + .attr("id", "vgb10-bg") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ecf8ff"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#f8fcff"); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#vgb10-bg)"); + + const displayTitle = title.replace(/\s+since\s+\d{4}\s*$/i, "").toUpperCase(); + const titleLines = wrapLines(displayTitle, 34, 2); + const titleText = svg.append("text") + .attr("x", 36) + .attr("y", 58) + .attr("text-anchor", "start") + .attr("font-family", titleFont) + .attr("font-size", 28) + .attr("font-weight", 900) + .attr("fill", navy); + titleLines.forEach((line, i) => { + titleText.append("tspan") + .attr("x", 36) + .attr("dy", i === 0 ? 0 : 31) + .text(line); + }); + + const sinceY = 108 + (titleLines.length - 1) * 31; + svg.append("line") + .attr("x1", 36) + .attr("x2", 134) + .attr("y1", sinceY) + .attr("y2", sinceY) + .attr("stroke", "#2075d1") + .attr("stroke-width", 2); + svg.append("text") + .attr("x", 158) + .attr("y", sinceY + 7) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 21) + .attr("font-weight", 900) + .attr("fill", "#2075d1") + .text("*"); + svg.append("text") + .attr("x", 270) + .attr("y", sinceY + 7) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 24) + .attr("font-weight", 900) + .attr("letter-spacing", 3) + .attr("fill", "#2075d1") + .text(yearBadge); + svg.append("text") + .attr("x", 382) + .attr("y", sinceY + 7) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 21) + .attr("font-weight", 900) + .attr("fill", "#2075d1") + .text("*"); + svg.append("line") + .attr("x1", 406) + .attr("x2", 500) + .attr("y1", sinceY) + .attr("y2", sinceY) + .attr("stroke", "#2075d1") + .attr("stroke-width", 2) + .attr("opacity", 0.55); + + const subtitleLines = wrapLines(subtitle, 44, 2); + const subtitleText = svg.append("text") + .attr("x", 36) + .attr("y", sinceY + 44) + .attr("text-anchor", "start") + .attr("font-family", labelFont) + .attr("font-size", 18) + .attr("font-weight", 500) + .attr("fill", "#2f4058"); + subtitleLines.forEach((line, i) => { + subtitleText.append("tspan") + .attr("x", 36) + .attr("dy", i === 0 ? 0 : 24) + .text(line); + }); + + const titleFontSize = 28; + const subtitleFontSize = 18; + const titleBboxes = titleLines.map((line, i) => { + const baseline = 58 + i * 31; + return { + x1: 36, + y1: baseline - titleFontSize, + x2: 36 + estimateTextWidth(line, titleFontSize), + y2: baseline + 7 + }; + }); + const subtitleBboxes = subtitleLines.map((line, i) => { + const baseline = sinceY + 44 + i * 24; + return { + x1: 36, + y1: baseline - subtitleFontSize, + x2: 36 + estimateTextWidth(line, subtitleFontSize), + y2: baseline + 6 + }; + }); + const headerSlotBBox = { x1: width - 118, y1: 42, x2: width - 6, y2: 206 }; + const headerSlotCollidesWithText = titleLines.length > 1 && + titleBboxes.concat(subtitleBboxes).some(box => rectsOverlap(box, headerSlotBBox)); + const headerSlotOpacity = headerSlotCollidesWithText ? 0 : 1; + + const slot = svg.append("g") + .attr("class", "reserved-asset-slot header-topic-icon-slot") + .attr("data-asset-slot", "header-topic-icon") + .attr("data-asset-source", "image2_asset") + .attr("data-bbox", `${width - 118},42,112,164`) + .attr("data-anchor", "top-right-header-safe-area") + .attr("data-mask", "soft-silhouette") + .attr("data-collision", "avoid:title,subtitle,metric-cards,legend,chart-panel,canvas-edge") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-title-safe-bbox", JSON.stringify(titleBboxes.concat(subtitleBboxes))) + .attr("data-collapsed-for-title-collision", headerSlotCollidesWithText ? "true" : "false") + .attr("opacity", headerSlotOpacity); + slot.append("ellipse") + .attr("cx", width - 46) + .attr("cy", 102) + .attr("rx", 52) + .attr("ry", 82) + .attr("fill", "#d8ebfb") + .attr("opacity", 0.46); + slot.append("path") + .attr("d", `M${width - 54},50 C${width - 6},82 ${width - 24},150 ${width + 26},162 L${width + 26},214 C${width - 36},186 ${width - 82},164 ${width - 72},104 C${width - 67},74 ${width - 88},60 ${width - 54},50 Z`) + .attr("fill", "#cfe4f6") + .attr("opacity", 0.38); + + const metricTop = 222; + const stripX = 36; + const stripW = width - 72; + const cardW = stripW / Math.max(1, groups.length); + const cardH = 82; + const metricCards = svg.append("g") + .attr("class", "top-metric-card-strip") + .attr("data-relationship", "independent-grid-aligned-to-chart-panel"); + metricCards.append("rect") + .attr("x", stripX) + .attr("y", metricTop) + .attr("width", stripW) + .attr("height", cardH) + .attr("rx", 13) + .attr("fill", "#ffffff") + .attr("stroke", "#e4edf6") + .attr("filter", "drop-shadow(0px 8px 14px rgba(16, 58, 94, 0.10))"); + + groups.forEach((group, i) => { + const x = stripX + i * cardW; + const card = metricCards.append("g") + .attr("class", "metric-card-segment") + .attr("transform", `translate(${x}, ${metricTop})`) + .attr("data-group", group); + if (i > 0) { + card.append("line") + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", 18) + .attr("y2", cardH - 18) + .attr("stroke", "#d6e2ee") + .attr("stroke-width", 1.2); + } + card.append("circle") + .attr("class", "reserved-asset-slot group-metric-icon-slot") + .attr("data-asset-slot", "group-metric-icon") + .attr("data-asset-source", "image2_asset") + .attr("data-anchor", "metric-card-left") + .attr("data-mask", "circle") + .attr("data-collision", "inside-card-segment-avoid-labels-and-dividers") + .attr("cx", 54) + .attr("cy", 41) + .attr("r", 24) + .attr("fill", "#ffffff") + .attr("stroke", groupColor(group)) + .attr("stroke-width", 2); + card.append("circle") + .attr("cx", 54) + .attr("cy", 41) + .attr("r", 12) + .attr("fill", groupColor(group)) + .attr("opacity", 0.22); + card.append("text") + .attr("x", 88) + .attr("y", 36) + .attr("font-family", labelFont) + .attr("font-size", 12) + .attr("font-weight", 900) + .attr("fill", groupColor(group)) + .text(String(group).toUpperCase().slice(0, 11)); + card.append("text") + .attr("x", 88) + .attr("y", 57) + .attr("font-family", labelFont) + .attr("font-size", 12) + .attr("font-weight", 500) + .attr("fill", "#202b3c") + .text(`Rate per 100k`); + }); + + const panel = { + x: 44, + y: 328, + w: width - 88, + h: 466 + }; + const plot = { + x: panel.x + 54, + y: panel.y + 86, + w: panel.w - 86, + h: panel.h - 138 + }; + + svg.append("rect") + .attr("class", "chart-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 12) + .attr("fill", "#ffffff") + .attr("stroke", panelStroke) + .attr("stroke-width", 1.5); + + svg.append("text") + .attr("x", panel.x + 28) + .attr("y", panel.y + 38) + .attr("text-anchor", "start") + .attr("font-family", labelFont) + .attr("font-size", 15) + .attr("font-weight", 900) + .attr("fill", navy) + .text(`${String(yField).replace(/([a-z])([A-Z])/g, "$1 $2").toUpperCase()} ${yUnit ? `(${yUnit.toUpperCase()})` : "(PER 100,000 VETERANS)"}`); + + const chartGroup = svg.append("g") + .attr("class", "plot-area") + .attr("transform", `translate(${plot.x}, ${plot.y})`); + + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, plot.w]) + .padding(0.26); + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.12); + const yScale = d3.scaleLinear() + .domain([0, maxValue * 1.16]) + .range([plot.h, 0]) + .nice(); + const maxXLabelChars = Math.max(5, Math.min(14, Math.floor(xScale.bandwidth() / 5.2))); + const formatXLabel = value => { + const text = String(value); + if (text.length <= maxXLabelChars) return text; + return `${text.slice(0, Math.max(3, maxXLabelChars - 1)).trim()}...`; + }; + + const roundedTopBarPath = (x, y, w, h) => { + const r = Math.min(7, w / 2, Math.max(0, h)); + const bottom = y + h; + if (h <= r) return `M${x},${bottom} L${x},${y} L${x + w},${y} L${x + w},${bottom} Z`; + return [ + `M${x},${bottom}`, + `L${x},${y + r}`, + `Q${x},${y} ${x + r},${y}`, + `L${x + w - r},${y}`, + `Q${x + w},${y} ${x + w},${y + r}`, + `L${x + w},${bottom}`, + "Z" + ].join(" "); + }; + + chartGroup.append("g") + .attr("class", "gridlines") + .call(d3.axisLeft(yScale).ticks(5).tickSize(-plot.w).tickFormat("")) + .selectAll("line") + .attr("stroke", "#e7f0f8") + .attr("stroke-width", 1); + chartGroup.select(".gridlines .domain").remove(); + + const xAxis = d3.axisBottom(xScale).tickSize(0).tickFormat(formatXLabel); + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickSize(0) + .tickPadding(8) + .tickFormat(d => chartUtils.format.autoText(d)); + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .attr("font-family", labelFont) + .attr("font-size", 10) + .attr("font-weight", 700) + .attr("fill", muted); + chartGroup.select(".y-axis .domain").remove(); + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${plot.h})`) + .call(xAxis) + .selectAll("text") + .attr("font-family", labelFont) + .attr("font-size", maxXLabelChars < 8 ? 8 : 10) + .attr("font-weight", 800) + .attr("fill", navy) + .attr("dy", "1.2em") + .append("title") + .text(d => String(d)); + chartGroup.select(".x-axis .domain").remove(); + + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("data-x-category", d => d.category) + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach((group, groupIndex) => { + const barWidth = groupScale.bandwidth(); + barGroups.append("path") + .attr("class", "bar") + .attr("data-group", group) + .attr("data-y-field", yField) + .attr("data-bar-end-shape", "rounded-top-flat-baseline") + .attr("d", d => { + const value = d.groups[group] || 0; + const y = yScale(value); + const h = Math.max(0, plot.h - y); + return roundedTopBarPath(groupScale(group), y, barWidth, h); + }) + .attr("fill", groupColor(group)) + .attr("opacity", groupIndex === 0 ? 1 : 0.94); + + barGroups.append("text") + .attr("class", "bar-value-label") + .attr("data-group", group) + .attr("x", () => groupScale(group) + barWidth / 2) + .attr("y", d => yScale(d.groups[group] || 0) - 5) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", groups.length > 3 ? 7 : 8) + .attr("font-weight", 800) + .attr("fill", navy) + .text(d => fmtValue(d.groups[group] || 0)); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_11.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_11.js new file mode 100644 index 0000000000000000000000000000000000000000..2f35a4f4e98075ec1ba1ef47ca2954a36b9b4b54 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_11.js @@ -0,0 +1,574 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_11", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const xChannel = chartUtils.schema.channel(jsonData, "x") || {}; + const yChannel = chartUtils.schema.channel(jsonData, "y") || {}; + const groupChannel = chartUtils.schema.channel(jsonData, "group") || {}; + const columns = chartUtils.schema.columns(jsonData) || []; + const xField = xChannel.key || "category"; + const yField = yChannel.key || "value"; + const groupField = groupChannel.key || "group"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const xColumn = columns.find(c => c.name === xField) || {}; + const isTemporal = /year|date|month|season|semester|time|timestamp/i.test(xField) || + /temporal|date|time/i.test(xColumn.data_type || ""); + + const width = variables.width || 600; + const height = Math.max(variables.height || 0, Math.round(width * 1.4), 840); + const sx = width / 600; + const sy = height / 840; + const scale = Math.min(sx, sy); + const labelFont = (typography.label && typography.label.font_family) || "Arial"; + const titleFont = (typography.title && typography.title.font_family) || "Arial"; + + const title = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || + "Grouped Completion Rates"; + const subtitle = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || + ""; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "vertical_group_bar_chart_11") + .attr("data-render-policy", "chart-owned-reference-layout") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bar-end-shape", "capsule-pill-rounded-top-and-baseline") + .attr("data-temporal-order", isTemporal ? "chronological" : "input"); + + const defs = svg.append("defs"); + const bgGradient = defs.append("linearGradient") + .attr("id", "vgb11-bg") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ffffff"); + bgGradient.append("stop").attr("offset", "70%").attr("stop-color", "#f9fcff"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#e9f5ff"); + + const moocFallback = "#25c7d0"; + const traditionalFallback = "#1268dc"; + const navy = "#06163b"; + const muted = "#626b78"; + const axisBlue = "#9eb7dc"; + const gridBlue = "#dce8f5"; + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#vgb11-bg)"); + svg.append("ellipse") + .attr("cx", 78 * sx) + .attr("cy", 808 * sy) + .attr("rx", 170 * sx) + .attr("ry", 98 * sy) + .attr("fill", "#dff0ff") + .attr("opacity", 0.55); + svg.append("ellipse") + .attr("cx", 486 * sx) + .attr("cy", 202 * sy) + .attr("rx", 110 * sx) + .attr("ry", 95 * sy) + .attr("fill", "#dfeffd") + .attr("opacity", 0.70); + + const sanitizeId = value => String(value).replace(/[^a-zA-Z0-9_-]+/g, "-"); + const fmtValue = value => { + const n = +value; + if (!Number.isFinite(n)) return ""; + const formatted = d3.format(".1f")(n).replace(/\.0$/, ""); + return yUnit ? `${formatted}${yUnit}` : formatted; + }; + const metricLabel = String(yField).replace(/([a-z])([A-Z])/g, "$1 $2"); + const noteMetricLabel = /^average\s/i.test(metricLabel) ? metricLabel.toLowerCase() : `average ${metricLabel.toLowerCase()}`; + const textWidth = (value, fontSize) => String(value || "").split("").reduce((sum, ch) => { + if (/\s/.test(ch)) return sum + fontSize * 0.34; + if ("ilI.,'|".includes(ch)) return sum + fontSize * 0.32; + if ("MW@#%&".includes(ch)) return sum + fontSize * 0.90; + if (/[A-Z0-9]/.test(ch)) return sum + fontSize * 0.68; + return sum + fontSize * 0.56; + }, 0); + const fitTextToWidth = (text, maxWidth, fontSize) => { + let value = String(text || "").trim(); + if (textWidth(value, fontSize) <= maxWidth) return value; + while (value.length > 1 && textWidth(`${value}...`, fontSize) > maxWidth) { + value = value.slice(0, -1).trim(); + } + return value ? `${value}...` : ""; + }; + const wrapWords = (text, maxWidth, fontSize, maxLines) => { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const fittedWord = fitTextToWidth(word, maxWidth, fontSize); + const candidate = current ? `${current} ${fittedWord}` : fittedWord; + if (current && textWidth(candidate, fontSize) > maxWidth) { + lines.push(current); + current = fittedWord; + } else { + current = candidate; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = fitTextToWidth(kept[maxLines - 1], maxWidth, fontSize); + return kept; + } + return lines; + }; + const splitTitle = value => { + const text = String(value || ""); + const phraseMatch = text.match(/^(.*?)(Completion Rates)$/i); + if (phraseMatch) { + const prefix = phraseMatch[1].trim(); + const outperformMatch = prefix.match(/^(.*?Courses)\s+(Outperform.*)$/i); + if (outperformMatch) { + return { + main: [outperformMatch[1], outperformMatch[2]], + accent: phraseMatch[2] + }; + } + return { + main: wrapWords(prefix, 405 * sx, 35 * scale, 2), + accent: phraseMatch[2] + }; + } + const lines = wrapWords(text, 330 * sx, 32 * scale, 3); + return { main: lines.slice(0, Math.max(1, lines.length - 1)), accent: lines[lines.length - 1] || "" }; + }; + + const groups = Array.from(new Set(chartData.map(d => d[groupField]))).filter(d => d !== undefined && d !== null); + const categories = Array.from(new Set(chartData.map(d => d[xField]))).filter(d => d !== undefined && d !== null); + if (isTemporal) { + categories.sort((a, b) => { + const ax = /^\d{4}$/.test(String(a)) ? +a : Date.parse(a); + const bx = /^\d{4}$/.test(String(b)) ? +b : Date.parse(b); + return d3.ascending(Number.isNaN(ax) ? String(a) : ax, Number.isNaN(bx) ? String(b) : bx); + }); + } + const limitedGroups = groups.slice(0, 2); + const resolveSeriesColor = (group, idx) => { + const lower = String(group || "").toLowerCase(); + if (lower.includes("mooc")) return moocFallback; + if (lower.includes("traditional")) return traditionalFallback; + const fallback = idx === 0 ? moocFallback : traditionalFallback; + try { + return colorResolver.field(group, idx, { fallback }).value || fallback; + } catch (e) { + return fallback; + } + }; + const seriesColorRoles = new Map(limitedGroups.map((group, idx) => { + const base = resolveSeriesColor(group, idx); + return [String(group), { + group, + index: idx, + base, + gradientId: `vgb11-bar-${idx}-${sanitizeId(group)}`, + top: colorResolver.variant(base, { mode: "darker", amount: 0.14 }) || base, + middle: colorResolver.variant(base, { mode: "brighter", amount: 0.20 }) || base, + bottom: base + }]; + })); + const groupColor = group => (seriesColorRoles.get(String(group)) || {}).base || moocFallback; + const groupGradientId = group => (seriesColorRoles.get(String(group)) || {}).gradientId || `vgb11-bar-0-${sanitizeId(group)}`; + + limitedGroups.forEach((group, idx) => { + const role = seriesColorRoles.get(String(group)); + const gradient = defs.append("linearGradient") + .attr("id", role.gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + gradient.append("stop").attr("offset", "0%").attr("stop-color", role.top); + gradient.append("stop").attr("offset", "62%").attr("stop-color", role.middle); + gradient.append("stop").attr("offset", "100%").attr("stop-color", role.bottom); + gradient.attr("data-group-color", role.base) + .attr("data-color-binding", "legend-swatch-bar-fill-value-label"); + }); + + const titleSplit = splitTitle(title); + svg.append("line") + .attr("x1", 32 * sx) + .attr("x2", 32 * sx) + .attr("y1", 44 * sy) + .attr("y2", 162 * sy) + .attr("stroke", "#1668df") + .attr("stroke-width", 4 * scale) + .attr("stroke-linecap", "round"); + + const titleGroup = svg.append("g") + .attr("class", "vgb11-title-block") + .attr("data-anchor", "top-left") + .attr("data-collision-rule", "wrap-or-shrink-before-header-slot-overlap"); + const titleText = titleGroup.append("text") + .attr("x", 50 * sx) + .attr("y", 72 * sy) + .attr("font-family", titleFont) + .attr("font-weight", 900) + .attr("font-size", 35 * scale) + .attr("fill", navy); + titleSplit.main.forEach((line, i) => { + titleText.append("tspan") + .attr("x", 50 * sx) + .attr("dy", i === 0 ? 0 : 39 * sy) + .text(line); + }); + titleText.append("tspan") + .attr("x", 50 * sx) + .attr("dy", 39 * sy) + .attr("fill", "#115bd8") + .text(titleSplit.accent); + + const subtitleLines = wrapWords(subtitle, 270 * sx, 16 * scale, 3); + const subtitleY = 220 * sy; + const subtitleText = titleGroup.append("text") + .attr("x", 50 * sx) + .attr("y", subtitleY) + .attr("font-family", labelFont) + .attr("font-weight", 400) + .attr("font-size", 16 * scale) + .attr("fill", muted); + subtitleLines.forEach((line, i) => { + subtitleText.append("tspan") + .attr("x", 50 * sx) + .attr("dy", i === 0 ? 0 : 23 * sy) + .text(line); + }); + + const headerSlot = svg.append("g") + .attr("class", "reserved-asset-slot vgb11-header-education-login-art-slot") + .attr("data-asset-slot", "header_education_login_art") + .attr("data-reserved-slot", "header_education_login_art") + .attr("data-slot-policy", "image2_asset") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "upper-right-header-safe-area") + .attr("data-bbox", `${360 * sx},${88 * sy},${196 * sx},${196 * sy}`) + .attr("data-mask", "rounded-rect-or-blob") + .attr("data-collision-rule", "avoid title subtitle legend and chart plot; hide before overlap") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + headerSlot.append("rect") + .attr("x", 405 * sx) + .attr("y", 130 * sy) + .attr("width", 150 * sx) + .attr("height", 116 * sy) + .attr("rx", 18 * scale) + .attr("fill", "#ffffff") + .attr("stroke", "#cfe0f7") + .attr("stroke-width", 2 * scale) + .attr("opacity", 0.58); + headerSlot.append("rect") + .attr("x", 405 * sx) + .attr("y", 130 * sy) + .attr("width", 150 * sx) + .attr("height", 24 * sy) + .attr("rx", 18 * scale) + .attr("fill", "#2c74e6") + .attr("opacity", 0.16); + headerSlot.append("circle").attr("cx", 480 * sx).attr("cy", 184 * sy).attr("r", 23 * scale).attr("fill", "#1d66d8").attr("opacity", 0.10); + headerSlot.append("rect").attr("x", 438 * sx).attr("y", 215 * sy).attr("width", 86 * sx).attr("height", 17 * sy).attr("rx", 5 * scale).attr("fill", "#1d66d8").attr("opacity", 0.10); + for (let i = 0; i < 16; i++) { + headerSlot.append("circle") + .attr("cx", (497 + (i % 4) * 16) * sx) + .attr("cy", (70 + Math.floor(i / 4) * 16) * sy) + .attr("r", 3 * scale) + .attr("fill", "#b6d5fb") + .attr("opacity", 0.70); + } + + const legendY = 302 * sy; + const legend = svg.append("g") + .attr("class", "vgb11-legend-capsule") + .attr("data-relationship", "independent-floating") + .attr("data-anchor", "below-subtitle-left-column"); + const legendFontSize = Math.max(10 * scale, Math.min(13 * scale, (width - 122 * sx) / Math.max(28, limitedGroups.join(" ").length) * 1.65)); + const legendMetrics = limitedGroups.map((group, i) => ({ + group, + color: groupColor(group), + labelWidth: textWidth(group, legendFontSize) + })); + const legendContentW = legendMetrics.reduce((sum, item) => sum + item.labelWidth + 42 * sx, 18 * sx); + const legendW = Math.min(width - 100 * sx, Math.max(205 * sx, legendContentW)); + legend.append("rect") + .attr("x", 50 * sx) + .attr("y", legendY - 25 * sy) + .attr("width", legendW) + .attr("height", 42 * sy) + .attr("rx", 13 * scale) + .attr("fill", "#ffffff") + .attr("stroke", "#e0e9f6") + .attr("filter", "drop-shadow(0px 5px 8px rgba(35, 90, 145, 0.12))"); + let legendCursor = 77 * sx; + legendMetrics.forEach((item) => { + const x = legendCursor; + legend.append("circle") + .attr("cx", x) + .attr("cy", legendY - 4 * sy) + .attr("r", 8 * scale) + .attr("fill", item.color); + legend.append("text") + .attr("x", x + 14 * sx) + .attr("y", legendY + 2 * sy) + .attr("font-family", labelFont) + .attr("font-size", legendFontSize) + .attr("font-weight", 500) + .attr("fill", navy) + .text(String(item.group)); + legendCursor += item.labelWidth + 54 * sx; + }); + + const plot = { + x: 72 * sx, + y: 355 * sy, + w: 500 * sx, + h: 292 * sy + }; + const yAxisLabel = `${metricLabel}${yUnit ? ` (${yUnit})` : ""}`; + const maxValue = d3.max(chartData, d => +d[yField]) || 1; + const isPercentScale = yUnit === "%" || /percent|percentage/i.test(yField); + const niceStep = maxValue <= 20 ? 5 : maxValue <= 100 ? 20 : Math.pow(10, Math.max(1, Math.floor(Math.log10(maxValue)) - 1)); + const domainMax = isPercentScale ? Math.max(100, Math.ceil(maxValue / 10) * 10) : Math.ceil((maxValue * 1.12) / niceStep) * niceStep; + const yScale = d3.scaleLinear().domain([0, domainMax]).range([plot.h, 0]); + const xScale = d3.scaleBand().domain(categories).range([0, plot.w]).padding(0.18); + const groupScale = d3.scaleBand().domain(limitedGroups).range([0, xScale.bandwidth()]).padding(0.28); + const barW = Math.max(8 * scale, Math.min(18 * scale, groupScale.bandwidth())); + + const axis = svg.append("g") + .attr("class", "vgb11-axis-grid") + .attr("transform", `translate(${plot.x},${plot.y})`); + d3.range(0, domainMax + 1, domainMax / 5).forEach(tick => { + const y = yScale(tick); + axis.append("line") + .attr("x1", 0) + .attr("x2", plot.w) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", gridBlue) + .attr("stroke-width", 1 * scale) + .attr("stroke-dasharray", tick === 0 ? "0" : `${3 * scale} ${3 * scale}`); + axis.append("text") + .attr("x", -10 * sx) + .attr("y", y + 4 * sy) + .attr("text-anchor", "end") + .attr("font-family", labelFont) + .attr("font-size", 11 * scale) + .attr("font-weight", 500) + .attr("fill", navy) + .text(`${Math.round(tick)}${yUnit || ""}`); + }); + axis.append("line") + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", 0) + .attr("y2", plot.h) + .attr("stroke", axisBlue) + .attr("stroke-width", 1.2 * scale); + axis.append("text") + .attr("x", -58 * sx) + .attr("y", plot.h / 2) + .attr("transform", `rotate(-90, ${-58 * sx}, ${plot.h / 2})`) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 12.5 * scale) + .attr("font-weight", 600) + .attr("fill", navy) + .text(yAxisLabel); + + const barLayer = svg.append("g") + .attr("class", "vgb11-bars") + .attr("data-relationship", "grouped-bars-grid-aligned-to-category-centers") + .attr("transform", `translate(${plot.x},${plot.y})`); + categories.forEach(category => { + const row = chartData.filter(d => String(d[xField]) === String(category)); + limitedGroups.forEach((group, groupIndex) => { + const datum = row.find(d => String(d[groupField]) === String(group)); + if (!datum) return; + const value = +datum[yField]; + if (!Number.isFinite(value)) return; + const groupSlotX = xScale(category) + groupScale(group) + groupScale.bandwidth() / 2 - barW / 2; + const y = yScale(value); + const h = Math.max(2 * scale, plot.h - y); + barLayer.append("rect") + .attr("class", `bar group-${groupIndex}`) + .attr("data-category", category) + .attr("data-group", group) + .attr("data-value", value) + .attr("x", groupSlotX) + .attr("y", y) + .attr("width", barW) + .attr("height", h) + .attr("rx", barW / 2) + .attr("ry", barW / 2) + .attr("fill", `url(#${groupGradientId(group)})`) + .attr("data-color-binding", groupColor(group)); + barLayer.append("text") + .attr("class", "bar-value-label") + .attr("data-relationship", "attached-to-bar-value-cap") + .attr("x", groupSlotX + barW / 2) + .attr("y", y - 7 * sy) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 10.5 * scale) + .attr("font-weight", 800) + .attr("fill", groupColor(group)) + .attr("data-color-binding", groupColor(group)) + .text(fmtValue(value)); + }); + const center = xScale(category) + xScale.bandwidth() / 2; + barLayer.append("ellipse") + .attr("cx", center) + .attr("cy", plot.h + 5 * sy) + .attr("rx", xScale.bandwidth() * 0.36) + .attr("ry", 7 * sy) + .attr("fill", "#dfeaf7") + .attr("opacity", 0.68); + }); + + const panel = { + x: 48 * sx, + y: 658 * sy, + w: 530 * sx, + h: 132 * sy + }; + const categoryPanel = svg.append("g") + .attr("class", "vgb11-category-label-icon-panel") + .attr("data-relationship", "grid-aligned-to-category-centers"); + categoryPanel.append("rect") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 18 * scale) + .attr("fill", "#ffffff") + .attr("stroke", "#e1edf8") + .attr("filter", "drop-shadow(0px 8px 14px rgba(32, 83, 130, 0.16))"); + + const categoryLabelMaxWidth = Math.max(42 * sx, Math.min(76 * sx, (panel.w / Math.max(1, categories.length)) * 0.92)); + categories.forEach(category => { + const center = plot.x + xScale(category) + xScale.bandwidth() / 2; + const labelLines = wrapWords(category, categoryLabelMaxWidth, 10.5 * scale, 2); + const label = categoryPanel.append("text") + .attr("x", center) + .attr("y", panel.y + 28 * sy) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 10.5 * scale) + .attr("font-weight", 600) + .attr("fill", navy); + labelLines.forEach((line, i) => { + label.append("tspan") + .attr("x", center) + .attr("dy", i === 0 ? 0 : 12 * sy) + .text(line); + }); + const slotY = panel.y + 86 * sy; + const slot = categoryPanel.append("g") + .attr("class", "reserved-asset-slot vgb11-category-icon-slot") + .attr("data-asset-slot", "category_icon_slot") + .attr("data-reserved-slot", "category_icon_slots") + .attr("data-slot-policy", "neutral_placeholder") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-category", category) + .attr("data-anchor", "category-center-below-label") + .attr("data-bbox", `${center - 22 * sx},${slotY - 22 * sy},${44 * sx},${44 * sy}`) + .attr("data-mask", "circle") + .attr("data-collision-rule", "inside-category-panel-below-label") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle") + .attr("cx", center) + .attr("cy", slotY) + .attr("r", 23 * scale) + .attr("fill", "#ffffff") + .attr("stroke", "#e1eaf5") + .attr("stroke-width", 1.2 * scale); + slot.append("circle") + .attr("cx", center) + .attr("cy", slotY) + .attr("r", 13 * scale) + .attr("fill", "#e7f2ff"); + slot.append("text") + .attr("x", center) + .attr("y", slotY + 4 * sy) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 10 * scale) + .attr("font-weight", 800) + .attr("fill", "#367fd8") + .text(String(category).trim().slice(0, 1).toUpperCase()); + }); + + const note = svg.append("g") + .attr("class", "vgb11-bottom-data-note") + .attr("data-role", "small-data-bound-note") + .attr("data-not-bottom-takeaway-wrapper", "true"); + note.append("circle") + .attr("cx", 54 * sx) + .attr("cy", 816 * sy) + .attr("r", 8 * scale) + .attr("fill", "none") + .attr("stroke", "#8bbcf2") + .attr("stroke-width", 1.4 * scale); + note.append("text") + .attr("x", 54 * sx) + .attr("y", 820 * sy) + .attr("text-anchor", "middle") + .attr("font-family", labelFont) + .attr("font-size", 11 * scale) + .attr("font-weight", 700) + .attr("fill", "#8bbcf2") + .text("i"); + note.append("text") + .attr("x", 72 * sx) + .attr("y", 821 * sy) + .attr("font-family", labelFont) + .attr("font-size", 10.5 * scale) + .attr("font-weight", 500) + .attr("fill", "#4b6f9e") + .text(`Data represents ${noteMetricLabel} for each ${String(xField).toLowerCase()}.`); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..ac9611f6cead773a1990c452b655a8266e19ad05 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_12.js @@ -0,0 +1,857 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_12", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直分组条形图实现 - 带有图标和数值标签 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 如果不存在，添加副标题字段 + typography.subtitle = typography.subtitle || typography.description; + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + const textColor = colorResolver.text({ fallback: colors.text_color || "#33413a" }).value; + const backgroundColor = colors.background_color || "#fbf6ea"; + const titleGreen = colors.other?.secondary || "#0f4a2b"; + const defaultColors = ["#b94728", "#d9a722"]; + + const groupColorFor = (group, index) => { + const direct = colors.field && colors.field[group]; + if (direct) return direct; + const available = colors.available_colors || []; + return available[index % available.length] || defaultColors[index % defaultColors.length]; + }; + + const clamp = (value, min, max) => Math.max(min, Math.min(max, value)); + const d3Color = (value, fallback) => d3.color(value) || d3.color(fallback); + const relativeLuminance = (value, fallback = "#ffffff") => { + const c = d3Color(value, fallback); + if (!c) return 1; + const channel = (v) => { + const s = v / 255; + return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4); + }; + return 0.2126 * channel(c.r) + 0.7152 * channel(c.g) + 0.0722 * channel(c.b); + }; + const lighten = (value, amount, fallback) => { + const c = d3Color(value, fallback); + return c ? c.brighter(amount).formatHex() : fallback; + }; + const darken = (value, amount, fallback) => { + const c = d3Color(value, fallback); + return c ? c.darker(amount).formatHex() : fallback; + }; + const slug = (value) => String(value).replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-|-$/g, "") || "group"; + + // 清除容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 500; + + // 边距：上，右，下，左 + const margin = { + top: 112, + right: 18, + bottom: 88, + left: 62 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, groupField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + + xField = xChannel.key; + yField = yChannel.key; + groupField = groupChannel.key; + + // 获取字段单位 + xUnit = xChannel.unit; + yUnit = yChannel.unit; + + // ---------- 4. 数据处理 ---------- + // 使用提供的数据 + let useData = chartData; + + // 获取x轴和分组的唯一值；time-like fields render chronologically by default. + const rawXValues = [...new Set(useData.map(d => d[xField]))]; + const timeLikeName = /(year|date|month|time|season|semester|quarter)/i.test(xField || ""); + const monthIndex = { + jan: 0, january: 0, feb: 1, february: 1, mar: 2, march: 2, apr: 3, april: 3, + may: 4, jun: 5, june: 5, jul: 6, july: 6, aug: 7, august: 7, sep: 8, sept: 8, + september: 8, oct: 9, october: 9, nov: 10, november: 10, dec: 11, december: 11 + }; + const timeKey = (value) => { + const s = String(value).trim(); + if (/^\d{4}$/.test(s)) return +s; + const lower = s.toLowerCase(); + if (monthIndex[lower] !== undefined) return monthIndex[lower]; + const parsed = Date.parse(s); + return Number.isNaN(parsed) ? null : parsed; + }; + const xValues = timeLikeName && rawXValues.every(d => timeKey(d) !== null) + ? rawXValues.slice().sort((a, b) => timeKey(a) - timeKey(b)) + : rawXValues; + let groupValues = [...new Set(useData.map(d => d[groupField]))]; + + // 如果组的数量不符合要求，给出警告 + if (groupValues.length !== 2) { + console.warn("此图表需要恰好2个组字段"); + } + + // 第一个组是左侧柱子，第二个组是右侧柱子 + const leftBarGroup = groupValues[0]; + const rightBarGroup = groupValues[1]; + const groups = [leftBarGroup, rightBarGroup]; + const groupColors = groups.map((group, index) => groupColorFor(group, index)); + const legendTextColor = relativeLuminance(backgroundColor) < 0.35 ? "#f8f4e8" : textColor; + const legendData = groups.map((group, index) => ({ + key: group, + color: groupColors[index], + unit: yUnit + })); + const legendSpacing = 24; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + defs.append("linearGradient") + .attr("id", "vg12-background") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%") + .selectAll("stop") + .data([ + { offset: "0%", color: lighten(backgroundColor, 0.55, "#fffaf0") }, + { offset: "100%", color: backgroundColor } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + svg.append("rect") + .attr("class", "chart-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "none"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + groups.forEach((group, i) => { + const groupColor = groupColors[i]; + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", lighten(groupColor, 0.45, defaultColors[i])) + .attr("stop-opacity", 1); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", darken(groupColor, 0.2, defaultColors[i])) + .attr("stop-opacity", 1); + }); + + const panel = { + x: 10, + y: 74, + width: width - 20, + height: height - 88, + radius: 18 + }; + + svg.append("rect") + .attr("class", "chart-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.width) + .attr("height", panel.height) + .attr("rx", panel.radius) + .attr("ry", panel.radius) + .attr("fill", "#fffdf6") + .attr("stroke", "#e2d7bf") + .attr("stroke-width", 1.5) + .style("filter", variables.has_shadow ? "url(#shadow)" : "drop-shadow(0 2px 4px rgba(86, 68, 38, 0.14))"); + + // ---------- 7. 创建图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8. 创建比例尺 ---------- + // X比例尺（分类）用于主分类 + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.10); + + // 分组比例尺，用于每个类别内的细分 + const groupScale = d3.scaleBand() + .domain([0, 1]) // 只有两个柱子，左侧和右侧 + .range([0, xScale.bandwidth()]) + .padding(0.2); // 同一维度柱子之间的间隙，增加间隔 + + // Y比例尺（数值）- 直接使用最大值映射到可用高度 + const dataMax = d3.max(useData, d => +d[yField]) || 100; + const yScale = d3.scaleLinear() + .domain([0, dataMax * 1.12]) + .nice(5) + .range([innerHeight, 0]); + + // ---------- 9. 文本宽度计算和字体大小调整 (移动到这里，在绘制坐标轴之前) ---------- + // 添加数值格式化函数 + + // 创建格式化函数 + const formattedValue = (value) => { + const numeric = +value || 0; + if (Math.abs(numeric) < 10 && Math.abs(numeric - Math.round(numeric)) > 1e-6) { + return d3.format(".2f")(numeric).replace(/\.?0+$/, ""); + } + return d3.format(",.0f")(numeric); + }; + + // 数值标签的可用宽度 = bar宽度 + 间距 + const barWidth = Math.min(30, Math.max(18, xScale.bandwidth() * 0.40)); + const pairGap = Math.max(4, xScale.bandwidth() * 0.07); + const valueSpacing = xScale.bandwidth() * 0.1; + const valueLabelAvailableWidth = Math.max(barWidth * 2.2, xScale.bandwidth() * 0.62); + + // 维度标签的可用宽度 = 两个bar宽度 + bar间距 + const dimensionLabelAvailableWidth = xScale.bandwidth(); + + // 计算最长的数值标签和维度标签 + let maxValueLabelWidth = 0; + let maxDimensionLabelWidth = 0; + + // 计算所有数值标签的最大宽度 + useData.forEach(d => { + const textWidth = chartUtils.text.measure(svg, formattedValue(+d[yField]), { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxValueLabelWidth = Math.max(maxValueLabelWidth, textWidth); + }); + + // 计算所有维度标签的最大宽度 + xValues.forEach(xValue => { + const textWidth = chartUtils.text.measure(svg, xValue, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxDimensionLabelWidth = Math.max(maxDimensionLabelWidth, textWidth); + }); + + // 计算需要的字体缩放比例 + const valueFontScale = Math.min(1, valueLabelAvailableWidth / maxValueLabelWidth); + const dimensionFontScale = Math.min(1, dimensionLabelAvailableWidth / maxDimensionLabelWidth); + + // 计算实际使用的字体大小 + const valueFontSize = Math.max(10, Math.min(12, parseInt(typography.label.font_size) * valueFontScale)); + const dimensionFontSize = Math.max(8, parseInt(typography.label.font_size) * dimensionFontScale); + + // 计算动态文本大小的函数 + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + // 否则，按比例缩小字体大小 + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + const roundedTopBarPath = (x, y, w, h, r) => { + const radius = clamp(Math.min(r, w / 2, h), 0, 4); + if (h <= 0) return ""; + return [ + `M${x},${y + h}`, + `L${x},${y + radius}`, + `Q${x},${y} ${x + radius},${y}`, + `L${x + w - radius},${y}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `L${x + w},${y + h}`, + "Z" + ].join(" "); + }; + + const yTicks = yScale.ticks(5); + chart.append("g") + .attr("class", "y-grid") + .selectAll("line") + .data(yTicks) + .enter() + .append("line") + .attr("x1", 0) + .attr("x2", innerWidth) + .attr("y1", d => yScale(d)) + .attr("y2", d => yScale(d)) + .attr("stroke", "#dfd3bd") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 4"); + + chart.append("line") + .attr("class", "y-axis-line") + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", "#3e4846") + .attr("stroke-width", 1.2); + + chart.append("line") + .attr("class", "baseline") + .attr("x1", 0) + .attr("x2", innerWidth) + .attr("y1", innerHeight) + .attr("y2", innerHeight) + .attr("stroke", "#3e4846") + .attr("stroke-width", 1.2); + + chart.append("g") + .attr("class", "y-tick-labels") + .selectAll("text") + .data(yTicks) + .enter() + .append("text") + .attr("x", -10) + .attr("y", d => yScale(d) + 4) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", "12px") + .style("font-weight", 500) + .style("fill", textColor) + .text(d => chartUtils.format.autoText(d)); + + chart.append("text") + .attr("class", "y-axis-title") + .attr("transform", `translate(${-52}, ${innerHeight / 2}) rotate(-90)`) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "14px") + .style("font-weight", 600) + .style("fill", textColor) + .text(`${yField}${yUnit ? ` (${yUnit})` : ""}`); + + // ---------- 10. 创建坐标轴 (原来的第9步) ---------- + // 创建x轴组，用于添加刻度标签 + const xAxisGroup = chart.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight + 50})`); + + // 第一步：找出最长的标签并计算统一的字体大小 + let maxLabelLength = 0; + const allLabels = xValues.map(d => d.toString()); + + // 找出最长的标签 + const longestLabel = allLabels.reduce((a, b) => a.length > b.length ? a : b, ""); + + // 使用最长标签计算合适的统一字体大小 + const labelMaxWidth = xScale.bandwidth()*1.3; + const uniformFontSize = calculateFontSize(longestLabel, labelMaxWidth, parseInt(typography.label.font_size)); + + // 绘制x轴标签 + xAxisGroup.selectAll(".x-label") + .data(xValues) + .enter() + .append("text") + .attr("class", "x-label") + .attr("x", d => xScale(d) + xScale.bandwidth() / 2) + .attr("y", 12) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${uniformFontSize}px`) // 应用统一的字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => d) + .each(function(d) { + const text = d3.select(this); + const labelText = d.toString(); + const labelWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: uniformFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 检查使用统一字体大小后，文本是否仍然超过可用宽度 + if (labelWidth > labelMaxWidth) { + // 如果仍然太长，应用文本换行 + wrapText(text, labelText, labelMaxWidth, 1.1); + } + }); + + // 文本换行助手函数 + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + + // 先清空文本 + text.text(null); + + // 处理文本 + let tspans = []; + + // 如果没有空格可分割，按字符分割 + if (words.length <= 1) { + const chars = str.split(''); + let currentLine = ''; + + for (let i = 0; i < chars.length; i++) { + currentLine += chars[i]; + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine, { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 当前行过长，回退一个字符并换行 + currentLine = currentLine.slice(0, -1); + + // 添加到tspans数组 + tspans.push(currentLine); + + // 重新开始下一行 + currentLine = chars[i]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } else { + // 处理有空格的文本 + let currentLine = []; + + while (word = words.pop()) { + currentLine.push(word); + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 回退一个词 + currentLine.pop(); + + // 添加到tspans数组 + tspans.push(currentLine.join(" ")); + + // 重新开始下一行 + currentLine = [word]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } + + // 计算总行数 + const totalLines = tspans.length; + + // 计算垂直居中的起始位置 + // 对于单行文本，y位置保持不变 + // 对于多行文本，需要向上偏移以保持垂直居中 + let startY = y; + if (totalLines > 1) { + // 向上偏移半行距离 * (总行数-1) + startY = parseFloat(y) - (lineHeight * (totalLines - 1) / 2); + } + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + text.append("tspan") + .attr("x", text.attr("x")) + .attr("y", startY) + .attr("dy", `${i * lineHeight}em`) + .text(lineText); + }); + } + + // ---------- 11. 绘制图例 (selected-reference standalone pill) ---------- + const legendPill = { + width: Math.min(width - 120, Math.max(300, groups.join("").length * 9 + 215)), + height: 50, + y: 18 + }; + legendPill.x = (width - legendPill.width) / 2; + const legend = svg.append("g") + .attr("class", "legend reference-legend-pill") + .attr("data-reference-relationship", "independent-centered-between-subtitle-and-chart-card") + .attr("transform", `translate(${legendPill.x}, ${legendPill.y})`); + + legend.append("rect") + .attr("class", "legend-pill-bg") + .attr("x", 0) + .attr("y", 0) + .attr("width", legendPill.width) + .attr("height", legendPill.height) + .attr("rx", 10) + .attr("ry", 10) + .attr("fill", "#fffdf7") + .attr("stroke", "#e2d7bf") + .attr("stroke-width", 1.2) + .style("filter", variables.has_shadow ? "url(#shadow)" : "drop-shadow(0 1.5px 3px rgba(86, 68, 38, 0.14))"); + + const drawLegendMarker = (g, cx, cy, color, index) => { + const marker = g.append("g") + .attr("class", "reserved-asset-slot legend-marker-slot") + .attr("data-asset-slot", "legend-marker") + .attr("data-asset-anchor", groups[index]) + .attr("data-asset-bbox", `${cx - 13},${cy - 16},26,32`) + .attr("data-collision-avoid", "legend-label,legend-pill") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + marker.append("path") + .attr("d", `M${cx},${cy - 16} C${cx + 11},${cy - 2} ${cx + 12},${cy + 12} ${cx},${cy + 15} C${cx - 12},${cy + 12} ${cx - 11},${cy - 2} ${cx},${cy - 16} Z`) + .attr("fill", color) + .attr("stroke", darken(color, 0.35, color)) + .attr("stroke-width", 0.8); + marker.append("path") + .attr("d", `M${cx + 5},${cy + 2} C${cx + 5},${cy + 8} ${cx + 1},${cy + 11} ${cx - 5},${cy + 10}`) + .attr("fill", "none") + .attr("stroke", "#ffffff") + .attr("stroke-width", 2) + .attr("stroke-linecap", "round") + .attr("opacity", 0.9); + }; + + const legendItemWidth = legendPill.width / 2; + legendData.forEach((itemData, index) => { + const itemX = index * legendItemWidth + 26; + const itemGroup = legend.append("g") + .attr("class", "legend-item") + .attr("transform", `translate(${itemX}, 0)`); + drawLegendMarker(itemGroup, 0, 25, itemData.color, index); + itemGroup.append("text") + .attr("x", 22) + .attr("y", 22) + .attr("dominant-baseline", "middle") + .attr("fill", textColor) + .style("font-family", typography.label.font_family) + .style("font-size", "13px") + .style("font-weight", 700) + .text(itemData.key); + itemGroup.append("text") + .attr("x", 22) + .attr("y", 38) + .attr("dominant-baseline", "middle") + .attr("fill", textColor) + .style("font-family", typography.label.font_family) + .style("font-size", "10px") + .style("font-weight", 500) + .text(yUnit ? `(${yUnit})` : ""); + }); + + const categoryTotals = xValues.map(xValue => { + const rows = useData.filter(d => d[xField] === xValue); + return { + xValue, + total: d3.sum(rows, d => +d[yField] || 0), + firstValue: +(rows.find(d => d[groupField] === leftBarGroup)?.[yField] || 0), + complete: groups.every(group => rows.some(d => d[groupField] === group)) + }; + }); + const highlightDatum = categoryTotals + .filter(d => d.complete) + .sort((a, b) => d3.descending(a.firstValue || a.total, b.firstValue || b.total))[0]; + if (highlightDatum && xScale.bandwidth() > 35) { + const hx = xScale(highlightDatum.xValue) + xScale.bandwidth() * 0.07; + const hw = xScale.bandwidth() * 0.86; + chart.insert("rect", ".y-grid") + .attr("class", "max-category-highlight") + .attr("x", hx) + .attr("y", -10) + .attr("width", hw) + .attr("height", innerHeight + 12) + .attr("rx", 10) + .attr("ry", 10) + .attr("fill", "#dcebd3") + .attr("stroke", "#9fbe8e") + .attr("stroke-width", 1) + .attr("opacity", 0.45); + } + + // 绘制条形图和标签 + xValues.forEach(xValue => { + // 获取当前x类别的数据 + const xData = useData.filter(d => d[xField] === xValue); + + // 获取左侧柱子的数据 + const leftBarData = xData.find(d => d[groupField] === leftBarGroup); + + // 获取右侧柱子的数据 + const rightBarData = xData.find(d => d[groupField] === rightBarGroup); + + // 计算左侧柱子的位置和高度 + const clusterCenter = xScale(xValue) + xScale.bandwidth() / 2; + const leftBarX = clusterCenter - barWidth - pairGap / 2; + let leftBarY, leftBarHeight, leftValue; + + // --- Variables to track label/bar positions for icon placement --- + let minBarTopY = innerHeight; + let minExternalLabelTopY = innerHeight; + let leftLabelIsOutside = false; // Track label position + let rightLabelIsOutside = false; + // ------------------------------------------------------------- + + if (leftBarData) { + leftValue = leftBarData[yField]; + leftBarHeight = innerHeight - yScale(leftValue); + leftBarY = yScale(leftValue); + minBarTopY = Math.min(minBarTopY, leftBarY); + + // 绘制左侧柱子 + chart.append("path") + .attr("class", "bar left-bar") + .attr("data-group", leftBarGroup) + .attr("data-x", xValue) + .attr("data-y", leftValue) + .attr("d", roundedTopBarPath(leftBarX, leftBarY, barWidth, leftBarHeight, Math.min(3, barWidth * 0.16))) + .attr("fill", "url(#bar-gradient-0)") + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 绘制左侧柱子顶部的标签 + const leftValueText = formattedValue(leftValue); + let leftLabelFontSize = valueFontSize; // 默认使用之前计算的字体大小 + let leftTextWidth = chartUtils.text.measure(chart, leftValueText, { + fontFamily: typography.label.font_family, + fontSize: `${leftLabelFontSize}px`, + fontWeight: "bold" + }).width; + const maxLabelWidth = Math.max(barWidth * 2.2, xScale.bandwidth() * 0.62); + if (leftTextWidth > maxLabelWidth) { + leftLabelFontSize = Math.max(8, leftLabelFontSize * (maxLabelWidth / leftTextWidth)); + } + // *** 修改: 判断标签是否能放入 Bar 内 *** + const labelHeightRequired = leftLabelFontSize + 10; // 字体高度 + 上下 padding + let leftLabelY, leftLabelColor, leftDominantBaseline = "auto"; // Default baseline + + leftLabelY = Math.max(14, leftBarY - 7); + leftLabelColor = groupColors[0]; + leftDominantBaseline = "auto"; + minExternalLabelTopY = Math.min(minExternalLabelTopY, leftLabelY - leftLabelFontSize); + leftLabelIsOutside = true; + + chart.append("text") + .attr("class", "bar-label left-label") + .attr("x", leftBarX + barWidth / 2) + .attr("y", leftLabelY) // 使用计算的 Y + .attr("dominant-baseline", leftDominantBaseline) // 设置 baseline + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${leftLabelFontSize}px`) + .style("font-weight", "bold") + .style("fill", leftLabelColor) // 使用计算的颜色 + .text(leftValueText); + } else { + leftValue = 0; + leftBarHeight = 0; + leftBarY = innerHeight; + } + + const rightBarX = leftBarX + barWidth + pairGap; + let rightBarY, rightBarHeight, rightValue; + + if (rightBarData) { + rightValue = rightBarData[yField]; + rightBarHeight = innerHeight - yScale(rightValue); + rightBarY = yScale(rightValue); + minBarTopY = Math.min(minBarTopY, rightBarY); + + // 绘制右侧柱子 + chart.append("path") + .attr("class", "bar right-bar") + .attr("data-group", rightBarGroup) + .attr("data-x", xValue) + .attr("data-y", rightValue) + .attr("d", roundedTopBarPath(rightBarX, rightBarY, barWidth, rightBarHeight, Math.min(3, barWidth * 0.16))) + .attr("fill", "url(#bar-gradient-1)") + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 绘制右侧柱子顶部的标签 + const rightValueText = formattedValue(rightValue); + let rightLabelFontSize = valueFontSize; // 默认使用之前计算的字体大小 + let rightTextWidth = chartUtils.text.measure(chart, rightValueText, { + fontFamily: typography.label.font_family, + fontSize: `${rightLabelFontSize}px`, + fontWeight: "bold" + }).width; + const rightMaxLabelWidth = Math.max(barWidth * 2.2, xScale.bandwidth() * 0.62); + if (rightTextWidth > rightMaxLabelWidth) { + rightLabelFontSize = Math.max(8, rightLabelFontSize * (rightMaxLabelWidth / rightTextWidth)); + } + // *** 修改: 判断标签是否能放入 Bar 内 *** + const rightLabelHeightRequired = rightLabelFontSize + 10; // 字体高度 + 上下 padding + let rightLabelY, rightLabelColor, rightDominantBaseline = "auto"; + + rightLabelY = Math.max(14, rightBarY - 7); + rightLabelColor = groupColors[1]; + rightDominantBaseline = "auto"; + minExternalLabelTopY = Math.min(minExternalLabelTopY, rightLabelY - rightLabelFontSize); + rightLabelIsOutside = true; + + chart.append("text") + .attr("class", "bar-label right-label") + .attr("x", rightBarX + barWidth / 2) + .attr("y", rightLabelY) // 使用计算的 Y + .attr("dominant-baseline", rightDominantBaseline) // 设置 baseline + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${rightLabelFontSize}px`) + .style("font-weight", "bold") + .style("fill", rightLabelColor) // 使用计算的颜色 + .text(rightValueText); + } else { + rightValue = 0; + rightBarHeight = 0; + rightBarY = innerHeight; + } + + const iconSize = clamp(xScale.bandwidth() * 0.64, 25, 38); + const iconX = xScale(xValue) + xScale.bandwidth() / 2; + const iconY = innerHeight + 28; + const slot = chart.append("g") + .attr("class", "reserved-asset-slot category-icon-slot") + .attr("data-asset-slot", "category-icon") + .attr("data-asset-anchor", String(xValue)) + .attr("data-asset-bbox", `${iconX - iconSize / 2},${iconY - iconSize / 2},${iconSize},${iconSize}`) + .attr("data-collision-avoid", "bars,value-labels,x-labels,panel-border") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle") + .attr("cx", iconX) + .attr("cy", iconY) + .attr("r", iconSize / 2) + .attr("fill", lighten(backgroundColor, 0.4, "#fff6d9")) + .attr("stroke", "#cdbb91") + .attr("stroke-width", 1.2); + slot.append("circle") + .attr("cx", iconX) + .attr("cy", iconY) + .attr("r", Math.max(2.4, iconSize / 10)) + .attr("fill", titleGreen) + .attr("opacity", 0.45); + + }); // --- END xValues.forEach --- + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_13.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_13.js new file mode 100644 index 0000000000000000000000000000000000000000..c40c33d37870c934968921fc352b556b92d8ff54 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_13.js @@ -0,0 +1,1192 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_13", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 垂直分组条形图实现 - 手绘风格 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + // Use a sketch-like font for labels + label: { font_family: "'Comic Sans MS', cursive", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // Default primary color (less relevant now) + } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + typography.subtitle = typography.subtitle || typography.description; + + // Sketch style doesn't usually use rounded corners or gradients + variables.has_rounded_corners = false; // Force disable rounded corners for sketch style + variables.has_gradient = false; // Force disable gradient + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + const width = variables.width || 800; + const height = variables.height || 500; + const margin = { + top: 100, right: 30, bottom: 100, // Increased bottom margin for sketch labels + icons + left: 30 + }; + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, groupField; + let xUnit = "", yUnit = ""; + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + xField = xChannel.key; + yField = yChannel.key; + groupField = groupChannel.key; + xUnit = xChannel.unit; + yUnit = yChannel.unit; + + // ---------- 4. 数据处理 ---------- + let useData = chartData; + const xValues = [...new Set(useData.map(d => d[xField]))]; + let groupValues = [...new Set(useData.map(d => d[groupField]))]; + if (groupValues.length !== 2) { + console.warn("此图表需要恰好2个组字段"); + // Handle error or default behavior if groups != 2 + if (groupValues.length < 2) return; // Stop if not enough groups + groupValues = groupValues.slice(0, 2); // Take first two if more than 2 + } + const leftBarGroup = groupValues[0]; + const rightBarGroup = groupValues[1]; + + // 获取分组颜色，若未在colors.field中定义，则使用默认颜色 + const leftGroupColor = colorResolver.field(leftBarGroup, 0, { fallback: "#4269d0" }).value; + const rightGroupColor = colorResolver.field(rightBarGroup, 0, { fallback: "#ff725c" }).value; + + return renderReferenceAligned(); + + function renderReferenceAligned() { + d3.select(containerSelector).html(""); + + const width = variables.width || 800; + const height = variables.height || 500; + const textColor = colorResolver.text({ fallback: colors.text_color || "#26352c" }).value; + const bgColor = "#fbf8ea"; + const darkGreen = "#0f4b27"; + const redAccent = "#d83a20"; + const orange = "#f4b52a"; + const orangeDark = "#d95a06"; + const green = "#4d9a46"; + const greenDark = "#0d6a3f"; + + const clamp = (value, min, max) => Math.max(min, Math.min(max, value)); + const d3Color = (value, fallback) => d3.color(value) || d3.color(fallback); + const lighten = (value, amount, fallback) => { + const c = d3Color(value, fallback); + return c ? c.brighter(amount).formatHex() : fallback; + }; + const darken = (value, amount, fallback) => { + const c = d3Color(value, fallback); + return c ? c.darker(amount).formatHex() : fallback; + }; + const slug = (value) => String(value).replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-|-$/g, "") || "group"; + const fontFamily = typography.label?.font_family || "Arial, sans-serif"; + const titleFamily = typography.title?.font_family || "Arial, sans-serif"; + + const measure = (text, size, weight = 500, family = fontFamily) => + chartUtils.text.measure(null, String(text), { + fontFamily: family, + fontSize: size, + fontWeight: weight + }).width; + const fitFont = (text, maxWidth, base, min, weight = 700, family = titleFamily) => { + const w = measure(text, base, weight, family); + return Math.max(min, Math.min(base, base * (maxWidth / Math.max(w, 1)))); + }; + const ellipsizeText = (text, maxWidth, size, weight = 800, family = fontFamily) => { + const value = String(text || ""); + if (measure(value, size, weight, family) <= maxWidth) return value; + let trimmed = value; + while (trimmed.length > 1 && measure(`${trimmed}...`, size, weight, family) > maxWidth) { + trimmed = trimmed.slice(0, -1).trimEnd(); + } + return trimmed.length > 1 ? `${trimmed}...` : value.slice(0, 1); + }; + const wrapLines = (text, maxWidth, size, weight = 500, family = fontFamily, maxLines = 3) => { + const words = String(text || "").split(/\s+/).filter(Boolean); + if (!words.length) return []; + const lines = []; + let line = ""; + words.forEach(word => { + const next = line ? `${line} ${word}` : word; + if (measure(next, size, weight, family) <= maxWidth || !line) { + line = next; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + if (lines.length <= maxLines) return lines; + const kept = lines.slice(0, maxLines); + while (measure(`${kept[maxLines - 1]}...`, size, weight, family) > maxWidth && kept[maxLines - 1].length > 4) { + kept[maxLines - 1] = kept[maxLines - 1].slice(0, -1); + } + kept[maxLines - 1] = `${kept[maxLines - 1]}...`; + return kept; + }; + const addTextLines = (parent, lines, x, y, opts = {}) => { + const size = opts.size || 12; + const lineHeight = opts.lineHeight || size * 1.18; + const g = parent.append("g").attr("class", opts.class || "wrapped-text"); + lines.forEach((line, index) => { + g.append("text") + .attr("x", x) + .attr("y", y + index * lineHeight) + .attr("text-anchor", opts.anchor || "start") + .attr("dominant-baseline", opts.baseline || "hanging") + .style("font-family", opts.family || fontFamily) + .style("font-size", `${size}px`) + .style("font-weight", opts.weight || 500) + .style("fill", opts.fill || textColor) + .text(line); + }); + return g; + }; + const formatValue = (value) => { + const numeric = +value || 0; + if (Math.abs(numeric) < 1) return d3.format(".3f")(numeric).replace(/\.?0+$/, ""); + if (Math.abs(numeric) < 10) return d3.format(".2f")(numeric).replace(/\.?0+$/, ""); + return d3.format(",.0f")(numeric); + }; + const prettifyMetricLabel = (value) => String(value || "") + .replace(/[_-]+/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") + .replace(/([a-zA-Z])(\d)/g, "$1 $2") + .replace(/(\d)([a-zA-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + const smallValueAxis = (maxValue) => { + if (maxValue <= 0.12) return { max: Math.ceil(maxValue / 0.02) * 0.02, step: 0.02 }; + if (maxValue <= 0.4) return { max: Math.ceil(maxValue / 0.05) * 0.05, step: 0.05 }; + if (maxValue <= 1) return { max: Math.ceil(maxValue / 0.1) * 0.1, step: 0.1 }; + return null; + }; + const roundedTopBarPath = (x, y, w, h, r) => { + const radius = clamp(Math.min(r, w / 2, h), 0, 3); + if (h <= 0) return ""; + return [ + `M${x},${y + h}`, + `L${x},${y + radius}`, + `Q${x},${y} ${x + radius},${y}`, + `L${x + w - radius},${y}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `L${x + w},${y + h}`, + "Z" + ].join(" "); + }; + + const rawXValues = [...new Set(useData.map(d => d[xField]))]; + const timeLikeName = /(year|date|month|time|season|semester|quarter)/i.test(xField || ""); + const monthIndex = { + jan: 0, january: 0, feb: 1, february: 1, mar: 2, march: 2, apr: 3, april: 3, + may: 4, jun: 5, june: 5, jul: 6, july: 6, aug: 7, august: 7, sep: 8, sept: 8, + september: 8, oct: 9, october: 9, nov: 10, november: 10, dec: 11, december: 11 + }; + const timeKey = (value) => { + const s = String(value).trim(); + if (/^\d{4}$/.test(s)) return +s; + const lower = s.toLowerCase(); + if (monthIndex[lower] !== undefined) return monthIndex[lower]; + const parsed = Date.parse(s); + return Number.isNaN(parsed) ? null : parsed; + }; + const xValues = timeLikeName && rawXValues.every(d => timeKey(d) !== null) + ? rawXValues.slice().sort((a, b) => timeKey(a) - timeKey(b)) + : rawXValues; + const groups = groupValues.slice(0, 2); + const averages = groups.map(group => ({ + group, + average: d3.mean(useData.filter(d => d[groupField] === group), d => +d[yField] || 0) || 0 + })); + const lowGroup = (averages[0].average <= averages[1].average ? averages[0] : averages[1]).group; + const highGroup = (lowGroup === groups[0] ? groups[1] : groups[0]); + const legendGroups = [lowGroup, highGroup]; + const barGroups = [highGroup, lowGroup]; + const colorFor = (group) => { + const name = String(group).toLowerCase(); + if (name.includes("organic") || group === lowGroup) return group === lowGroup ? green : colorResolver.field(group, 0, { fallback: green }).value; + if (name.includes("conventional") || group === highGroup) return group === highGroup ? orange : colorResolver.field(group, 1, { fallback: orange }).value; + return colorResolver.field(group, groups.indexOf(group), { fallback: groups.indexOf(group) === 0 ? green : orange }).value; + }; + const groupColor = new Map(legendGroups.map(group => [group, colorFor(group)])); + groupColor.set(highGroup, colorFor(highGroup)); + groupColor.set(lowGroup, colorFor(lowGroup)); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", "vg13-background") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "100%") + .selectAll("stop") + .data([ + { offset: "0%", color: "#fffdf4" }, + { offset: "68%", color: bgColor }, + { offset: "100%", color: "#edf6d7" } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + svg.append("rect") + .attr("class", "chart-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#vg13-background)"); + + legendGroups.forEach((group, index) => { + const color = groupColor.get(group) || (index ? orange : green); + const pattern = defs.append("pattern") + .attr("id", `vg13-hatch-${slug(group)}`) + .attr("width", 7) + .attr("height", 7) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + pattern.append("rect").attr("width", 7).attr("height", 7).attr("fill", color); + pattern.append("path") + .attr("d", "M -1,2 L 8,2 M -1,5 L 8,5") + .attr("stroke", "#fff7cf") + .attr("stroke-width", 1.1) + .attr("opacity", 0.9); + }); + + const rangeText = (() => { + const parsed = xValues.map(timeKey).filter(d => d !== null); + if (parsed.length === xValues.length && xValues.length > 1 && /^\d{4}$/.test(String(xValues[0]))) { + return ` from ${xValues[0]} to ${xValues[xValues.length - 1]}`; + } + return ""; + })(); + const primaryPesticide = /pesticide\s*residue/i.test(prettifyMetricLabel(yField)) + && legendGroups.some(group => /organic/i.test(String(group))) + && legendGroups.some(group => /conventional/i.test(String(group))); + const titleSpec = primaryPesticide + ? { + line1: "Conventional Strawberries", + line2: "Have Higher Pesticide Residue", + subtitle: "Pesticide residue for conventional and organic strawberries from 2010 to 2023 (measured in ppm)." + } + : { + line1: `${prettifyMetricLabel(yField)} Comparison:`, + line2: `${String(highGroup)} vs. ${String(lowGroup)}`, + subtitle: `${prettifyMetricLabel(yField)} for ${String(highGroup)} and ${String(lowGroup)}${rangeText}${yUnit ? `, measured in ${yUnit}` : ""}.` + }; + const headerLeft = width * 0.05; + const titleMaxW = width * 0.72; + const titleLine1Size = fitFont(titleSpec.line1, titleMaxW, clamp(height * 0.048, 42, 62), 24, 900, titleFamily); + const titleLine2Size = fitFont(titleSpec.line2, titleMaxW, clamp(height * 0.045, 38, 58), 22, 900, titleFamily); + svg.append("text") + .attr("class", "header-title-line header-title-primary") + .attr("x", headerLeft) + .attr("y", height * 0.035) + .attr("dominant-baseline", "hanging") + .style("font-family", titleFamily) + .style("font-size", `${titleLine1Size}px`) + .style("font-weight", 900) + .style("fill", darkGreen) + .text(titleSpec.line1); + svg.append("text") + .attr("class", "header-title-line header-title-accent") + .attr("x", headerLeft) + .attr("y", height * 0.095) + .attr("dominant-baseline", "hanging") + .style("font-family", titleFamily) + .style("font-size", `${titleLine2Size}px`) + .style("font-weight", 900) + .style("fill", redAccent) + .text(titleSpec.line2); + const dividerY = height * 0.137; + svg.append("line") + .attr("class", "header-divider") + .attr("x1", headerLeft) + .attr("x2", width * 0.32) + .attr("y1", dividerY) + .attr("y2", dividerY) + .attr("stroke", "#24733f") + .attr("stroke-width", 2); + svg.append("line") + .attr("class", "header-divider") + .attr("x1", width * 0.395) + .attr("x2", width * 0.61) + .attr("y1", dividerY) + .attr("y2", dividerY) + .attr("stroke", "#24733f") + .attr("stroke-width", 2); + const ornament = svg.append("g") + .attr("class", "reserved-asset-slot title-ornament-slot") + .attr("data-asset-slot", "title-ornament") + .attr("data-asset-bbox", `${width * 0.35},${dividerY - 15},${width * 0.04},30`) + .attr("data-asset-anchor", "header-divider-center") + .attr("data-collision-avoid", "title,subtitle,hero-produce-art") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + ornament.append("ellipse") + .attr("cx", width * 0.365) + .attr("cy", dividerY) + .attr("rx", 11) + .attr("ry", 7) + .attr("fill", "#8fbd78"); + addTextLines(svg, wrapLines(titleSpec.subtitle, width * 0.58, clamp(height * 0.018, 16, 24), 500, fontFamily, 2), headerLeft, height * 0.160, { + class: "header-subtitle", + size: clamp(height * 0.018, 16, 24), + lineHeight: clamp(height * 0.028, 24, 35), + fill: textColor, + weight: 500 + }); + const heroX = width * 0.765; + const heroY = height * 0.020; + const heroW = width * 0.185; + const heroH = height * 0.190; + const hero = svg.append("g") + .attr("class", "reserved-asset-slot hero-produce-slot") + .attr("data-asset-slot", "hero-produce-art") + .attr("data-asset-bbox", `${heroX},${heroY},${heroW},${heroH}`) + .attr("data-asset-anchor", "header-top-right") + .attr("data-collision-avoid", "title,subtitle,comparison-card") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + hero.append("circle") + .attr("cx", heroX + heroW * 0.58) + .attr("cy", heroY + heroH * 0.44) + .attr("r", heroW * 0.38) + .attr("fill", "#eef6ce") + .attr("stroke", "#a8c287") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "7 6") + .attr("opacity", 0.75); + hero.append("circle") + .attr("cx", heroX + heroW * 0.34) + .attr("cy", heroY + heroH * 0.56) + .attr("r", heroW * 0.15) + .attr("fill", "#d7edbb") + .attr("stroke", "#78a86d") + .attr("stroke-width", 1.6) + .attr("opacity", 0.72); + + const card = { x: width * 0.05, y: height * 0.226, w: width * 0.90, h: height * 0.114 }; + svg.append("rect") + .attr("class", "comparison-card") + .attr("x", card.x) + .attr("y", card.y) + .attr("width", card.w) + .attr("height", card.h) + .attr("rx", 14) + .attr("ry", 14) + .attr("fill", "#fffdf2") + .attr("stroke", "#dfdfbf") + .attr("stroke-width", 1) + .style("filter", "drop-shadow(0 2px 5px rgba(80,90,50,0.12))"); + const hazard = svg.append("g") + .attr("class", "reserved-asset-slot hazard-product-slot") + .attr("data-asset-slot", "hazard-product-art") + .attr("data-asset-bbox", `${card.x + 14},${card.y + 12},${card.w * 0.19},${card.h - 24}`) + .attr("data-asset-anchor", "comparison-card-left") + .attr("data-collision-avoid", "comparison-card-text,legend") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + hazard.append("rect") + .attr("x", card.x + 44) + .attr("y", card.y + 20) + .attr("width", card.w * 0.08) + .attr("height", card.h - 38) + .attr("rx", 6) + .attr("fill", "#89c77e") + .attr("stroke", greenDark) + .attr("opacity", 0.65); + [0, 1, 2].forEach(i => { + const cx = card.x + 25; + const cy = card.y + 23 + i * 20; + svg.append("path") + .attr("class", "comparison-warning-mark") + .attr("d", `M${cx - 5},${cy - 5} L${cx + 5},${cy + 5} M${cx + 5},${cy - 5} L${cx - 5},${cy + 5}`) + .attr("stroke", redAccent) + .attr("stroke-width", 3) + .attr("stroke-linecap", "round"); + }); + const infoMidX = card.x + card.w * 0.33; + const infoRightX = card.x + card.w * 0.62; + svg.append("line") + .attr("x1", card.x + card.w * 0.58) + .attr("x2", card.x + card.w * 0.58) + .attr("y1", card.y + 18) + .attr("y2", card.y + card.h - 18) + .attr("stroke", "#a8c09b") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "2 5"); + const avgText = (group) => `${formatValue(averages.find(d => d.group === group)?.average || 0)}${yUnit ? ` ${yUnit}` : ""} avg`; + const drawGroupSummary = (x, group, isHigh) => { + const color = groupColor.get(group) || (isHigh ? orange : green); + svg.append("circle") + .attr("class", "comparison-card-swatch") + .attr("cx", x) + .attr("cy", card.y + card.h * 0.36) + .attr("r", 18) + .attr("fill", isHigh ? `url(#vg13-hatch-${slug(group)})` : "#f3fff1") + .attr("stroke", color) + .attr("stroke-width", 2); + svg.append("text") + .attr("x", x + 32) + .attr("y", card.y + card.h * 0.26) + .attr("dominant-baseline", "hanging") + .style("font-family", titleFamily) + .style("font-size", `${clamp(height * 0.025, 12, 16)}px`) + .style("font-weight", 800) + .style("fill", isHigh ? orangeDark : greenDark) + .text(String(group)); + addTextLines(svg, wrapLines(isHigh ? `Higher residue (${avgText(group)})` : `Lower residue (${avgText(group)})`, card.w * 0.20, 12, 500, fontFamily, 2), x + 32, card.y + card.h * 0.52, { + class: "comparison-card-description", + size: clamp(height * 0.018, 9, 12), + lineHeight: clamp(height * 0.023, 11, 14), + fill: textColor, + weight: 500 + }); + }; + drawGroupSummary(infoMidX, lowGroup, false); + drawGroupSummary(infoRightX, highGroup, true); + + const panel = { x: width * 0.031, y: height * 0.353, w: width * 0.938, h: height * 0.473 }; + svg.append("rect") + .attr("class", "chart-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 15) + .attr("ry", 15) + .attr("fill", "#fffef5") + .attr("stroke", "#d8dfb4") + .attr("stroke-width", 1.1) + .style("filter", "drop-shadow(0 2px 5px rgba(80,90,50,0.10))"); + svg.append("text") + .attr("class", "y-axis-panel-title") + .attr("x", panel.x + 12) + .attr("y", panel.y + 16) + .attr("dominant-baseline", "hanging") + .style("font-family", fontFamily) + .style("font-size", `${clamp(height * 0.020, 10, 13)}px`) + .style("font-weight", 800) + .style("fill", textColor) + .text(`${prettifyMetricLabel(yField)}${yUnit ? ` (${yUnit})` : ""}`); + + const legend = svg.append("g") + .attr("class", "legend chart-owned-legend") + .attr("data-reference-relationship", "independent-centered-above-plot") + .attr("transform", `translate(${panel.x + panel.w * 0.39},${panel.y + 26})`); + legendGroups.forEach((group, index) => { + const lx = index * panel.w * 0.19; + legend.append("rect") + .attr("x", lx) + .attr("y", -7) + .attr("width", 17) + .attr("height", 17) + .attr("rx", 3) + .attr("fill", `url(#vg13-hatch-${slug(group)})`) + .attr("stroke", groupColor.get(group)) + .attr("stroke-width", 1.3); + legend.append("text") + .attr("x", lx + 27) + .attr("y", 2) + .attr("dominant-baseline", "middle") + .style("font-family", fontFamily) + .style("font-size", `${clamp(height * 0.020, 10, 13)}px`) + .style("font-weight", 800) + .style("fill", group === highGroup ? orangeDark : greenDark) + .text(String(group)); + }); + + const plot = { + x: panel.x + panel.w * 0.065, + y: panel.y + panel.h * 0.11, + w: panel.w * 0.89, + h: panel.h * 0.815 + }; + const xScale2 = d3.scaleBand() + .domain(xValues) + .range([plot.x, plot.x + plot.w]) + .padding(0.10); + const dataMax = d3.max(useData, d => +d[yField]) || 100; + const smallAxis = smallValueAxis(dataMax); + const yMax = smallAxis ? smallAxis.max : d3.scaleLinear().domain([0, dataMax * 1.14]).nice(5).domain()[1]; + const yScale2 = d3.scaleLinear() + .domain([0, yMax]) + .range([plot.y + plot.h, plot.y]); + const yTicks = smallAxis + ? d3.range(0, yMax + smallAxis.step / 2, smallAxis.step) + : yScale2.ticks(5); + yTicks.forEach(tick => { + const y = yScale2(tick); + svg.append("line") + .attr("class", "gridline") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", "#d9d9bf") + .attr("stroke-dasharray", "3 4") + .attr("stroke-width", 0.8); + svg.append("text") + .attr("class", "y-tick") + .attr("x", plot.x - 9) + .attr("y", y + 4) + .attr("text-anchor", "end") + .style("font-family", fontFamily) + .style("font-size", `${clamp(height * 0.017, 8, 11)}px`) + .style("fill", textColor) + .text(formatValue(tick)); + }); + svg.append("line") + .attr("class", "y-axis-line") + .attr("x1", plot.x) + .attr("x2", plot.x) + .attr("y1", plot.y) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#2f7141") + .attr("stroke-width", 1.1); + svg.append("line") + .attr("class", "baseline") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", plot.y + plot.h) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#2f7141") + .attr("stroke-width", 1.1); + + const band = xScale2.bandwidth(); + const barW = clamp(band * 0.26, 4, 14); + const gap = clamp(band * 0.08, 2, 5); + const labelSize = clamp(height * 0.018, 8, 12); + xValues.forEach(xValue => { + const rows = useData.filter(d => d[xField] === xValue); + const center = xScale2(xValue) + band / 2; + const highRow = rows.find(d => d[groupField] === highGroup); + const lowRow = rows.find(d => d[groupField] === lowGroup); + const positions = [ + { group: highGroup, row: highRow, x: center - barW - gap / 2, color: groupColor.get(highGroup), labelColor: orangeDark }, + { group: lowGroup, row: lowRow, x: center + gap / 2, color: groupColor.get(lowGroup), labelColor: greenDark } + ]; + positions.forEach(item => { + if (!item.row) return; + const value = +item.row[yField] || 0; + const y = yScale2(value); + const h = plot.y + plot.h - y; + svg.append("path") + .attr("class", `bar grouped-bar ${item.group === highGroup ? "high-bar" : "low-bar"}`) + .attr("data-group", item.group) + .attr("data-x", xValue) + .attr("data-y", value) + .attr("data-mark-endcap", "flat-baseline-slightly-rounded-top") + .attr("data-baseline-edge", "flat-square") + .attr("data-value-edge", "horizontal-flat-with-minor-top-corner-radius") + .attr("data-stacked-join", "not-applicable-grouped-bars-separated") + .attr("d", roundedTopBarPath(item.x, y, barW, Math.max(0, h), Math.min(2, barW * 0.14))) + .attr("fill", `url(#vg13-hatch-${slug(item.group)})`) + .attr("stroke", darken(item.color, 0.25, item.color)) + .attr("stroke-width", 0.45); + svg.append("text") + .attr("class", "bar-value-label") + .attr("x", item.x + barW / 2) + .attr("y", Math.max(plot.y + 10, y - 5)) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", `${labelSize}px`) + .style("font-weight", 800) + .style("fill", item.labelColor) + .text(formatValue(value)); + }); + const xText = String(xValue); + const compactTimeLabel = /^\d{4}(-\d{2})?$/.test(xText) || timeKey(xText) !== null; + const tileMaxW = compactTimeLabel ? 44 : Math.min(78, band * 0.94); + const tileW = clamp(band * 0.92, 22, tileMaxW); + const tileH = clamp(height * 0.044, 18, 26); + const tileX = center - tileW / 2; + const tileY = panel.y + panel.h - tileH - 7; + svg.append("rect") + .attr("class", "x-label-tile") + .attr("data-reference-relationship", "centered-on-band-contained-label") + .attr("data-full-label", xText) + .attr("x", tileX) + .attr("y", tileY) + .attr("width", tileW) + .attr("height", tileH) + .attr("rx", 3) + .attr("ry", 3) + .attr("fill", greenDark) + .attr("stroke", "#0a4a2f") + .attr("stroke-width", 0.7); + const xSize = fitFont(xText, tileW - 6, clamp(height * 0.020, 9, 13), 6, 800, fontFamily); + const shortLabel = xText.length <= 8; + const fittedXText = (compactTimeLabel || shortLabel) ? xText : ellipsizeText(xText, tileW - 7, xSize, 800, fontFamily); + const xLabel = svg.append("text") + .attr("class", "x-label") + .attr("data-full-label", xText) + .attr("x", center) + .attr("y", tileY + tileH / 2 + 1) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", fontFamily) + .style("font-size", `${xSize}px`) + .style("font-weight", 800) + .style("fill", "#ffffff") + .text(fittedXText); + xLabel.append("title").text(xText); + }); + + return svg.node(); + } + + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6. 创建视觉效果 (Patterns for Sketch Style) ---------- + const defs = svg.append("defs"); + + // --- Sketch Pattern for Left Bars --- + const patternLeft = defs.append("pattern") + .attr("id", "pattern-sketch-left") + .attr("width", 8) // Pattern tile size + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); // Rotate lines + + // Background color for the pattern tile + patternLeft.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", leftGroupColor); + + // Sketch lines (white in example image) + patternLeft.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") // Horizontal lines, rotation makes them diagonal + .attr("stroke", "#FFFFFF") // White lines like example + .attr("stroke-width", 0.8); // Thinner lines + + // --- Sketch Pattern for Right Bars --- + const patternRight = defs.append("pattern") + .attr("id", "pattern-sketch-right") + .attr("width", 8) + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + + patternRight.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", rightGroupColor); + + patternRight.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 0.8); + + // *** 添加: 新的 Sketch Pattern for Label Backgrounds *** + const patternLabelSketch = defs.append("pattern") + .attr("id", "pattern-label-sketch") // 新 ID + .attr("width", 8) // 可以与 bar pattern 保持一致或调整 + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); // 保持斜线 + + // 添加白色背景矩形 + patternLabelSketch.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", "#FFFFFF"); // 白色背景 + + // 添加灰色斜线 + patternLabelSketch.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") // 与 bar pattern 线条一致 + .attr("stroke", "#CCCCCC") // *** 修改: 灰色线条 *** + .attr("stroke-width", 0.6); // 可以调整线条粗细 + + // Shadow Filter (if enabled) + if (variables.has_shadow) { + // ... (shadow filter code remains the same as original) + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8. 创建比例尺 ---------- + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.2); + + const groupScale = d3.scaleBand() + .domain([0, 1]) // Left (0) and Right (1) bars within a group + .range([0, xScale.bandwidth()]) + .padding(variables.has_spacing ? 0.2 : 0.1); // Adjust spacing within group + + const dataMax = d3.max(useData, d => +d[yField]) || 100; + const yScale = d3.scaleLinear() + .domain([0, dataMax * 1.1]) // Add some top padding for labels + .range([innerHeight, 0]); + + const barWidth = groupScale.bandwidth(); + + // ---------- 9. 文本格式化 ---------- + + // 计算动态文本大小的函数 + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + // 否则，按比例缩小字体大小 + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + + // 先清空文本 + text.text(null); + + // 处理文本 + let tspans = []; + + // 如果没有空格可分割，按字符分割 + if (words.length <= 1) { + const chars = str.split(''); + let currentLine = ''; + + for (let i = 0; i < chars.length; i++) { + currentLine += chars[i]; + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine, { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 当前行过长，回退一个字符并换行 + currentLine = currentLine.slice(0, -1); + + // 添加到tspans数组 + tspans.push(currentLine); + + // 重新开始下一行 + currentLine = chars[i]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } else { + // 处理有空格的文本 + let currentLine = []; + + while (word = words.pop()) { + currentLine.push(word); + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 回退一个词 + currentLine.pop(); + + // 添加到tspans数组 + tspans.push(currentLine.join(" ")); + + // 重新开始下一行 + currentLine = [word]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } + + // 计算总行数 + const totalLines = tspans.length; + + // 计算垂直居中的起始位置 + // 对于单行文本，y位置保持不变 + // 对于多行文本，需要向上偏移以保持垂直居中 + let startY = y; + if (totalLines > 1) { + // 向上偏移半行距离 * (总行数-1) + startY = parseFloat(y) - (lineHeight * (totalLines - 1) / 2); + } + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + text.append("tspan") + .attr("x", text.attr("x")) + .attr("y", startY) + .attr("dy", `${i * lineHeight}em`) + .text(lineText); + }); + } + + // ---------- 10. 创建X坐标轴标签 (新逻辑) ---------- + const xAxisGroup = chart.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`); + + // 计算标签最大宽度和统一字体大小 (同 chart_12) + const labelMaxWidth = xScale.bandwidth() * 1.1; // 允许稍微宽一点以便背景有空间 + const longestLabel = xValues.reduce((a, b) => a.toString().length > b.toString().length ? a.toString() : b.toString(), ""); + const baseFontSize = parseInt(typography.label.font_size); + const uniformFontSize = calculateFontSize(longestLabel, labelMaxWidth * 0.9, baseFontSize); // 计算字体时用稍小的宽度 + + // 定义手绘背景的内边距 + const sketchPadding = 5; + + // 绘制X轴标签组 + xAxisGroup.selectAll(".x-label-group") + .data(xValues) + .enter() + .append("g") + .attr("class", "x-label-group") + .attr("transform", d => `translate(${xScale(d) + xScale.bandwidth() / 2}, 25)`) // Group 定位不变 + .each(function(d) { + const group = d3.select(this); + const textContent = d.toString(); + + // 1. 创建文本元素 + const text = group.append("text") + .attr("class", "x-label") + .attr("x", 0) // 相对于 group 居中 + .attr("y", 0) // 相对于 group 垂直基线 (会被 wrapText 调整) + .attr("text-anchor", "middle") + .style("font-family", "'Comic Sans MS', cursive") + .style("font-size", `${uniformFontSize}px`) // 应用统一字体 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(textContent); + + // 2. 检查宽度并应用换行 (同 chart_12) + // 注意: wrapText 需要在 chart_13 中可用 + const textWidth = chartUtils.text.measure(null, textContent, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: uniformFontSize, + fontWeight: typography.label.font_weight + }).width; + if (textWidth > labelMaxWidth) { + wrapText(text, textContent, labelMaxWidth, 1.1); // 1.1 是行高倍数 + } + + // 3. 根据最终文本行计算背景边界框 + const renderedLines = text.selectAll("tspan").nodes().map(node => d3.select(node).text()); + const labelLines = renderedLines.length ? renderedLines : [text.text()]; + const measureOptions = { + fontFamily: "'Comic Sans MS', cursive", + fontSize: uniformFontSize, + fontWeight: typography.label.font_weight + }; + const bboxWidth = Math.max(...labelLines.map(line => chartUtils.text.measure(null, line, measureOptions).width), 0); + const bboxHeight = labelLines.length > 1 + ? uniformFontSize + (labelLines.length - 1) * uniformFontSize * 1.1 + : chartUtils.text.measure(null, labelLines[0], measureOptions).height; + const bbox = { + width: bboxWidth, + height: bboxHeight, + x: -bboxWidth / 2, + y: labelLines.length > 1 ? -bboxHeight / 2 : -bboxHeight * 0.8 + }; + + // 4. 计算手绘背景尺寸和位置 + const bgWidth = bbox.width + 2 * sketchPadding; + const bgHeight = bbox.height + 1.5 * sketchPadding; + // bgX/bgY 相对于 group 的 (0,0) 点计算 + const bgX = bbox.x - sketchPadding; + const bgY = bbox.y - sketchPadding * 0.75; // 调整 Y 使背景居中 + + // 5. 插入手绘背景矩形 (在文本之前) + group.insert("rect", "text") + .attr("class", "label-background") + .attr("x", bgX) + .attr("y", bgY) + .attr("width", bgWidth) + .attr("height", bgHeight) + .attr("fill", "url(#pattern-label-sketch)") + .attr("stroke", "#AAAAAA") + .attr("stroke-width", 0.5); + }); + + // ---------- 11. 绘制图例 ---------- + const legendItems = legendData.map(item => ({ + label: item.key, + color: item.pattern || item.color, + })); + chartUtils.legend.centered(svg, legendItems, {}, width / 2, 30, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 20, + fontSize: 12, + fontFamily: typography.label.font_family || "'Comic Sans MS', cursive", + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + + // ---------- 12. 绘制条形图和数值标签 (带手绘背景) ---------- + xValues.forEach(xValue => { + const xData = useData.filter(d => d[xField] === xValue); + const leftBarData = xData.find(d => d[groupField] === leftBarGroup); + const rightBarData = xData.find(d => d[groupField] === rightBarGroup); + + const baseFontSizeValue = parseInt(typography.label.font_size); // 数值标签基础大小 + const valueLabelMaxWidth = barWidth * 1.1; // 数值标签最大宽度 + + // --- Left Bar --- + if (leftBarData) { + const leftValue = +leftBarData[yField]; + if (isNaN(leftValue)) return; // Skip if value is not a number + + const leftBarHeight = innerHeight - yScale(leftValue); + const leftBarY = yScale(leftValue); + const leftBarX = xScale(xValue) + groupScale(0); // Use groupScale for position + + // Draw Bar + chart.append("rect") + .attr("class", "bar left-bar") + .attr("x", leftBarX) + .attr("y", leftBarY) + .attr("width", barWidth) + .attr("height", Math.max(0, leftBarHeight)) // Ensure height is not negative + .attr("fill", "url(#pattern-sketch-left)") // Use sketch pattern + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // --- 修改: 绘制数值标签，不带手绘背景 --- + if (leftBarHeight > 5) { + const labelX = leftBarX + barWidth / 2; + const labelY = leftBarY - 5; // 将标签放置在柱子上方5个像素 + const textContent = chartUtils.format.autoText(leftValue) + (yUnit ? ` ${yUnit}` : ''); + + // 计算字体大小 + let currentFontSize = baseFontSizeValue; + const textWidth = chartUtils.text.measure(chart, textContent, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: baseFontSizeValue, + fontWeight: "bold" + }).width; + + if (textWidth > valueLabelMaxWidth) { + currentFontSize = Math.max(8, baseFontSizeValue * (valueLabelMaxWidth / textWidth)); + } + + // 添加实际文本标签 + const textLabel = chart.append("text") + .attr("class", "bar-label") + .attr("x", labelX) + .attr("y", labelY) + .attr("text-anchor", "middle") + .style("font-family", "'Comic Sans MS', cursive") + .style("font-size", `${currentFontSize}px`) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 如果即使缩小到8px后文本仍然超出宽度，应用文本换行 + if (currentFontSize <= 8 && textWidth > valueLabelMaxWidth) { + wrapText(textLabel, textContent, barWidth, 1.1); + + // 获取tspan元素计算最后一行位置 + const tspans = textLabel.selectAll("tspan"); + const lineCount = tspans.size(); + + if (lineCount > 1) { + // 计算文本高度以确保最后一行紧贴柱子顶部 + const lineHeight = currentFontSize * 1.1; + const totalTextHeight = lineHeight * lineCount; + + // 重新定位所有tspan，使最后一行紧贴柱子顶部 + tspans.each(function(d, i) { + const tspan = d3.select(this); + tspan.attr("y", labelY - totalTextHeight + (i + 1) * lineHeight); + }); + } + } else { + textLabel.text(textContent); + } + } + } + + // --- Right Bar --- (类似地修改数值标签) + if (rightBarData) { + const rightValue = +rightBarData[yField]; + if (isNaN(rightValue)) return; // Skip if value is not a number + + const rightBarHeight = innerHeight - yScale(rightValue); + const rightBarY = yScale(rightValue); + const rightBarX = xScale(xValue) + groupScale(1); // Use groupScale for position + + // Draw Bar + chart.append("rect") + .attr("class", "bar right-bar") + .attr("x", rightBarX) + .attr("y", rightBarY) + .attr("width", barWidth) + .attr("height", Math.max(0, rightBarHeight)) // Ensure height is not negative + .attr("fill", "url(#pattern-sketch-right)") // Use sketch pattern + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // --- 修改: 绘制数值标签，不带手绘背景 --- + if (rightBarHeight > 5) { + const labelX = rightBarX + barWidth / 2; + const labelY = rightBarY - 5; // 将标签放置在柱子上方5个像素 + const textContent = chartUtils.format.autoText(rightValue) + (yUnit ? ` ${yUnit}` : ''); + + // 计算字体大小 + let currentFontSize = baseFontSizeValue; + const textWidth = chartUtils.text.measure(chart, textContent, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: baseFontSizeValue, + fontWeight: "bold" + }).width; + + if (textWidth > valueLabelMaxWidth) { + currentFontSize = Math.max(8, baseFontSizeValue * (valueLabelMaxWidth / textWidth)); + } + + // 添加实际文本标签 + const textLabel = chart.append("text") + .attr("class", "bar-label") + .attr("x", labelX) + .attr("y", labelY) + .attr("text-anchor", "middle") + .style("font-family", "'Comic Sans MS', cursive") + .style("font-size", `${currentFontSize}px`) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 如果即使缩小到8px后文本仍然超出宽度，应用文本换行 + if (currentFontSize <= 8 && textWidth > valueLabelMaxWidth) { + wrapText(textLabel, textContent, barWidth, 1.1); + + // 获取tspan元素计算最后一行位置 + const tspans = textLabel.selectAll("tspan"); + const lineCount = tspans.size(); + + if (lineCount > 1) { + // 计算文本高度以确保最后一行紧贴柱子顶部 + const lineHeight = currentFontSize * 1.1; + const totalTextHeight = lineHeight * lineCount; + + // 重新定位所有tspan，使最后一行紧贴柱子顶部 + tspans.each(function(d, i) { + const tspan = d3.select(this); + tspan.attr("y", labelY - totalTextHeight + (i + 1) * lineHeight); + }); + } + } else { + textLabel.text(textContent); + } + } + } + }); + + // ---------- 14. 返回SVG节点 ---------- + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_14.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_14.js new file mode 100644 index 0000000000000000000000000000000000000000..306e57bef68ad6b31241f95dbbf200a3aa815b02 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_14.js @@ -0,0 +1,701 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_14", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2,4], [0, 100], [2,2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const jsonData = data; + const colorResolver = chartUtils.color.resolver(jsonData); + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const titles = jsonData.titles || {}; + const metadata = jsonData.metadata || {}; + + const width = variables.width || 1024; + const height = variables.height || 1536; + const scale = width / 1024; + const textColor = colorResolver.text({ fallback: "#101936" }).value || "#101936"; + const bgColor = (jsonData.colors && (jsonData.colors.background_color || jsonData.colors.background)) || "#FFF7FA"; + + const xChannel = chartUtils.schema.channel(jsonData, "x") || {}; + const yChannel = chartUtils.schema.channel(jsonData, "y") || {}; + const groupChannel = chartUtils.schema.channel(jsonData, "group") || {}; + const xField = xChannel.key || "period"; + const yField = yChannel.key || "value"; + const groupField = groupChannel.key || "group"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const uid = `vgb14-${Math.round(Math.random() * 1e9)}`; + const bgGradientId = `${uid}-bg`; + const shadowId = `${uid}-soft-shadow`; + + const backgroundGradient = defs.append("radialGradient") + .attr("id", bgGradientId) + .attr("cx", "76%") + .attr("cy", "8%") + .attr("r", "82%"); + backgroundGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ECE5FF"); + backgroundGradient.append("stop").attr("offset", "36%").attr("stop-color", "#FFF8FA"); + backgroundGradient.append("stop").attr("offset", "100%").attr("stop-color", bgColor || "#FFF3F8"); + + const shadow = defs.append("filter") + .attr("id", shadowId) + .attr("x", "-15%") + .attr("y", "-15%") + .attr("width", "130%") + .attr("height", "130%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 12 * scale) + .attr("stdDeviation", 12 * scale) + .attr("flood-color", "#CDBFD4") + .attr("flood-opacity", 0.35); + + svg.append("rect") + .attr("class", "vgb14-reference-background") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", `url(#${bgGradientId})`); + + svg.append("circle") + .attr("cx", width * 0.83) + .attr("cy", height * 0.13) + .attr("r", width * 0.16) + .attr("fill", "#E9E3FF") + .attr("opacity", 0.46); + + const dotGroup = svg.append("g") + .attr("class", "vgb14-decorative-dot-grid") + .attr("data-role", "implemented-background-decoration") + .attr("opacity", 0.35); + for (let row = 0; row < 5; row += 1) { + for (let col = 0; col < 5; col += 1) { + dotGroup.append("circle") + .attr("cx", width * 0.79 + col * 22 * scale) + .attr("cy", height * 0.10 + row * 22 * scale) + .attr("r", 2.2 * scale) + .attr("fill", "#CDBFD9"); + } + } + + function parseSize(value, fallback) { + if (value === undefined || value === null) return fallback; + const parsed = parseFloat(String(value).replace("px", "")); + return Number.isFinite(parsed) ? parsed : fallback; + } + + function measure(text, fontSize, fontWeight) { + try { + return chartUtils.text.measure(null, String(text || ""), { + fontFamily: "Arial, Helvetica, sans-serif", + fontSize, + fontWeight: fontWeight || 400 + }).width; + } catch (err) { + return String(text || "").length * fontSize * 0.56; + } + } + + function wrapWords(text, maxWidth, fontSize, fontWeight, maxLines) { + const words = String(text || "").trim().split(/\s+/).filter(Boolean); + if (!words.length) return []; + const lines = []; + let line = ""; + words.forEach(word => { + const candidate = line ? `${line} ${word}` : word; + if (measure(candidate, fontSize, fontWeight) <= maxWidth || !line) { + line = candidate; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + if (lines.length <= maxLines) return lines; + const kept = lines.slice(0, Math.max(1, maxLines)); + kept[kept.length - 1] = `${kept[kept.length - 1].replace(/\.*$/, "")}...`; + return kept; + } + + function renderTextBlock(parent, lines, x, y, options) { + const fontSize = options.fontSize; + const lineHeight = options.lineHeight || fontSize * 1.18; + const text = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", options.anchor || "start") + .attr("font-family", options.family || "Arial, Helvetica, sans-serif") + .attr("font-size", fontSize) + .attr("font-weight", options.weight || 400) + .attr("fill", options.fill || textColor) + .attr("letter-spacing", "0"); + lines.forEach((line, index) => { + text.append("tspan") + .attr("x", x) + .attr("y", y + index * lineHeight) + .text(line); + }); + return text; + } + + function variantColor(base, mode, amount) { + try { + return chartUtils.color.variant(base, { mode, amount }) || base; + } catch (err) { + const c = d3.color(base); + if (!c) return base; + return mode === "darker" ? c.darker(amount || 0.5).formatHex() : c.brighter(amount || 0.5).formatHex(); + } + } + + function groupColor(group, index) { + const defaults = ["#FF5265", "#6655D9", "#31B9C9", "#F59E4A"]; + const role = index === 0 ? "primary" : (index === 1 ? "secondary" : "primary"); + const resolved = colorResolver.other(role, { fallback: defaults[index % defaults.length], index }).value; + if (index === 1) return "#6655D9"; + return resolved || defaults[index % defaults.length]; + } + + function formatValue(value) { + const v = Number(value); + const formatted = Number.isFinite(v) ? chartUtils.format.autoText(v) : ""; + return `${formatted}${yUnit ? yUnit : ""}`; + } + + function isTemporalField(fieldName) { + const name = String(fieldName || "").toLowerCase(); + const xType = String((xChannel.raw && xChannel.raw.data_type) || xChannel.type || "").toLowerCase(); + return /year|date|month|time|timestamp|season|semester|quarter/.test(name) || /date|time|temporal/.test(xType); + } + + function temporalRank(value) { + const text = String(value || "").trim(); + const year = text.match(/\b(19|20)\d{2}\b/); + if (year) return Number(year[0]); + const monthNames = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, sept: 9, + september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + const lower = text.toLowerCase(); + if (monthNames[lower] !== undefined) return monthNames[lower]; + const parsed = Date.parse(text); + return Number.isNaN(parsed) ? null : parsed; + } + + const groups = Array.from(new Set(chartData.map(d => d[groupField]).filter(v => v !== undefined && v !== null))); + let categories = Array.from(new Set(chartData.map(d => d[xField]).filter(v => v !== undefined && v !== null))); + if (isTemporalField(xField)) { + categories = categories.slice().sort((a, b) => { + const ar = temporalRank(a); + const br = temporalRank(b); + if (ar !== null && br !== null) return ar - br; + return String(a).localeCompare(String(b)); + }); + } + + const processedData = categories.map(category => { + const row = { category, groups: {} }; + groups.forEach(group => { + const datum = chartData.find(d => d[xField] === category && d[groupField] === group); + row.groups[group] = datum ? +datum[yField] : 0; + }); + return row; + }); + + const header = { + x: 78 * scale, + y: 96 * scale, + w: 892 * scale, + h: 520 * scale + }; + const chartPanel = { + x: 66 * scale, + y: 620 * scale, + w: 892 * scale, + h: 750 * scale + }; + const plot = { + x: chartPanel.x + 126 * scale, + y: chartPanel.y + 118 * scale, + w: chartPanel.w - 220 * scale, + h: chartPanel.h - 238 * scale + }; + + const mainTitle = String(titles.main_title || metadata.title || "Grouped Bar Comparison").trim(); + const subtitle = String(titles.sub_title || metadata.description || jsonData.description || "").trim(); + let titleLineOne = mainTitle; + let titleLineTwo = ""; + const inMatch = mainTitle.match(/\s(in|by|for|across)\s+(.+)$/i); + if (inMatch && inMatch.index > 8 && inMatch[2].length <= 34) { + titleLineOne = mainTitle.slice(0, inMatch.index).trim(); + titleLineTwo = mainTitle.slice(inMatch.index).trim(); + } else if (mainTitle.includes(":")) { + const parts = mainTitle.split(":"); + titleLineOne = `${parts.shift()}:`.trim(); + titleLineTwo = parts.join(":").trim(); + } else { + const words = mainTitle.split(/\s+/); + if (words.length > 5) { + const splitAt = Math.ceil(words.length / 2); + titleLineOne = words.slice(0, splitAt).join(" "); + titleLineTwo = words.slice(splitAt).join(" "); + } + } + + const titleSafeW = 600 * scale; + const titleFontOne = Math.min(54 * scale, Math.max(36 * scale, titleSafeW / Math.max(10, titleLineOne.length * 0.53))); + const titleFontTwo = titleLineTwo ? Math.min(72 * scale, Math.max(44 * scale, titleSafeW / Math.max(10, titleLineTwo.length * 0.48))) : 0; + const titleG = svg.append("g") + .attr("class", "vgb14-title-block") + .attr("data-role", "implemented-title-subtitle") + .attr("data-collision-rule", "title-subtitle-stay-left-of-header-social-illustration-slot-and-above-summary-cards"); + titleG.append("text") + .attr("x", header.x) + .attr("y", header.y) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleFontOne) + .attr("font-weight", 900) + .attr("fill", "#101936") + .attr("letter-spacing", "0") + .text(titleLineOne); + if (titleLineTwo) { + titleG.append("text") + .attr("x", header.x) + .attr("y", header.y + 82 * scale) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleFontTwo) + .attr("font-weight", 900) + .attr("fill", "#F04F63") + .attr("letter-spacing", "0") + .text(titleLineTwo); + } + + const subtitleLines = wrapWords(subtitle, 520 * scale, 27 * scale, 400, 3); + renderTextBlock(titleG, subtitleLines, header.x, header.y + (titleLineTwo ? 154 : 92) * scale, { + fontSize: 27 * scale, + lineHeight: 40 * scale, + weight: 400, + fill: "#293246" + }); + + const slot = svg.append("g") + .attr("class", "reserved-asset-slot vgb14-header-social-illustration-slot") + .attr("data-asset-slot", "header-social-illustration") + .attr("data-reserved-slot", "header_social_illustration_slot") + .attr("data-slot-policy", "image2_asset") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "top-right-header-safe-area") + .attr("data-collision-rule", "avoid-title-subtitle-summary-cards-legend-chart-panel-and-canvas-edge") + .attr("data-mask-policy", "downstream image2/retrieval may replace only inside this rounded neutral placeholder") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bbox", `${648 * scale},${232 * scale},${276 * scale},${190 * scale}`) + .attr("transform", `translate(${648 * scale}, ${232 * scale})`) + .attr("opacity", 0.84); + slot.append("rect") + .attr("x", 0) + .attr("y", 22 * scale) + .attr("width", 250 * scale) + .attr("height", 168 * scale) + .attr("rx", 32 * scale) + .attr("fill", "#FFFFFF") + .attr("fill-opacity", 0.30) + .attr("stroke", "#B8A9EF") + .attr("stroke-width", 3 * scale) + .attr("stroke-dasharray", `${12 * scale} ${9 * scale}`); + slot.append("circle").attr("cx", 226 * scale).attr("cy", 30 * scale).attr("r", 18 * scale).attr("fill", "none").attr("stroke", "#B8A9EF").attr("stroke-width", 8 * scale).attr("opacity", 0.55); + slot.append("circle").attr("cx", 274 * scale).attr("cy", 176 * scale).attr("r", 12 * scale).attr("fill", "none").attr("stroke", "#B8A9EF").attr("stroke-width", 6 * scale).attr("opacity", 0.55); + slot.append("rect").attr("x", 52 * scale).attr("y", 64 * scale).attr("width", 120 * scale).attr("height", 18 * scale).attr("rx", 9 * scale).attr("fill", "#8C81CF").attr("opacity", 0.35); + slot.append("rect").attr("x", 52 * scale).attr("y", 104 * scale).attr("width", 162 * scale).attr("height", 18 * scale).attr("rx", 9 * scale).attr("fill", "#8C81CF").attr("opacity", 0.25); + slot.append("rect").attr("x", 52 * scale).attr("y", 144 * scale).attr("width", 86 * scale).attr("height", 18 * scale).attr("rx", 9 * scale).attr("fill", "#8C81CF").attr("opacity", 0.25); + + const groupColors = groups.map((group, index) => groupColor(group, index)); + const firstCategory = processedData[0]; + const secondCategory = processedData[1]; + const summaryGroups = groups.slice(0, 2); + const cardG = svg.append("g") + .attr("class", "vgb14-summary-cards") + .attr("data-role", "implemented-data-bound-summary-cards") + .attr("data-coordinate-relationship", "grid-aligned") + .attr("data-collision-rule", "summary-cards-wrap-before-overlap-with-title-legend-or-header-asset-slot"); + const cardY = header.y + 270 * scale; + const cardW = 270 * scale; + const cardH = 112 * scale; + summaryGroups.forEach((group, index) => { + const x = header.x + index * (cardW + 24 * scale); + const color = groupColors[index] || groupColors[0] || "#FF5265"; + let deltaText = ""; + if (firstCategory && secondCategory) { + const a = firstCategory.groups[group]; + const b = secondCategory.groups[group]; + if (Number.isFinite(a) && Number.isFinite(b) && b !== 0) { + deltaText = `${a >= b ? "+" : ""}${Math.round(((a - b) / Math.abs(b)) * 100)}%`; + } + } + const cleanGroup = String(group).replace(/Rate|Engagement/gi, "").trim() || String(group); + const comparisonWord = /donation/i.test(cleanGroup) + ? "More" + : (firstCategory && secondCategory && firstCategory.groups[group] >= secondCategory.groups[group] ? "Higher" : "Lower"); + const title = `${comparisonWord} ${cleanGroup}`; + const card = cardG.append("g") + .attr("class", "vgb14-summary-card") + .attr("transform", `translate(${x}, ${cardY})`) + .attr("data-group", group) + .attr("data-anchor", "header-grid") + .attr("data-collision-rule", "icon-slot-text-and-delta-remain-inside-card"); + card.append("rect") + .attr("width", cardW) + .attr("height", cardH) + .attr("rx", 18 * scale) + .attr("fill", "#FFFFFF") + .attr("fill-opacity", 0.54) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1.2 * scale); + const icon = card.append("g") + .attr("class", "reserved-asset-slot vgb14-summary-card-icon-slot") + .attr("data-asset-slot", "summary-card-icon") + .attr("data-reserved-slot", "summary_card_icon") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-anchor", "summary-card-left-inset") + .attr("data-collision-rule", "inside-card-left-area-avoid-label-and-delta-text") + .attr("data-bbox", `${x + 24 * scale},${cardY + 28 * scale},${58 * scale},${58 * scale}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + icon.append("circle") + .attr("cx", 54 * scale) + .attr("cy", 56 * scale) + .attr("r", 34 * scale) + .attr("fill", color) + .attr("opacity", 0.86); + icon.append("circle") + .attr("cx", 54 * scale) + .attr("cy", 56 * scale) + .attr("r", 16 * scale) + .attr("fill", "#FFFFFF") + .attr("fill-opacity", 0.34); + const titleLines = wrapWords(title, cardW - 120 * scale, 21 * scale, 800, 2); + renderTextBlock(card, titleLines, 104 * scale, titleLines.length > 1 ? 34 * scale : 42 * scale, { + fontSize: titleLines.length > 1 ? 20 * scale : 24 * scale, + lineHeight: 22 * scale, + weight: 800, + fill: "#18213A" + }); + card.append("text") + .attr("x", 104 * scale) + .attr("y", titleLines.length > 1 ? 92 * scale : 84 * scale) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleLines.length > 1 ? 34 * scale : 40 * scale) + .attr("font-weight", 900) + .attr("fill", color) + .attr("letter-spacing", "0") + .text(deltaText || formatValue(firstCategory ? firstCategory.groups[group] : 0)); + }); + + const legendG = svg.append("g") + .attr("class", "vgb14-legend") + .attr("data-role", "implemented-independent-legend") + .attr("data-coordinate-relationship", "independent") + .attr("data-anchor", "header-chart-gap") + .attr("data-collision-rule", "wrap-or-tighten-before-overlap-with-chart-panel") + .attr("transform", `translate(${header.x}, ${header.y + 430 * scale})`); + let legendX = 0; + groups.forEach((group, index) => { + const item = legendG.append("g").attr("transform", `translate(${legendX}, 0)`); + item.append("rect") + .attr("x", 0) + .attr("y", -18 * scale) + .attr("width", 30 * scale) + .attr("height", 30 * scale) + .attr("rx", 7 * scale) + .attr("fill", groupColors[index] || "#FF5265"); + item.append("text") + .attr("x", 48 * scale) + .attr("y", 6 * scale) + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 25 * scale) + .attr("font-weight", 800) + .attr("fill", "#18213A") + .attr("letter-spacing", "0") + .text(group); + legendX += Math.min(300 * scale, 62 * scale + measure(group, 25 * scale, 800) + 46 * scale); + }); + + svg.append("rect") + .attr("class", "vgb14-chart-panel") + .attr("data-role", "implemented-chart-panel") + .attr("data-coordinate-relationship", "grid-aligned") + .attr("data-collision-rule", "panel-stays-below-legend-and-contains-axes-bars-callouts-x-labels-logo-slots") + .attr("x", chartPanel.x) + .attr("y", chartPanel.y) + .attr("width", chartPanel.w) + .attr("height", chartPanel.h) + .attr("rx", 26 * scale) + .attr("fill", "#FFFFFF") + .attr("fill-opacity", 0.84) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1.4 * scale) + .attr("filter", `url(#${shadowId})`); + + const yMaxRaw = d3.max(chartData, d => +d[yField]) || 1; + const yMax = yUnit === "%" && yMaxRaw <= 10 ? Math.ceil((yMaxRaw + 0.25) * 2) / 2 : Math.ceil(yMaxRaw * 1.12); + const yScale = d3.scaleLinear() + .domain([0, yMax]) + .range([plot.y + plot.h, plot.y]) + .nice(); + const xScale = d3.scaleBand() + .domain(categories) + .range([plot.x, plot.x + plot.w]) + .paddingInner(categories.length > 2 ? 0.30 : 0.42) + .paddingOuter(0.18); + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.18); + + const tickCount = yUnit === "%" && yMax <= 6 ? 8 : 5; + const ticks = yScale.ticks(tickCount); + const axisG = svg.append("g").attr("class", "vgb14-axes-grid"); + ticks.forEach(tick => { + const y = yScale(tick); + axisG.append("line") + .attr("class", "vgb14-gridline") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", "#D8D5DE") + .attr("stroke-width", 1.1 * scale) + .attr("stroke-dasharray", `${5 * scale} ${5 * scale}`) + .attr("opacity", tick === 0 ? 0 : 0.9); + axisG.append("text") + .attr("x", plot.x - 20 * scale) + .attr("y", y + 7 * scale) + .attr("text-anchor", "end") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 23 * scale) + .attr("font-weight", 600) + .attr("fill", "#162038") + .attr("letter-spacing", "0") + .text(`${chartUtils.format.autoText(tick)}${yUnit || ""}`); + }); + axisG.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x) + .attr("y1", plot.y) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#111832") + .attr("stroke-width", 2.4 * scale); + axisG.append("line") + .attr("x1", plot.x) + .attr("x2", plot.x + plot.w) + .attr("y1", plot.y + plot.h) + .attr("y2", plot.y + plot.h) + .attr("stroke", "#111832") + .attr("stroke-width", 2.4 * scale); + axisG.append("text") + .attr("x", chartPanel.x + 30 * scale) + .attr("y", plot.y + plot.h * 0.55) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 20 * scale) + .attr("font-weight", 800) + .attr("fill", "#3F4657") + .attr("letter-spacing", "0.08em") + .attr("transform", `rotate(-90 ${chartPanel.x + 30 * scale} ${plot.y + plot.h * 0.55})`) + .text(`${String(yField).replace(/([a-z])([A-Z])/g, "$1 $2").toUpperCase()}${yUnit ? ` (${yUnit})` : ""}`); + + function roundedTopBarPath(x, y, w, h, r) { + const radius = Math.max(0, Math.min(r, w / 2, Math.max(0, h))); + const bottom = y + h; + if (h <= 0) return `M ${x} ${bottom} L ${x + w} ${bottom} Z`; + return [ + `M ${x} ${bottom}`, + `L ${x} ${y + radius}`, + `Q ${x} ${y} ${x + radius} ${y}`, + `L ${x + w - radius} ${y}`, + `Q ${x + w} ${y} ${x + w} ${y + radius}`, + `L ${x + w} ${bottom}`, + "Z" + ].join(" "); + } + + groups.forEach((group, groupIndex) => { + const baseColor = groupColors[groupIndex] || "#FF5265"; + const gradId = `${uid}-bar-${groupIndex}`; + const grad = defs.append("linearGradient") + .attr("id", gradId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + grad.append("stop").attr("offset", "0%").attr("stop-color", variantColor(baseColor, "brighter", 0.45)); + grad.append("stop").attr("offset", "100%").attr("stop-color", baseColor); + }); + + const marksG = svg.append("g") + .attr("class", "vgb14-bars") + .attr("data-role", "implemented-grouped-columns") + .attr("data-endpoint-geometry", "rounded-top-corners-flat-square-baseline-bottoms") + .attr("data-coordinate-relationship", "grid-aligned-to-x-band-centers-and-zero-baseline") + .attr("data-temporal-order-policy", isTemporalField(xField) ? "chronological" : "input-order"); + processedData.forEach(categoryRow => { + groups.forEach((group, groupIndex) => { + const value = Number(categoryRow.groups[group]) || 0; + const barX = xScale(categoryRow.category) + groupScale(group); + const rawBarW = groupScale.bandwidth(); + const barW = Math.min(rawBarW, categories.length > 2 ? 72 * scale : 110 * scale); + const centeredX = barX + (rawBarW - barW) / 2; + const barY = yScale(value); + const barH = Math.max(0, plot.y + plot.h - barY); + const color = groupColors[groupIndex] || "#FF5265"; + marksG.append("path") + .attr("class", "bar") + .attr("data-x-category", categoryRow.category) + .attr("data-group", group) + .attr("data-value", value) + .attr("data-bar-endpoint-geometry", "reference-rounded-top-flat-bottom") + .attr("d", roundedTopBarPath(centeredX, barY, barW, barH, Math.min(16 * scale, barW * 0.18))) + .attr("fill", `url(#${uid}-bar-${groupIndex})`); + + const labelText = formatValue(value); + const denseCategories = categories.length >= 4; + const calloutFont = denseCategories ? 24 * scale : 30 * scale; + const labelW = Math.max(denseCategories ? 70 * scale : 86 * scale, measure(labelText, calloutFont, 900) + (denseCategories ? 20 * scale : 32 * scale)); + const labelH = denseCategories ? 42 * scale : 52 * scale; + const denseXStagger = denseCategories && groups.length > 1 + ? (groupIndex === 0 ? -14 * scale : 14 * scale) + : 0; + const labelX = Math.max(plot.x + 4 * scale, Math.min(centeredX + barW / 2 - labelW / 2 + denseXStagger, plot.x + plot.w - labelW - 4 * scale)); + const denseStagger = denseCategories && groups.length > 1 && groupIndex === 0 ? 30 * scale : 0; + const labelY = Math.max(plot.y + 8 * scale, barY - labelH - (denseCategories ? 16 * scale : 22 * scale) - denseStagger); + const callout = marksG.append("g") + .attr("class", "value-label vgb14-value-callout") + .attr("data-role", "bar-top-value-callout") + .attr("data-coordinate-relationship", "centerline-aligned") + .attr("data-anchor", "bar-top-center") + .attr("data-collision-rule", "clamp-inside-plot-and-panel-away-from-grid-ticks") + .attr("transform", `translate(${labelX}, ${labelY})`); + callout.append("rect") + .attr("width", labelW) + .attr("height", labelH) + .attr("rx", denseCategories ? 9 * scale : 11 * scale) + .attr("fill", color) + .attr("filter", `url(#${shadowId})`); + const pointerCenter = centeredX + barW / 2 - labelX; + const pointerTipY = Math.max(labelH + (denseCategories ? 15 : 20) * scale, Math.min(barY - labelY, labelH + (denseCategories ? 48 : 34) * scale)); + callout.append("path") + .attr("d", `M ${pointerCenter - (denseCategories ? 10 : 13) * scale} ${labelH - 2 * scale} L ${pointerCenter} ${pointerTipY} L ${pointerCenter + (denseCategories ? 10 : 13) * scale} ${labelH - 2 * scale} Z`) + .attr("fill", color); + callout.append("text") + .attr("x", labelW / 2) + .attr("y", denseCategories ? 29 * scale : 35 * scale) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", calloutFont) + .attr("font-weight", 900) + .attr("fill", "#FFFFFF") + .attr("letter-spacing", "0") + .text(labelText); + }); + }); + + const xLabelG = svg.append("g") + .attr("class", "vgb14-x-category-labels") + .attr("data-role", "implemented-x-axis-category-labels-with-reserved-logo-slots") + .attr("data-collision-rule", "category-logo-slots-and-text-stay-inside-panel-label-band"); + categories.forEach(category => { + const cx = xScale(category) + xScale.bandwidth() / 2; + const labelY = plot.y + plot.h + 76 * scale; + const maxLabelW = Math.max(118 * scale, xScale.bandwidth() * 0.82); + const labelFont = categories.length >= 4 ? 26 * scale : 30 * scale; + const labelLineH = categories.length >= 4 ? 30 * scale : 34 * scale; + const labelLines = wrapWords(category, maxLabelW, labelFont, 900, 2); + const labelTextW = Math.max(...labelLines.map(line => measure(line, labelFont, 900)), 0); + const slotSize = (categories.length >= 4 ? 38 : 48) * scale; + const rowGap = 16 * scale; + const combinedW = slotSize + rowGap + labelTextW; + const slotX = -combinedW / 2; + const textX = slotX + slotSize + rowGap; + const multiLineYOffset = labelLines.length > 1 ? -((labelLines.length - 1) * labelLineH) / 2 : 0; + const labelGroup = xLabelG.append("g") + .attr("transform", `translate(${cx}, ${labelY})`) + .attr("data-category", category) + .attr("data-coordinate-relationship", "logo-slot-and-category-label-adjacent-same-row-pair-centered"); + labelGroup.append("g") + .attr("class", "reserved-asset-slot vgb14-x-category-logo-slot") + .attr("data-asset-slot", "x-category-logo") + .attr("data-reserved-slot", "x_category_logo") + .attr("data-asset-source-policy", "retrieval_asset") + .attr("data-anchor", "x-axis-category-label-centerline") + .attr("data-collision-rule", "same-row-with-label-pair-centered-inside-x-label-band-avoid-bars-panel-edge-and-neighbor-labels") + .attr("data-bbox", `${cx + slotX},${labelY - slotSize / 2},${slotSize},${slotSize}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .append("rect") + .attr("x", slotX) + .attr("y", -slotSize / 2) + .attr("width", slotSize) + .attr("height", slotSize) + .attr("rx", 11 * scale) + .attr("fill", "#FFFFFF") + .attr("stroke", "#9F92CF") + .attr("stroke-width", 2.6 * scale) + .attr("stroke-dasharray", `${7 * scale} ${5 * scale}`) + .attr("opacity", 0.96); + labelGroup.append("circle") + .attr("cx", slotX + slotSize / 2) + .attr("cy", 0) + .attr("r", slotSize * 0.23) + .attr("fill", "#C7BEEA") + .attr("opacity", 0.65); + renderTextBlock(labelGroup, labelLines, textX, (labelLines.length > 1 ? -4 * scale : 10 * scale) + multiLineYOffset, { + fontSize: labelFont, + lineHeight: labelLineH, + weight: 900, + fill: "#111832", + anchor: "start" + }); + }); + + svg.append("g") + .attr("class", "vgb14-ignored-bottom-wrapper-policy") + .attr("data-ignored-element", "bottom-takeaway-source-footer-rating-replacement-prose") + .attr("data-policy", "not-rendered"); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_15.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_15.js new file mode 100644 index 0000000000000000000000000000000000000000..ce1efbc127dca4b02319e3ce4b23b97005fd6d0b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_15.js @@ -0,0 +1,556 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_15", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 74, + right: 28, + bottom: 72, + left: 62 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = xChannel.key || "period"; + const yField = yChannel.key || "value"; + const groupField = groupChannel.key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (xChannel.unit !== "none") { + xUnit = xChannel.unit; + } + + if (yChannel.unit !== "none") { + yUnit = yChannel.unit; + } + + if (groupChannel.unit !== "none") { + groupUnit = groupChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + const monthIndex = { + jan: 1, january: 1, + feb: 2, february: 2, + mar: 3, march: 3, + apr: 4, april: 4, + may: 5, + jun: 6, june: 6, + jul: 7, july: 7, + aug: 8, august: 8, + sep: 9, sept: 9, september: 9, + oct: 10, october: 10, + nov: 11, november: 11, + dec: 12, december: 12 + }; + + function temporalKey(value) { + const text = String(value ?? "").trim(); + if (!text) return null; + if (/^\d{4}$/.test(text)) return +text; + const parsedDate = Date.parse(text); + if (!Number.isNaN(parsedDate)) return parsedDate; + const lower = text.toLowerCase(); + if (Object.prototype.hasOwnProperty.call(monthIndex, lower)) { + return monthIndex[lower]; + } + const monthMatch = lower.match(/^(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)/); + if (monthMatch && monthIndex[monthMatch[1]]) return monthIndex[monthMatch[1]]; + return null; + } + + function isTemporalX() { + const dataType = String(xChannel.data_type || xChannel.type || "").toLowerCase(); + const name = String(xField || "").toLowerCase(); + return dataType.includes("temporal") || /(year|date|month|time|season|quarter)/.test(name); + } + + function readableFieldName(name) { + return String(name || "") + .replace(/[_-]+/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function formatTickValue(value) { + const formatted = isPercentUnit ? Math.round(value) : chartUtils.format.autoText(value); + if (!yUnit) return String(formatted); + if (yUnit === "%") return `${formatted}%`; + if (yUnit === "$") return `$${formatted}`; + return `${formatted} ${yUnit}`; + } + + function formatBarValue(value) { + if (yUnit === "%") return `${Math.round(value)}%`; + return chartUtils.format.autoText(value) + (yUnit && yUnit.length <= 3 ? yUnit : ""); + } + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + if (isTemporalX()) { + processedData.sort((a, b) => { + const aKey = temporalKey(a.category); + const bKey = temporalKey(b.category); + if (aKey !== null && bKey !== null) return aKey - bKey; + return String(a.category).localeCompare(String(b.category), undefined, { numeric: true }); + }); + } + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .paddingInner(0.28) + .paddingOuter(0.12); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .paddingInner(0.18) + .paddingOuter(0.06); + + const maxValue = d3.max(chartData, d => +d[yField]) || 0; + const isPercentUnit = yUnit === "%" || /percent|percentage|rate|proportion/i.test(String(yField)) || maxValue <= 100 && maxValue >= 20; + function niceUpperBound(max) { + if (isPercentUnit && max <= 80) return 80; + if (isPercentUnit && max <= 100) return 100; + if (max <= 10) return 10; + const magnitude = Math.pow(10, Math.floor(Math.log10(max || 1))); + return Math.ceil((max * 1.12) / magnitude) * magnitude; + } + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, niceUpperBound(maxValue)]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + processedData.forEach(d => { + // x label + const xLabelText = String(d.category); + let currentWidth = chartUtils.text.measure(null, xLabelText).width; + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + const compactYearLabels = processedData.every(d => /^\d{4}$/.test(String(d.category))); + const useBaselineBandLabels = compactYearLabels && minXLabelRatio >= 0.78 && processedData.length <= 7; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const headerSlotX = width * 0.705; + const headerSlotY = height * 0.035; + const headerSlotW = width * 0.225; + const headerSlotH = height * 0.155; + const headerSlotGroup = svg.append("g") + .attr("class", "reserved-asset-slots") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + headerSlotGroup.append("rect") + .attr("data-asset-slot", "header-topic-art") + .attr("data-slot-anchor", "upper-right chart-safe area") + .attr("data-slot-bbox", `${Math.round(headerSlotX)},${Math.round(headerSlotY)},${Math.round(headerSlotW)},${Math.round(headerSlotH)}`) + .attr("data-slot-mask", "rounded-rect") + .attr("data-slot-collision", "avoid title/subtitle, legend, y-axis label, plot bbox, value labels, canvas edge") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("x", headerSlotX) + .attr("y", headerSlotY) + .attr("width", headerSlotW) + .attr("height", headerSlotH) + .attr("rx", 16) + .attr("ry", 16) + .attr("fill", "#f8fbfd") + .attr("fill-opacity", 0.72) + .attr("stroke", "#b7d5d2") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "9 7") + .attr("opacity", 0.9) + .attr("pointer-events", "none"); + + headerSlotGroup.append("line") + .attr("data-asset-slot", "header-topic-art-anchor") + .attr("data-slot-anchor", "upper-right chart-safe area baseline anchor") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("x1", headerSlotX + headerSlotW * 0.5) + .attr("x2", headerSlotX + headerSlotW * 0.5) + .attr("y1", headerSlotY + headerSlotH) + .attr("y2", headerSlotY + headerSlotH + Math.min(36, height * 0.045)) + .attr("stroke", "#b7d5d2") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "5 5") + .attr("opacity", 0.65) + .attr("pointer-events", "none"); + + svg.select(".reserved-asset-slots") + .append("rect") + .attr("data-asset-slot", "background-decor") + .attr("data-slot-anchor", "canvas background safe area") + .attr("data-slot-bbox", `${Math.round(width * 0.02)},${Math.round(height * 0.02)},${Math.round(width * 0.96)},${Math.round(height * 0.22)}`) + .attr("data-slot-mask", "rect") + .attr("data-slot-collision", "avoid title, legend, plot panel, value labels") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("x", width * 0.02) + .attr("y", height * 0.02) + .attr("width", width * 0.96) + .attr("height", height * 0.22) + .attr("fill", "none") + .attr("stroke", "none") + .attr("pointer-events", "none"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + chartGroup.append("g") + .attr("class", "y-grid") + .call(d3.axisLeft(yScale) + .ticks(5) + .tickSize(-chartWidth) + .tickFormat("")) + .call(g => g.select(".domain").remove()) + .call(g => g.selectAll("line") + .attr("stroke", "#d7e1ec") + .attr("stroke-dasharray", "4 4") + .attr("stroke-width", 1)); + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("dy", useBaselineBandLabels ? 15 : 30) + .style("font-size", () => minXLabelRatio < 0.82 ? "11px" : typography.label.font_size) + .style("font-weight", "700") + .style("text-anchor", useBaselineBandLabels ? "middle" : "end") + .attr("transform", useBaselineBandLabels ? "rotate(0)" : "rotate(-32)") + .style("fill", colorResolver.text({ fallback: "#071d44" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => formatTickValue(d)) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", "700") + .style("fill", colorResolver.text({ fallback: "#071d44" }).value); + + chartGroup.selectAll(".x-axis .domain, .y-axis .domain") + .attr("stroke", "#071d44") + .attr("stroke-width", 1.5); + + chartGroup.append("text") + .attr("class", "y-axis-title") + .attr("x", -margin.left + 4) + .attr("y", -18) + .attr("fill", colorResolver.text({ fallback: "#071d44" }).value) + .attr("font-family", typography.label.font_family) + .attr("font-size", 12) + .attr("font-weight", 700) + .text(readableFieldName(yField) + (yUnit ? ` (${yUnit})` : "")); + + const baselineBandHeight = Math.min(24, Math.max(16, margin.bottom * 0.32)); + chartGroup.append("rect") + .attr("class", "baseline-band") + .attr("data-coordinate-rule", "flush-to-plot-baseline") + .attr("data-alignment-basis", "shared-edge-span") + .attr("x", 0) + .attr("y", chartHeight - baselineBandHeight * 0.32) + .attr("width", chartWidth) + .attr("height", baselineBandHeight) + .attr("rx", 6) + .attr("ry", 6) + .attr("fill", "#071d44") + .attr("opacity", 0.98); + + chartGroup.select(".x-axis").raise(); + chartGroup.select(".x-axis .domain").attr("display", "none"); + chartGroup.selectAll(".x-axis text") + .attr("dy", useBaselineBandLabels ? 15 : 30) + .style("text-anchor", useBaselineBandLabels ? "middle" : "end") + .attr("transform", useBaselineBandLabels ? "rotate(0)" : "rotate(-32)") + .style("fill", useBaselineBandLabels ? "#ffffff" : colorResolver.text({ fallback: "#071d44" }).value) + .style("font-weight", "800"); + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + const groupColor = colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + const barWidth = Math.max(4, groupScale.bandwidth() * 0.92); + + barGroups.append("path") + .attr("class", "bar") + .attr("data-mark-type", "grouped-vertical-bar") + .attr("data-endpoint-shape", "rounded-top-flat-baseline") + .attr("data-baseline-edge", "flat-contained-by-baseline-band") + .attr("data-value-edge", "rounded-pill-top") + .attr("data-grouped-join", "separated-gaps") + .attr("d", d => { + const value = d.groups[group] || 0; + const x = groupScale(group) + (groupScale.bandwidth() - barWidth) / 2; + const y = yScale(value); + const h = chartHeight - y; + const r = Math.min(barWidth / 2, Math.max(3, barWidth * 0.42), h / 2); + const bottom = chartHeight; + return [ + `M ${x} ${bottom}`, + `L ${x} ${y + r}`, + `Q ${x} ${y} ${x + r} ${y}`, + `L ${x + barWidth - r} ${y}`, + `Q ${x + barWidth} ${y} ${x + barWidth} ${y + r}`, + `L ${x + barWidth} ${bottom}`, + "Z" + ].join(" "); + }) + .attr("fill", groupColor); + + if (groupScale.bandwidth() >= 12 && xScale.bandwidth() >= 48) { + barGroups.append("text") + .attr("class", "bar-value-label") + .attr("data-coordinate-rule", "centerline-aligned-to-bar-value-edge") + .attr("data-alignment-basis", "shared-mark-centerline-fixed-top-gap") + .attr("x", d => groupScale(group) + groupScale.bandwidth() / 2) + .attr("y", d => Math.max(10, yScale(d.groups[group] || 0) - 6)) + .attr("text-anchor", "middle") + .attr("font-family", typography.label.font_family) + .attr("font-size", Math.min(12, Math.max(9, barWidth * 0.55))) + .attr("font-weight", 700) + .attr("fill", groupColor) + .text(d => { + const value = d.groups[group] || 0; + return formatBarValue(value); + }); + } + + }); + + // 添加图例 - 独立标题区行，避免和柱体绑定或碰撞 + const legendItems = groups.map(group => { + const label = String(group); + const labelWidth = chartUtils.text.measure(null, label).width; + return { + group, + label, + width: Math.max(98, labelWidth + 62) + }; + }); + const legendGap = 28; + const legendRowHeight = 42; + const legendRows = []; + let currentRow = []; + let currentWidth = 0; + const legendMaxWidth = Math.min(chartWidth, width * 0.68); + legendItems.forEach(item => { + const nextWidth = currentRow.length ? currentWidth + legendGap + item.width : item.width; + if (nextWidth > legendMaxWidth && currentRow.length) { + legendRows.push({ items: currentRow, width: currentWidth }); + currentRow = [item]; + currentWidth = item.width; + } else { + currentRow.push(item); + currentWidth = nextWidth; + } + }); + if (currentRow.length) { + legendRows.push({ items: currentRow, width: currentWidth }); + } + + const legendGroup = svg.append("g") + .attr("class", "legend") + .attr("data-coordinate-rule", "independent-header-row") + .attr("data-alignment-basis", "fixed-header-row-offset") + .attr("data-legend-shape", "rounded-pill-controls-with-circular-swatches") + .attr("transform", `translate(0, ${Math.max(14, margin.top - 64)})`); + + legendRows.forEach((row, rowIndex) => { + let legendX = (width - row.width) / 2; + const legendY = rowIndex * legendRowHeight; + row.items.forEach(itemData => { + const group = itemData.group; + const item = legendGroup.append("g") + .attr("class", "legend-item legend-pill") + .attr("data-coordinate-rule", "independent-centered-pill") + .attr("transform", `translate(${legendX}, ${legendY})`); + item.append("rect") + .attr("class", "legend-pill-background") + .attr("x", 0) + .attr("y", -18) + .attr("width", itemData.width) + .attr("height", 34) + .attr("rx", 15) + .attr("ry", 15) + .attr("fill", "#fdfefe") + .attr("stroke", "#d6e1ea") + .attr("stroke-width", 2); + const swatchColor = colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + item.append("circle") + .attr("class", "legend-swatch") + .attr("cx", 24) + .attr("cy", -1) + .attr("r", 11) + .attr("fill", swatchColor); + item.append("circle") + .attr("class", "legend-swatch-highlight") + .attr("cx", 20.5) + .attr("cy", -4.5) + .attr("r", 2.2) + .attr("fill", "#ffffff") + .attr("opacity", 0.85); + item.append("text") + .attr("x", 45) + .attr("y", 0) + .attr("dominant-baseline", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", 14) + .attr("font-weight", 800) + .attr("fill", "#071d44") + .text(itemData.label); + legendX += itemData.width + legendGap; + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_16.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_16.js new file mode 100644 index 0000000000000000000000000000000000000000..9363e8938839fda2b7b8b97ea3b8f87583ff188b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_16.js @@ -0,0 +1,580 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_16", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data || {}; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const images = jsonData.images || { field: {}, other: {} }; + + const width = Number(variables.width) || 1024; + const height = Number(variables.height) || 1536; + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const xField = xChannel.key; + const yField = yChannel.key; + const groupField = groupChannel.key; + const yUnit = normalizedUnit(yChannel.unit); + + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "vertical_group_bar_chart_16") + .attr("data-reference", "sample_00_gpt_image_2_00") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + const defs = svg.append("defs"); + defs.append("linearGradient").attr("id", "vg16-bg").attr("x1", "0%").attr("x2", "100%").attr("y1", "0%").attr("y2", "100%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#fff7fa"); + g.append("stop").attr("offset", "50%").attr("stop-color", "#f8f9ff"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#eef3ff"); + }); + defs.append("radialGradient").attr("id", "vg16-left-wash").attr("cx", "18%").attr("cy", "82%").attr("r", "76%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#ffe7ec").attr("stop-opacity", "0.95"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#ffffff").attr("stop-opacity", "0"); + }); + defs.append("radialGradient").attr("id", "vg16-right-wash").attr("cx", "88%").attr("cy", "75%").attr("r", "72%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#e4eaff").attr("stop-opacity", "0.95"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#ffffff").attr("stop-opacity", "0"); + }); + addVerticalGradient(defs, "vg16-red-bar", "#b70f2a", "#e11f45"); + addVerticalGradient(defs, "vg16-purple-bar", "#5a25aa", "#8b4ee5"); + addDropShadow(defs, "vg16-soft-shadow", 0, 12, 22, 0.16); + addDropShadow(defs, "vg16-card-shadow", 0, 8, 18, 0.13); + + svg.append("rect").attr("width", width).attr("height", height).attr("rx", 38).attr("fill", "url(#vg16-bg)"); + svg.append("rect").attr("width", width).attr("height", height).attr("rx", 38).attr("fill", "url(#vg16-left-wash)"); + svg.append("rect").attr("width", width).attr("height", height).attr("rx", 38).attr("fill", "url(#vg16-right-wash)"); + drawDotGrid(svg, 20, 122, 8, 6, "#d9dce7", 0.7); + drawDotGrid(svg, width - 112, 40, 6, 5, "#d9dce7", 0.65); + + const rows = chartData + .map(d => ({ + raw: d, + category: d[xField], + group: d[groupField], + value: Number(d[yField]) + })) + .filter(d => d.category != null && d.group != null && Number.isFinite(d.value)); + + let categories = unique(rows.map(d => d.category)); + if (isTemporalField(xField, xChannel)) { + categories = categories.slice().sort((a, b) => temporalKey(a) - temporalKey(b)); + } + const groups = unique(rows.map(d => d.group)).slice(0, 2); + const valuesByCategory = new Map(); + categories.forEach(category => { + const byGroup = new Map(); + rows.filter(d => d.category === category).forEach(d => byGroup.set(d.group, d)); + valuesByCategory.set(category, byGroup); + }); + + const title = titleText(jsonData); + const subtitle = subtitleText(jsonData); + const headerLayout = drawHeader(svg, title, subtitle, groups, width); + drawLegend(svg, groups, width, colorResolver, headerLayout.legendY); + + if (categories.length <= 4) { + drawPanelMode(svg, categories, groups, valuesByCategory, { + width, + height, + yUnit, + images, + colorResolver, + fontFamily: labelFont(typography) + }); + } else { + drawDenseMode(svg, categories, groups, valuesByCategory, { + width, + height, + yUnit, + images, + colorResolver, + fontFamily: labelFont(typography) + }); + } + + return svg.node(); + + function drawHeader(root, titleValue, subtitleValue, groupValues, canvasWidth) { + const titleLines = wrapWords(titleValue, canvasWidth < 760 ? 22 : 25, 3); + const topY = 120; + const titleFont = titleLines.length > 2 ? 52 : 62; + const lineHeight = titleFont * 1.28; + titleLines.forEach((line, index) => { + const y = topY + index * lineHeight; + const accent = index === titleLines.length - 1; + root.append("text") + .attr("x", canvasWidth / 2) + .attr("y", y) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", titleFont) + .attr("font-weight", 900) + .attr("letter-spacing", "0") + .attr("fill", accent ? "#5533bd" : "#07122d") + .text(line); + }); + + const ruleY = topY + titleLines.length * lineHeight + 8; + root.append("line").attr("x1", canvasWidth / 2 - 70).attr("x2", canvasWidth / 2 + 70) + .attr("y1", ruleY).attr("y2", ruleY) + .attr("stroke", "url(#vg16-red-bar)").attr("stroke-width", 4).attr("stroke-linecap", "round"); + + const subtitleLines = wrapWords(stripOuterQuotes(subtitleValue), 48, 2); + const subtitleGroup = root.append("text") + .attr("class", "vg16-subtitle") + .attr("x", canvasWidth / 2) + .attr("y", ruleY + 66) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, 'Times New Roman', serif") + .attr("font-size", 30) + .attr("font-style", "italic") + .attr("font-weight", 400) + .attr("fill", "#526173"); + subtitleLines.forEach((line, index) => { + subtitleGroup.append("tspan") + .attr("x", canvasWidth / 2) + .attr("dy", index === 0 ? 0 : 42) + .text(index === 0 ? `“${line}` : line + "”"); + }); + + const slotsAboveTitle = titleLines.length > 2 || titleLines.slice(1).some(line => line.length >= 24); + drawReservedHeaderSlot(root, slotsAboveTitle ? 18 : 78, slotsAboveTitle ? 34 : 170, groupValues[0] || "A", "header_metric_left"); + drawReservedHeaderSlot(root, slotsAboveTitle ? canvasWidth - 110 : canvasWidth - 148, slotsAboveTitle ? 48 : 184, groupValues[1] || "B", "header_metric_right"); + + const subtitleBottom = ruleY + 66 + Math.max(0, subtitleLines.length - 1) * 42 + 16; + return { + legendY: Math.max(434, subtitleBottom + 28) + }; + } + + function drawReservedHeaderSlot(root, x, y, label, slotName) { + const initials = initialsFor(label); + const slot = root.append("g") + .attr("class", `reserved-asset-slot vg16-${slotName}`) + .attr("data-asset-slot", slotName) + .attr("data-reserved-slot", slotName) + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", slotName === "header_metric_left" ? "top-left-header-safe-area" : "top-right-header-safe-area") + .attr("data-bbox", `${x},${y},92,92`) + .attr("data-collision-rule", "avoid title subtitle legend chart panels and canvas edge") + .attr("data-mask-policy", "rounded-square slot; downstream asset replaces only inside this box") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("rect") + .attr("x", x).attr("y", y).attr("width", 92).attr("height", 92).attr("rx", 22) + .attr("fill", "#fffafd").attr("stroke", "#ffffff").attr("stroke-width", 2) + .style("filter", "url(#vg16-card-shadow)"); + slot.append("text") + .attr("x", x + 46).attr("y", y + 58).attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif").attr("font-size", 24) + .attr("font-weight", 900).attr("fill", slotName === "header_metric_left" ? "#b91631" : "#5b34bd") + .text(initials); + } + + function drawLegend(root, groupValues, canvasWidth, resolver, legendY = 434) { + const legendLabels = groupValues.map(group => labelWithUnit(group)); + const totalLegendChars = legendLabels.reduce((acc, label) => acc + label.length, 0); + const longLegend = totalLegendChars > 44 || legendLabels.some(label => label.length > 23); + const cardW = longLegend + ? Math.min(canvasWidth - 150, Math.max(620, totalLegendChars * 14 + 170)) + : Math.min(600, Math.max(480, groupValues.reduce((acc, g) => acc + String(g).length * 13, 220) + 210)); + const legendFontSize = longLegend ? 24 : 26; + const cardX = (canvasWidth - cardW) / 2; + const legend = root.append("g").attr("class", "vg16-legend"); + legend.append("rect") + .attr("x", cardX).attr("y", legendY) + .attr("width", cardW).attr("height", 74).attr("rx", 18) + .attr("fill", "#ffffff").attr("stroke", "#edf0f8").attr("stroke-width", 1) + .style("filter", "url(#vg16-card-shadow)"); + const itemGap = cardW / Math.max(2, groupValues.length); + groupValues.forEach((group, index) => { + const textApproxW = legendLabels[index].length * (legendFontSize * 0.5); + const itemX = longLegend && groupValues.length === 2 && index === 1 + ? cardX + cardW - 44 - textApproxW - 44 + : cardX + 44 + index * itemGap; + legend.append("rect") + .attr("x", itemX).attr("y", legendY + 24).attr("width", 28).attr("height", 28).attr("rx", 4) + .attr("fill", groupColor(index, group, resolver)); + legend.append("text") + .attr("x", itemX + 44).attr("y", legendY + 47) + .attr("font-family", "Arial, Helvetica, sans-serif").attr("font-size", legendFontSize) + .attr("font-weight", 500).attr("fill", "#111827") + .text(legendLabels[index]); + }); + } + + function drawPanelMode(root, categories, groupValues, valueMap, opts) { + const panelY = 612; + const panelH = 718; + const gap = 14; + const panelCount = Math.max(2, categories.length); + const panelW = (opts.width - gap * (panelCount - 1)) / panelCount; + const maxValue = d3.max(rows, d => d.value) || 1; + categories.forEach((category, categoryIndex) => { + const panelX = categoryIndex * (panelW + gap); + const panelFill = categoryIndex % 2 === 0 ? "#fff0f4" : "#f0f3ff"; + const panel = root.append("g") + .attr("class", "vg16-category-panel") + .attr("data-category", category) + .attr("data-reference-local-geometry", "grid-aligned category panel; bars baseline-aligned inside panel"); + panel.append("rect") + .attr("x", panelX).attr("y", panelY).attr("width", panelW).attr("height", panelH) + .attr("rx", 32).attr("fill", panelFill).attr("opacity", 0.88) + .attr("stroke", "#ffffff").attr("stroke-width", 1.5) + .style("filter", "url(#vg16-soft-shadow)"); + + const baselineY = panelY + panelH - 112; + const plotTop = panelY + 74; + const plotH = baselineY - plotTop; + panel.append("line") + .attr("x1", panelX + 104).attr("x2", panelX + panelW - 34) + .attr("y1", baselineY).attr("y2", baselineY) + .attr("stroke", "#0b1222").attr("stroke-width", 2); + + const barW = Math.min(126, panelW / 4.0); + const center = panelX + panelW / 2 - 16; + const positions = [ + center - barW * 0.85, + center + barW * 0.62 + ]; + groupValues.forEach((group, groupIndex) => { + const datum = valueMap.get(category).get(group); + if (!datum) return; + const rawH = (datum.value / maxValue) * plotH; + const barH = Math.max(64, rawH); + const barX = positions[groupIndex] || (center + (groupIndex - 0.5) * barW * 1.35); + const barY = baselineY - barH; + const fill = groupColor(groupIndex, group, opts.colorResolver); + panel.append("path") + .attr("class", "bar vg16-bar") + .attr("data-category", category) + .attr("data-group", group) + .attr("data-value", datum.value) + .attr("data-endcap-geometry", "rounded-top flat-baseline") + .attr("d", topRoundedRectPath(barX, barY, barW, barH, 18)) + .attr("fill", fill) + .attr("stroke", "rgba(255,255,255,0.34)") + .attr("stroke-width", 1); + drawBarCapSlot(panel, barX + barW / 2, barY, group, groupIndex, 42); + drawValueLabel(panel, barX + barW / 2, barY - 92, datum.value, group, groupIndex, opts.yUnit); + }); + drawCategoryIconAndLabel(panel, category, panelX + panelW / 2, baselineY + 30, opts.images, opts.fontFamily); + }); + } + + function drawDenseMode(root, categories, groupValues, valueMap, opts) { + const panelX = 56; + const panelY = 612; + const panelW = opts.width - panelX * 2; + const panelH = 704; + const baselineY = panelY + panelH - 112; + const plotTop = panelY + 74; + const plotH = baselineY - plotTop; + const maxValue = d3.max(rows, d => d.value) || 1; + const panel = root.append("g") + .attr("class", "vg16-dense-panel") + .attr("data-reference-generalization", "dense representative sample uses one panel to avoid category overlap"); + panel.append("rect") + .attr("x", panelX).attr("y", panelY).attr("width", panelW).attr("height", panelH) + .attr("rx", 32).attr("fill", "#fff8fb").attr("opacity", 0.92) + .attr("stroke", "#ffffff").attr("stroke-width", 1.5) + .style("filter", "url(#vg16-soft-shadow)"); + const x = d3.scaleBand().domain(categories).range([panelX + 38, panelX + panelW - 38]).paddingInner(0.18).paddingOuter(0.08); + const gx = d3.scaleBand().domain(groupValues).range([0, x.bandwidth()]).paddingInner(0.14); + panel.append("line").attr("x1", panelX + 38).attr("x2", panelX + panelW - 38) + .attr("y1", baselineY).attr("y2", baselineY).attr("stroke", "#0b1222").attr("stroke-width", 2); + const labelEvery = categories.length > 10 ? 2 : 1; + categories.forEach((category, categoryIndex) => { + groupValues.forEach((group, groupIndex) => { + const datum = valueMap.get(category).get(group); + if (!datum) return; + const barW = Math.max(7, gx.bandwidth()); + const barH = Math.max(18, (datum.value / maxValue) * plotH); + const barX = x(category) + gx(group); + const barY = baselineY - barH; + panel.append("path") + .attr("class", "bar vg16-bar dense") + .attr("data-category", category) + .attr("data-group", group) + .attr("data-value", datum.value) + .attr("data-endcap-geometry", "rounded-top flat-baseline") + .attr("d", topRoundedRectPath(barX, barY, barW, barH, Math.min(10, barW / 2))) + .attr("fill", groupColor(groupIndex, group, opts.colorResolver)); + if (categories.length <= 8 || datum.value === maxValue) { + drawValueLabel(panel, barX + barW / 2, barY - 10, datum.value, group, groupIndex, opts.yUnit, 18, false); + } + }); + if (categoryIndex % labelEvery === 0) { + panel.append("text") + .attr("x", x(category) + x.bandwidth() / 2) + .attr("y", baselineY + 34) + .attr("text-anchor", "end") + .attr("transform", `rotate(-34 ${x(category) + x.bandwidth() / 2} ${baselineY + 34})`) + .attr("font-family", opts.fontFamily) + .attr("font-size", 18) + .attr("font-weight", 700) + .attr("fill", "#111827") + .text(shortLabel(category, 15)); + } + }); + } + + function drawBarCapSlot(root, cx, barTopY, group, groupIndex, radius) { + const cy = barTopY - 8; + const slot = root.append("g") + .attr("class", "reserved-asset-slot vg16-bar-cap-slot") + .attr("data-asset-slot", `bar_cap_metric_icon_${slug(group)}`) + .attr("data-reserved-slot", `bar_cap_metric_icon_${slug(group)}`) + .attr("data-asset-source-policy", "neutral_placeholder_then_image2_asset") + .attr("data-anchor", "bar-value-edge-centerline") + .attr("data-bbox", `${(cx - radius).toFixed(1)},${(cy - radius).toFixed(1)},${(radius * 2).toFixed(1)},${(radius * 2).toFixed(1)}`) + .attr("data-collision-rule", "centered on bar cap; avoid value label and category icon") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle") + .attr("cx", cx).attr("cy", cy).attr("r", radius) + .attr("fill", groupIndex === 0 ? "#c71736" : "#7041c9") + .attr("stroke", "#ffffff").attr("stroke-width", 3) + .style("filter", "url(#vg16-card-shadow)"); + slot.append("text") + .attr("x", cx).attr("y", cy + 9).attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif").attr("font-size", 22) + .attr("font-weight", 900).attr("fill", "#ffffff") + .text(initialsFor(group)); + } + + function drawValueLabel(root, x, y, value, group, groupIndex, unit, fontSize = 34, twoLine = true) { + const color = groupIndex === 0 ? "#9f1028" : "#5d35b1"; + const text = root.append("text") + .attr("class", "bar-label vg16-value-label") + .attr("x", x).attr("y", y) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", fontSize) + .attr("font-weight", 900) + .attr("fill", color); + text.append("tspan").attr("x", x).text(formatValue(value)); + const unitText = unitForGroup(group, unit); + if (unitText && twoLine) { + text.append("tspan").attr("x", x).attr("dy", fontSize * 0.88).attr("font-size", fontSize * 0.68).text(unitText); + } else if (unitText) { + text.text(`${formatValue(value)}${unitText === "%" ? "%" : ""}`); + } + } + + function drawCategoryIconAndLabel(root, category, cx, y, imageData, fontFamily) { + const icon = imageData && imageData.field && imageData.field[category]; + const circleR = 44; + root.append("circle") + .attr("cx", cx).attr("cy", y + circleR).attr("r", circleR) + .attr("fill", "#ffffff").attr("stroke", "#edf0f7").attr("stroke-width", 1.5) + .style("filter", "url(#vg16-card-shadow)"); + if (icon) { + root.append("image") + .attr("class", "category-icon") + .attr("data-asset-source-policy", "input-provided") + .attr("data-anchor", "category-label-center") + .attr("x", cx - 28).attr("y", y + circleR - 28).attr("width", 56).attr("height", 56) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("href", icon) + .attr("xlink:href", icon); + } else { + root.append("text") + .attr("x", cx).attr("y", y + circleR + 9).attr("text-anchor", "middle") + .attr("font-family", fontFamily).attr("font-size", 24).attr("font-weight", 900) + .attr("fill", "#526173").text(initialsFor(category)); + } + root.append("text") + .attr("class", "x-label") + .attr("x", cx).attr("y", y + 112).attr("text-anchor", "middle") + .attr("font-family", fontFamily).attr("font-size", 30).attr("font-weight", 800) + .attr("fill", "#0b1222").text(shortLabel(category, 22)); + } + + function groupColor(index, group, resolver) { + return index === 0 ? "url(#vg16-red-bar)" : "url(#vg16-purple-bar)"; + } + + function labelWithUnit(group) { + const unitText = unitForGroup(group, yUnit); + if (!unitText || String(group).toLowerCase().includes(unitText.toLowerCase())) return String(group); + if (unitText === "%") return `${group} (%)`; + return `${group} (${unitText})`; + } +} + +function addVerticalGradient(defs, id, top, bottom) { + defs.append("linearGradient").attr("id", id).attr("x1", "0%").attr("x2", "0%").attr("y1", "0%").attr("y2", "100%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", top); + g.append("stop").attr("offset", "100%").attr("stop-color", bottom); + }); +} + +function addDropShadow(defs, id, dx, dy, blur, opacity) { + const filter = defs.append("filter").attr("id", id).attr("x", "-30%").attr("y", "-30%").attr("width", "160%").attr("height", "160%"); + filter.append("feDropShadow") + .attr("dx", dx).attr("dy", dy).attr("stdDeviation", blur) + .attr("flood-color", "#141b31").attr("flood-opacity", opacity); +} + +function topRoundedRectPath(x, y, w, h, r) { + const radius = Math.max(0, Math.min(r, w / 2, h)); + return [ + `M ${x} ${y + h}`, + `L ${x} ${y + radius}`, + `Q ${x} ${y} ${x + radius} ${y}`, + `L ${x + w - radius} ${y}`, + `Q ${x + w} ${y} ${x + w} ${y + radius}`, + `L ${x + w} ${y + h}`, + "Z" + ].join(" "); +} + +function drawDotGrid(root, x, y, cols, rows, color, opacity) { + const g = root.append("g").attr("class", "vg16-dot-grid").attr("opacity", opacity); + for (let row = 0; row < rows; row += 1) { + for (let col = 0; col < cols; col += 1) { + g.append("circle").attr("cx", x + col * 16).attr("cy", y + row * 16).attr("r", 3).attr("fill", color); + } + } +} + +function unique(values) { + return Array.from(new Set(values.map(v => String(v)))); +} + +function normalizedUnit(unit) { + const text = String(unit || "").trim(); + return text && text.toLowerCase() !== "none" ? text : ""; +} + +function unitForGroup(group, explicitUnit) { + if (explicitUnit) return explicitUnit; + const text = String(group || "").toLowerCase(); + if (/memory|footprint|storage|ram/.test(text)) return "GB"; + if (/time|duration|training/.test(text)) return "min"; + if (/rate|percent|share|proportion/.test(text)) return "%"; + return ""; +} + +function titleText(data) { + return (data.titles && data.titles.main_title) + || (data.metadata && data.metadata.title) + || data.title + || "Grouped Bar Comparison"; +} + +function subtitleText(data) { + return (data.titles && data.titles.sub_title) + || (data.metadata && data.metadata.description) + || (data.metadata && data.metadata.main_insight) + || ""; +} + +function stripOuterQuotes(text) { + return String(text || "").replace(/^["“]+|["”]+$/g, ""); +} + +function labelFont(typography) { + return (typography.label && typography.label.font_family) || "Arial, Helvetica, sans-serif"; +} + +function wrapWords(text, maxChars, maxLines) { + const words = String(text || "").trim().split(/\s+/).filter(Boolean); + if (!words.length) return ["Grouped Bar Comparison"]; + const lines = []; + let current = ""; + words.forEach(word => { + const trial = current ? `${current} ${word}` : word; + if (current && trial.length > maxChars) { + lines.push(current); + current = word; + } else { + current = trial; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = `${kept[maxLines - 1].replace(/\.*$/, "")}...`; + return kept; + } + return lines; +} + +function shortLabel(value, maxChars) { + const text = String(value || ""); + return text.length > maxChars ? `${text.slice(0, Math.max(1, maxChars - 1))}...` : text; +} + +function initialsFor(value) { + const words = String(value || "").replace(/[^A-Za-z0-9 ]/g, " ").trim().split(/\s+/).filter(Boolean); + if (!words.length) return ""; + return words.slice(0, 2).map(w => w[0].toUpperCase()).join(""); +} + +function slug(value) { + return String(value || "group").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "group"; +} + +function formatValue(value) { + if (Math.abs(value) >= 100 || Number.isInteger(value)) return d3.format(",.0f")(value); + return d3.format(".1f")(value); +} + +function isTemporalField(field, channel) { + const name = String(field || "").toLowerCase(); + const type = String((channel && (channel.data_type || channel.type)) || "").toLowerCase(); + return type.includes("temporal") || /(year|date|month|time|season|quarter)/.test(name); +} + +function temporalKey(value) { + const text = String(value || "").trim(); + const lower = text.toLowerCase(); + const months = { jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 }; + if (/^\d{4}$/.test(text)) return Number(text); + if (months[lower]) return months[lower]; + const prefix = lower.match(/^(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)/); + if (prefix && months[prefix[1]]) return months[prefix[1]]; + const parsed = Date.parse(text); + return Number.isNaN(parsed) ? Number.MAX_SAFE_INTEGER : parsed; +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_2.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_2.js new file mode 100644 index 0000000000000000000000000000000000000000..4eab88632f7bc219e9543d45131b5cc4b72608b5 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_2.js @@ -0,0 +1,313 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_2", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 7], [0, 100], [3, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + let chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // 用于测量文本宽度的辅助函数 + function measureTextWidth(text, fontSize = typography.label.font_size) { + // 简单估算文本宽度 - 减小系数以避免过度缩放 + let fontSizeValue = 14; // 默认字体大小 + if (typeof fontSize === 'string') { + fontSizeValue = parseInt(fontSize.replace('px', '')); + } else if (typeof fontSize === 'number') { + fontSizeValue = fontSize; + } + + // 使用更保守的系数估算每个字符的宽度 + return chartUtils.text.estimate(text, { fontSize: fontSizeValue, factor: 0.45 }).width; + } + + // 确定标签的最大长度和缩放比例 + let minXLabelRatio = 1.0; + // 增加允许的宽度比例，使标签有更多空间 + const maxXLabelWidth = xScale.bandwidth() * 1.1; + + // 获取最长标签的宽度 + processedData.forEach(d => { + const xLabelText = String(d.category); + let fontSize = parseInt(typography.label.font_size); + let estimatedWidth = measureTextWidth(xLabelText, fontSize); + + if (estimatedWidth > maxXLabelWidth) { + const newRatio = maxXLabelWidth / estimatedWidth; + minXLabelRatio = Math.min(minXLabelRatio, newRatio); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + const xAxisGroup = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + + // 处理X轴标签重叠问题 + xAxisGroup.selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", function() { + if (minXLabelRatio < 0.9) { // 只有当缩放比例小于0.9时才缩小字体 + // 计算比例时增加限制，避免过度缩小 + const scaleFactor = Math.max(minXLabelRatio, 0.7); + return `${parseInt(typography.label.font_size) * scaleFactor}px`; + } + return typography.label.font_size; + }) + .style("text-anchor", "middle") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加图标 + xAxisGroup.selectAll(".tick") + .append("image") + .attr("xlink:href", (d) => { + const dataItem = processedData.find(item => item.category === d); + return dataItem?.icon || ''; + }) + .attr("x", -8) // 调整图标位置 + .attr("y", 10) + .attr("width", 16) + .attr("height", 16) + .attr("style", "display: inline-block"); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + barGroups.append("rect") + .attr("class", "bar") + .attr("x", d => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.groups[group] || 0)) + .attr("fill", colorResolver.field(group, 0, { fallbackKey: "primary" }).value); + + // 修改数值标签为竖向、白色，放在柱形图内部顶端 + barGroups.append("text") + .attr("class", "label") + .attr("x", d => groupScale(group) + groupScale.bandwidth() / 2) + .attr("y", d => { + const barHeight = chartHeight - yScale(d.groups[group] || 0); + // 如果柱形高度足够，放在内部，否则放在外部 + return barHeight > 25 ? + yScale(d.groups[group] || 0) + 15 : // 内部 + yScale(d.groups[group] || 0) - 5; // 外部 + }) + .attr("text-anchor", "middle") + .attr("transform", d => { + const barHeight = chartHeight - yScale(d.groups[group] || 0); + const x = groupScale(group) + groupScale.bandwidth() / 2 + 2; // 向右移动2px + const y = barHeight > 25 ? + yScale(d.groups[group] || 0) + 15 : // 内部 + yScale(d.groups[group] || 0) - 5; // 外部 + return `rotate(-90, ${x}, ${y})`; + }) + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", d => { + const barHeight = chartHeight - yScale(d.groups[group] || 0); + return barHeight > 25 ? "#FFFFFF" : colorResolver.text({ fallback: "#333333" }).value; // 内部白色，外部黑色 + }) + .text(d => chartUtils.format.autoText(d.groups[group] || 0)) // 使用格式化函数 + .style("opacity", 1); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_3.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_3.js new file mode 100644 index 0000000000000000000000000000000000000000..1555f90f571ca69fc6a2187bed6bda953e8436c4 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_3.js @@ -0,0 +1,282 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_3", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 6], [0, "inf"], [2, 8]], + "required_fields_icons": ["x"], + "required_other_icons": ["primary"], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "gradient", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ +// Grouped Bar Chart implementation using D3.js +function makeChart(containerSelector, data) { + // Extract data from the json_data object + const jsonData = data; + const chartData = jsonData.data.data + const variables = jsonData.variables; + const typography = jsonData.typography; + const colors = jsonData.colors || {}; + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // Set width and height based on variables + const width = variables.width; + const height = variables.height; + const margin = { top: 60, right: 100, bottom: 60, left: 80 }; + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // Extract axis fields based on data_columns order + const xField = chartUtils.schema.columnField(dataColumns, 0); + const yField = chartUtils.schema.columnField(dataColumns, 1); + const groupField = chartUtils.schema.columnField(dataColumns, 2); + const imageSize = 32; + + // 获取Y轴单位 + const yUnit = chartUtils.schema.column(dataColumns, 1, { fallbackKey: yField }).unit; + + // Get unique x values and groups + const xValues = [...new Set(chartData.map(d => d[xField]))]; + const groupValues = [...new Set(chartData.map(d => d[groupField]))]; + + // Create color scale using colors from json_data + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // Create SVG inside the chart-container div + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg"); + + // Add title if it exists in variables + if (variables.title && variables.title.text) { + svg.append("text") + .attr("x", width / 2) + .attr("y", margin.top / 2) + .attr("text-anchor", "middle") + .style("font-family", typography.title.font_family) + .style("font-size", typography.title.font_size) + .style("font-weight", typography.title.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(variables.title.text); + } + + // Create chart group and apply margin + const g = svg.append("g") + .attr("transform", `translate(${margin.left},${margin.top})`); + + // Create scales + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.2); + + const xGroupScale = d3.scaleBand() + .domain(groupValues) + .range([0, xScale.bandwidth()]) + .padding(variables.has_spacing ? 0.1 : 0.05); + + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField]) * 1.1]) + .range([innerHeight, 0]); + + // Draw x-axis + const xAxis = g.append("g") + .attr("transform", `translate(0,${innerHeight})`) + .call(d3.axisBottom(xScale)) + .style("color", colorResolver.text({ fallback: "#333333" }).value); + + // Apply typography to x-axis labels + xAxis.selectAll("text") + .attr("transform", "translate(0, 32)") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight); + + // Add icons to x-axis if available + xValues.forEach(value => { + if (images.field && images.field[value]) { + const xPos = xScale(value) + xScale.bandwidth() / 2; + + g.append("image") + .attr("href", images.field[value]) + .attr("x", xPos - imageSize / 2) + .attr("y", innerHeight + 5) + .attr("width", imageSize) + .attr("height", imageSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("text-anchor", "middle"); + } + }); + + // Draw y-axis + const yAxis = g.append("g") + .call(d3.axisLeft(yScale) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : ''))) + .style("color", colorResolver.text({ fallback: "#333333" }).value); + + // Apply typography to y-axis labels + yAxis.selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight); + + // Create gradient defs if needed + if (variables.has_gradient) { + const defs = svg.append("defs"); + groupValues.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("gradientUnits", "userSpaceOnUse") + .attr("x1", 0) + .attr("y1", 0) + .attr("x2", 0) + .attr("y2", innerHeight); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", baseColor); + }); + } + + // Add shadow filter if needed + if (variables.has_shadow) { + const defs = svg.select("defs").size() ? svg.select("defs") : svg.append("defs"); + + defs.append("filter") + .attr("id", "shadow") + .append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 2) + .attr("flood-opacity", 0.3); + } + + // Create bars with effects + const barGroups = g.selectAll(".bar-group") + .data(xValues) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d)},0)`); + + // Add bars for each group + barGroups.selectAll(".bar") + .data(d => { + return groupValues.map(group => { + const match = chartData.find(item => item[xField] === d && item[groupField] === group); + return { + x: d, + group: group, + value: match ? match[yField] : 0 + }; + }); + }) + .enter() + .append("rect") + .attr("class", "bar") + .attr("x", d => xGroupScale(d.group)) + .attr("y", d => yScale(d.value)) + .attr("width", xGroupScale.bandwidth()) + .attr("height", d => innerHeight - yScale(d.value)) + .attr("fill", d => { + // Apply gradient if needed + if (variables.has_gradient) { + const gradientId = `gradient-${d.group.replace(/\s+/g, '-').toLowerCase()}`; + return `url(#${gradientId})`; + } else { + return getColor(d.group); + } + }) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? colorResolver.other("stroke_color", { fallback: "#FFFFFF" }).value : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 0.8); + }) + .on("mouseout", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 1); + }); + + // Add data labels + barGroups.selectAll(".label") + .data(d => { + return groupValues.map(group => { + const match = chartData.find(item => item[xField] === d && item[groupField] === group); + return { + x: d, + group: group, + value: match ? match[yField] : 0 + }; + }).filter(d => d.value > 0); // Only add labels for bars with values + }) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xGroupScale(d.group) + xGroupScale.bandwidth() / 2) + .attr("y", d => yScale(d.value) + 15) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "10px") + .style("fill", "white") + .style("pointer-events", "none") + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')); + chartUtils.legend.draw(svg, groupValues, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: width - margin.right + 20, + y: margin.top, + direction: "vertical", + markerShape: "rect", + markerSize: 15, + labelGap: 5, + rowGap: 10, + itemHeight: 25, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_4.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_4.js new file mode 100644 index 0000000000000000000000000000000000000000..6212ebd2aefe7a03c480581e51751042b4fe1353 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_4.js @@ -0,0 +1,455 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_4", + "is_composite": false, + "required_fields": ["x", "y", "group","group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"], ["categorical"]], + "required_fields_range": [[2, 8], [0, "inf"], [2, 2], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直分组条形图实现 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { primary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 如果不存在，添加副标题字段 + typography.subtitle = typography.subtitle || typography.description; + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清除容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 500; + + // 边距：上，右，下，左 + const margin = { + top: 100, // 标题和副标题的空间 + right: 30, // 右侧标签的空间 + bottom: 60, // x轴和标签的空间 + left: 100 // y轴和标签的空间 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, group1Field, group2Field; + let yUnit = ""; + + // 从数据列中安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + + xField = xChannel.key; + yField = yChannel.key; + group1Field = chartUtils.schema.channel(jsonData, "group").key; + group2Field = chartUtils.schema.channel(jsonData, "group2").key; + + // 获取字段单位（如果存在） + if (yChannel.unit) { + yUnit = yChannel.unit; + } + + // ---------- 4. 数据处理 ---------- + // 使用提供的数据 + let useData = chartData; + + // 获取x轴和分组的唯一值 + const xValues = [...new Set(useData.map(d => d[xField]))]; + const group1Values = [...new Set(useData.map(d => d[group1Field]))]; // 第一个分组字段的唯一值 + const group2Values = [...new Set(useData.map(d => d[group2Field]))]; // 第二个分组字段的唯一值 + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + + + // ---------- 8. 创建比例尺 ---------- + // X比例尺（分类）用于主分类 + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.2); + + // Y比例尺（数值） + // 找出数据中的最大值，如果没有则默认为100 + const dataMax = d3.max(useData, d => +d[yField]) || 100; + // 向上取整到最接近的10，20，50或100 + let yMax; + if (dataMax <= 10) yMax = 10; + else if (dataMax <= 20) yMax = 20; + else if (dataMax <= 50) yMax = 50; + else if (dataMax <= 100) yMax = 100; + else yMax = Math.ceil(dataMax / 100) * 100; + + const yScale = d3.scaleLinear() + .domain([0, yMax]) + .range([innerHeight, 0]); + + // 分组比例尺，用于每个类别内的细分 + const totalGroups = group1Values.length * group2Values.length; + const groupScale = d3.scaleBand() + .domain(d3.range(totalGroups)) + .range([0, xScale.bandwidth()]) + .padding(variables.has_spacing ? 0.1 : 0.05); + + // 从颜色数据中获取group1的颜色映射 + const colorMap = {}; + + // 为每个group1值分配一个基础颜色 + group1Values.forEach(g1Value => { + // 尝试从数据中获取颜色 + const baseColor = colorResolver.field(g1Value, 0, { fallbackKey: "primary", fallback: "#4682B4" }).value; + + // 为group2的每个值分配不同深浅的颜色 + group2Values.forEach((g2Value, i) => { + // 根据索引调整颜色深浅 + let colorVariant; + if (group2Values.length === 1) { + colorVariant = baseColor; + } else if (group2Values.length === 2) { + // 如果只有两个值，一个浅色一个深色 + if (i === 0) { + colorVariant = lightenColor(baseColor, 30); // 第一个值使用浅色 + } else { + colorVariant = baseColor; // 第二个值使用原色 + } + } else { + // 如果有多个值，创建颜色梯度 + const step = 60 / (group2Values.length - 1); + colorVariant = lightenColor(baseColor, 40 - (i * step)); + } + + // 存储颜色映射 + colorMap[`${g1Value} ${g2Value}`] = colorVariant; + }); + }); + + // 辅助函数：根据百分比调亮颜色 + function lightenColor(color, percent) { + const hex = color.replace('#', ''); + const r = parseInt(hex.substr(0, 2), 16); + const g = parseInt(hex.substr(2, 2), 16); + const b = parseInt(hex.substr(4, 2), 16); + + const lightenR = Math.min(255, Math.floor(r + (255 - r) * (percent / 100))); + const lightenG = Math.min(255, Math.floor(g + (255 - g) * (percent / 100))); + const lightenB = Math.min(255, Math.floor(b + (255 - b) * (percent / 100))); + + return `#${lightenR.toString(16).padStart(2, '0')}${lightenG.toString(16).padStart(2, '0')}${lightenB.toString(16).padStart(2, '0')}`; + } + + // ---------- 9. 创建坐标轴 ---------- + // 底部的X轴 + chart.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(d3.axisBottom(xScale).tickSize(0)) + .call(g => { + g.select(".domain").remove(); + + // 计算四个小柱子的总宽度 + const fourBarsWidth = 4 * groupScale.bandwidth(); + + // 找出最长的x轴标签 + let maxLabelLength = 0; + let longestLabel = ''; + xValues.forEach(value => { + if (value.toString().length > maxLabelLength) { + maxLabelLength = value.toString().length; + longestLabel = value.toString(); + } + }); + + // 计算文本长度与所需长度的比率 + const tempTextLength = chartUtils.text.measure(chart, longestLabel, { + fontFamily: typography.label.font_family, + fontSize: 10, + fontWeight: typography.label.font_weight + }).width; + const targetLength = fourBarsWidth * 1.2; // 四个小柱子宽度的1.1倍 + const ratio = targetLength / tempTextLength; + + // 计算新的字体大小 + const newFontSize = Math.max(4, Math.floor(10 * ratio)); // 限制字体大小在8px到16px之间 + + // 应用新的字体大小 + g.selectAll(".tick text") + .style("font-family", typography.label.font_family) + .style("font-size", `${newFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + }); + + + + // ---------- 10. 绘制条形和为标签收集数据 ---------- + // 创建一个对象来存储每个x值和group1值组合的数据，用于后续绘制标签 + const labelData = {}; + + // 为每个x值和分组组合绘制条形 + xValues.forEach(xValue => { + // 筛选此x值的数据 + const xData = useData.filter(d => d[xField] === xValue); + + // 初始化此x值的标签数据 + labelData[xValue] = {}; + + // 为每个group1值初始化数据数组 + group1Values.forEach(g1Value => { + labelData[xValue][g1Value] = []; + }); + + // 为每个group1和group2组合绘制条形 + let groupIndex = 0; + + // 首先按group1分组，然后按group2分组 + group1Values.forEach(g1Value => { + // 这里的 g1Value 对应样图中的 "2011-12" 或 "2020-21" + group2Values.forEach((g2Value, g2Index) => { + // 这里的 g2Value 对应样图中的 "Male" 或 "Female" + + // 查找此组合的数据点 + const dataPoint = xData.find(d => + d[group1Field] === g1Value && + d[group2Field] === g2Value + ); + + if (dataPoint) { + // 计算条形位置和尺寸 + const barX = xScale(xValue) + groupScale(groupIndex); + const barY = yScale(+dataPoint[yField]); + const barWidth = groupScale.bandwidth(); + const barHeight = innerHeight - barY; + + // 获取此组合的颜色 + const colorKey = `${g1Value} ${g2Value}`; + const barColor = colorMap[colorKey]; + + // 绘制条形 + chart.append("rect") + .attr("class", "bar") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", barColor) + .attr("rx", variables.has_rounded_corners ? 2 : 0) + .attr("ry", variables.has_rounded_corners ? 2 : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 存储此条形的数据，以便后续绘制标签 + labelData[xValue][g1Value].push({ + value: dataPoint[yField], + barX: barX, + barWidth: barWidth, + barY: barY, + g2Index: g2Index // 保存group2的索引，以便知道哪个是第一个，哪个是第二个 + }); + } + + groupIndex++; + }); + }); + }); + + // ---------- 11. 绘制标签 ---------- + // 为每个x值处理标签 + Object.keys(labelData).forEach(xValue => { + // 为每个group1值处理标签 + Object.keys(labelData[xValue]).forEach(g1Value => { + // 获取此group1值的所有条形数据 + const bars = labelData[xValue][g1Value]; + + // 排序，确保按group2索引顺序处理 + bars.sort((a, b) => a.g2Index - b.g2Index); + + // 确保我们有两个条形（对应两个group2值） + if (bars.length === 2) { + // 获取两个条形 + const bar1 = bars[0]; // 第一个条形 (g2Index=0, 例如 Male) + const bar2 = bars[1]; // 第二个条形 (g2Index=1, 例如 Female) + + // 找出两个条形的最小Y值（最高点，因为Y轴是反的） + const minY = Math.min(bar1.barY, bar2.barY); + + // 计算两个条形之间的中心点 - 保持文本居中 + const textCenterX = bar1.barX + bar1.barWidth + (bar2.barX - (bar1.barX + bar1.barWidth)) / 2; + + // 计算标签背景矩形的宽度和高度 + const labelWidth = (bar1.barWidth + bar2.barWidth) * 0.9; // 两个柱子宽度之和的90% + const labelHeight = (bar1.barWidth + bar2.barWidth) * 0.5; // 标签高度 + const labelPadding = 5; // 两个标签之间的垂直间距 + + // 获取对应的颜色 + const color1 = colorMap[`${g1Value} ${group2Values[0]}`]; // 第一个条形的颜色 + const color2 = colorMap[`${g1Value} ${group2Values[1]}`]; // 第二个条形的颜色 + + // 绘制第二个条形的标签背景和文本 + chart.append("rect") + .attr("x", bar1.barX) // Align background to the left edge of the first bar + .attr("y", minY - labelHeight - 5 ) + .attr("width", labelWidth) + .attr("height", labelHeight) + .attr("fill", color2) + .attr("rx", variables.has_rounded_corners ? 2 : 0) + .attr("ry", variables.has_rounded_corners ? 2 : 0); + + chart.append("text") + .attr("class", "value-label") + .attr("x", textCenterX) // Keep text centered between bars + .attr("y", minY -5- labelHeight/2 ) // 垂直居中在矩形内 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelHeight * 0.8}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", "#FFFFFF") // 白色文本 + .text(chartUtils.format.autoText(bar2.value) + (yUnit ? ` ${yUnit}` : '')); // 使用格式化函数 + + // 绘制第一个条形的标签背景和文本 + chart.append("rect") + .attr("x", bar1.barX) // Align background to the left edge of the first bar + .attr("y", minY - labelHeight - 5 - labelPadding - labelHeight) + .attr("width", labelWidth) + .attr("height", labelHeight) + .attr("fill", color1) + .attr("rx", variables.has_rounded_corners ? 2 : 0) + .attr("ry", variables.has_rounded_corners ? 2 : 0); + + chart.append("text") + .attr("class", "value-label") + .attr("x", textCenterX) // Keep text centered between bars + .attr("y", minY - 5 - labelHeight - labelPadding - labelHeight/2 ) // 垂直居中在矩形内 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelHeight * 0.8}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", "#FFFFFF") // 白色文本 + .text(chartUtils.format.autoText(bar1.value) + (yUnit ? ` ${yUnit}` : '')); // 使用格式化函数 + } + }); + }); + + + + // ---------- 12. 创建图例 ---------- + const legendItems = []; + group2Values.forEach(g2Value => { + group1Values.forEach(g1Value => { + legendItems.push({ + label: `${g2Value} ${g1Value}`, + color: colorMap[`${g1Value} ${g2Value}`], + }); + }); + }); + const legendRectSize = 15; + const spaceBetweenRectAndText = 5; + const legendItemHeight = 25; + const legendTotalWidth = 180; + chartUtils.legend.draw(svg, legendItems.map(item => item.label), { + color: (_, i) => legendItems[i].color, + colorResolver, + colors, + }, { + x: width - legendTotalWidth, + y: margin.top - 50, + direction: "vertical", + markerShape: "rect", + markerSize: legendRectSize, + labelGap: spaceBetweenRectAndText, + rowGap: legendItemHeight - legendRectSize, + itemHeight: legendItemHeight, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + +return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_5.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_5.js new file mode 100644 index 0000000000000000000000000000000000000000..ae311c48ae591239abae50abcf75fbab420dadf9 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_5.js @@ -0,0 +1,507 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_5", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 10], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直分组条形图实现 - 带有百分比变化指示器 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: { + "2011 Sales": "#154360", // 深蓝色 (2011) + "2012 Sales": "#3498DB", // 浅蓝色 (2012) + "YoY Change": "#C0392B" // 红色 (百分比变化) + }, + other: { + primary: "#4682B4", + percentage_indicator: "#C0392B" // 百分比指示器的红色 + } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 如果不存在，添加副标题字段 + typography.subtitle = typography.subtitle || typography.description; + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清除容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 500; + + // 边距：上，右，下，左 + const margin = { + top: 100, // 标题和副标题的空间 + right: 40, // 右侧标签的空间 + bottom: 80, // x轴和标签的空间 + left: 80 // y轴和标签的空间 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, groupField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + + xField = xChannel.key; + yField = yChannel.key; + groupField = groupChannel.key; + + // 获取字段单位 + xUnit = xChannel.unit; + yUnit = yChannel.unit; + + // ---------- 4. 数据处理 ---------- + // 使用提供的数据 + let useData = chartData; + + // 获取x轴和分组的唯一值 + const xValues = [...new Set(useData.map(d => d[xField]))]; + let groupValues = [...new Set(useData.map(d => d[groupField]))]; + + // 确保我们只有两个组字段：第一个组是左侧柱子，第二个组是右侧柱子 + if (groupValues.length !== 2) { + console.warn("此图表需要恰好2个组字段：用于左侧和右侧柱状图。"); + } + + // 第一个组是左侧柱子，第二个组是右侧柱子 + const leftBarGroup = groupValues[0]; + const rightBarGroup = groupValues[1]; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8. 创建比例尺 ---------- + // X比例尺（分类）用于主分类 + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.2); + + // 分组比例尺，用于每个类别内的细分 + const groupScale = d3.scaleBand() + .domain([0, 1]) // 只有两个柱子，左侧和右侧 + .range([0, xScale.bandwidth()]) + .padding(0.2); // 增加同一维度柱子之间的间隙 + + // Y比例尺（数值） + // 找出数据中的最大值 + const dataMax = d3.max(useData, d => +d[yField]) ; + // 找出数据中的最小值 + const dataMin = d3.min(useData, d => +d[yField]) ; + // 向上取整到最接近的合适的刻度 + let yMax; + yMax = Math.ceil(dataMax * 1.2 / 10) * 10; // 向上取整到最接近的10的倍数 + let yMin; + if (dataMin < 0) { + yMin = Math.floor(dataMin * 1.2 / 10) * 10; // 向下取整到最接近的10的倍数 + } + else { + yMin = 0; // 如果没有负值，则从0开始 + } + + + const yScale = d3.scaleLinear() + .domain([yMin, yMax]) + .range([innerHeight, 0]); + + // 计算动态文本大小的函数 + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + // 否则，按比例缩小字体大小 + return Math.max(8, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + // 检查是否应该显示x轴标签 + const shouldShowLabel = (text) => { + const maxWidth = xScale.bandwidth() * 2; // 两个柱子宽度之和的两倍 + const avgCharWidth = 12 * 0.6; // 使用基础字体大小12 + const textWidth = text.length * avgCharWidth; + return textWidth <= maxWidth; + }; + + // ---------- 9. 创建坐标轴 ---------- + // 底部的X轴 + chart.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(d3.axisBottom(xScale).tickSize(0)) + .call(g => { + g.select(".domain").remove(); + + // 第一步：找出最长的标签并计算统一的字体大小 + let maxLabelLength = 0; + const allLabels = []; + + // 收集所有标签并找出最长的一个 + g.selectAll(".tick text").each(function(d) { + const labelText = d.toString(); + allLabels.push(labelText); + if (labelText.length > maxLabelLength) { + maxLabelLength = labelText.length; + } + }); + + // 使用最长标签计算合适的统一字体大小 + const maxWidth = xScale.bandwidth() ; + const longestLabel = allLabels.reduce((a, b) => a.length > b.length ? a : b, ""); + const uniformFontSize = calculateFontSize(longestLabel, maxWidth); + + // 第二步：应用统一字体大小，必要时进行换行处理 + g.selectAll(".tick text") + .style("font-family", typography.label.font_family) + .style("font-size", `${uniformFontSize}px`) // 应用统一的字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .each(function(d) { + const text = d3.select(this); + const labelText = d.toString(); + const labelWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: uniformFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 检查使用统一字体大小后，文本是否仍然超过可用宽度 + if (labelWidth > maxWidth) { + // 如果仍然太长，应用文本换行 + wrapText(text, labelText, maxWidth, 1.1); + } + }); + }); + + // 文本换行助手函数 + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + const textMeasureOptions = { + fontFamily: text.style("font-family") || typography.label.font_family, + fontSize: parseFloat(text.style("font-size")) || parseFloat(typography.label.font_size), + fontWeight: text.style("font-weight") || typography.label.font_weight + }; + const measureTextWidth = value => chartUtils.text.measure(null, value, textMeasureOptions).width; + let tspan = text.text(null).append("tspan") + .attr("x", 0) + .attr("y", y) + .attr("dy", dy + "em"); + + // 如果没有空格可分割，按字符分割 + if (words.length <= 1) { + const chars = str.split(''); + let currentLine = ''; + + for (let i = 0; i < chars.length; i++) { + currentLine += chars[i]; + tspan.text(currentLine); + + if (measureTextWidth(currentLine) > width && currentLine.length > 1) { + // 当前行过长，回退一个字符并换行 + currentLine = currentLine.slice(0, -1); + tspan.text(currentLine); + + // 创建新行 + currentLine = chars[i]; + tspan = text.append("tspan") + .attr("x", 0) + .attr("y", y) + .attr("dy", ++lineNumber * lineHeight + dy + "em") + .text(currentLine); + } + } + } else { + while (word = words.pop()) { + line.push(word); + tspan.text(line.join(" ")); + + if (measureTextWidth(line.join(" ")) > width && line.length > 1) { + line.pop(); + tspan.text(line.join(" ")); + line = [word]; + tspan = text.append("tspan") + .attr("x", 0) + .attr("y", y) + .attr("dy", ++lineNumber * lineHeight + dy + "em") + .text(word); + } + } + } + + // 调整标签位置以保持居中 + if (lineNumber > 0) { + text.selectAll("tspan").attr("y", parseFloat(y) + 5); + } + } + + // 左侧的Y轴 + chart.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(-innerWidth) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + ) + .call(g => { + g.select(".domain").remove(); + g.selectAll(".tick line") + .attr("stroke", "#e0e0e0") + .attr("stroke-dasharray", "2,2"); + g.selectAll(".tick text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + }); + + // ---------- 10. 绘制图例 ---------- + // 图例 + const legendData = [ + { key: leftBarGroup, color: colorResolver.field(leftBarGroup, 0, { fallback: "#154360" }).value }, + { key: rightBarGroup, color: colorResolver.field(rightBarGroup, 0, { fallback: "#3498DB" }).value } + ]; + + const legendPadding = 20; + const legendItems = legendData.map(item => ({ + label: item.key.toString().replace(" Sales", ""), + color: item.color, + })); + chartUtils.legend.centered(svg, legendItems, {}, width / 2 + (legendPadding + 40) / 2, 80, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: legendPadding, + fontSize: 12, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + + // ---------- 11. 绘制条形图 ---------- + // 为每个x类别创建一个组 + const xGroups = chart.selectAll(".x-group") + .data(xValues) + .enter() + .append("g") + .attr("class", "x-group") + .attr("transform", d => `translate(${xScale(d)}, 0)`); + + // 绘制条形图 + xValues.forEach(xValue => { + // 获取当前x类别的数据 + const xData = useData.filter(d => d[xField] === xValue); + + // 获取左侧柱子的数据（2011年销售额） + const leftBarData = xData.find(d => d[groupField] === leftBarGroup); + + // 获取右侧柱子的数据（2012年销售额） + const rightBarData = xData.find(d => d[groupField] === rightBarGroup); + + // 计算百分比变化 + let percentValue = 0; + if (leftBarData && rightBarData) { + const leftValue = leftBarData[yField]; + const rightValue = rightBarData[yField]; + + // 计算百分比变化：(新值-旧值)/旧值 * 100 + if (leftValue !== 0) { + percentValue = Math.round(((rightValue - leftValue) / leftValue) * 100); + } + } + + // 计算左侧柱子的位置和高度 + if (leftBarData) { + const barHeight = innerHeight - yScale(leftBarData[yField]); + chart.append("rect") + .attr("class", "bar left-bar") + .attr("x", xScale(xValue)) + .attr("y", yScale(leftBarData[yField])) + .attr("width", groupScale.bandwidth()) + .attr("height", barHeight) + .attr("fill", colorResolver.field(leftBarGroup, 0, { fallback: "#154360" }).value) + .attr("rx", variables.has_rounded_corners ? 2 : 0) + .attr("ry", variables.has_rounded_corners ? 2 : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + } + + // 计算右侧柱子的位置和高度 + if (rightBarData) { + const barHeight = innerHeight - yScale(rightBarData[yField]); + chart.append("rect") + .attr("class", "bar right-bar") + .attr("x", xScale(xValue) + groupScale.bandwidth() + (xScale.bandwidth() - 2 * groupScale.bandwidth()) / 2) + .attr("y", yScale(rightBarData[yField])) + .attr("width", groupScale.bandwidth()) + .attr("height", barHeight) + .attr("fill", colorResolver.field(rightBarGroup, 0, { fallback: "#3498DB" }).value) + .attr("rx", variables.has_rounded_corners ? 2 : 0) + .attr("ry", variables.has_rounded_corners ? 2 : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + } + + // 绘制百分比变化指示器 + if (leftBarData && rightBarData) { + const percentText = percentValue <= 0 ? `${percentValue}%` : `+${percentValue}%`; + const percentColor = colorResolver.other("percentage_indicator", { fallback: "#C0392B" }).value; + + // 计算两个柱子的中心位置，确保三角形指向正确位置 + const leftBarCenter = xScale(xValue) + groupScale.bandwidth() / 2; + const rightBarCenter = xScale(xValue) + groupScale.bandwidth() + (xScale.bandwidth() - 2 * groupScale.bandwidth()) / 2 + groupScale.bandwidth() / 2; + const centerBetweenBars = (leftBarCenter + rightBarCenter) / 2; + + // 创建指示器组，用于放置矩形和三角形 + const indicatorGroup = chart.append("g") + .attr("class", "percent-indicator") + .attr("transform", `translate(${centerBetweenBars}, 0)`); + + // 计算百分比指示器的位置 + const indicatorWidth = Math.min(2 * groupScale.bandwidth(),40); // 指示器宽度 + const indicatorHeight = indicatorWidth / 2; // 指示器高度 + const triangleHeight = indicatorHeight * 0.8; // 三角形高度 + + // 计算百分比文本的宽度和适当的字体大小 + const percentFontSize = calculateFontSize(percentText, indicatorWidth - 4, 14); + + // 如果是左侧柱子和右侧柱子中较高的那个的顶部位置 + const maxBarHeight = Math.max( + leftBarData ? leftBarData[yField] : 0, + rightBarData ? rightBarData[yField] : 0 + ); + const indicatorY = yScale(maxBarHeight) - indicatorHeight - triangleHeight - 5; + + // 绘制百分比背景矩形 + indicatorGroup.append("rect") + .attr("x", -indicatorWidth / 2) + .attr("y", indicatorY) + .attr("width", indicatorWidth) + .attr("height", indicatorHeight) + .attr("fill", percentColor) + .attr("rx", 2) + .attr("ry", 2); + + // 绘制百分比三角形，确保指向两个柱子的中间 + indicatorGroup.append("path") + .attr("d", `M${-triangleHeight},${indicatorY + indicatorHeight} L${triangleHeight},${indicatorY + indicatorHeight} L0,${indicatorY + indicatorHeight + triangleHeight} Z`) + .attr("fill", percentColor); + + // 绘制百分比文本，并使用计算出的动态字体大小 + indicatorGroup.append("text") + .attr("x", 0) + .attr("y", indicatorY + indicatorHeight / 2 + 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${percentFontSize}px`) + .style("font-weight", "bold") + .style("fill", "white") + .text(percentText); + } + }); + // 添加x轴处的长黑横线 + chart.append("line") + .attr("x1", 0) + .attr("y1", innerHeight) + .attr("x2", innerWidth) + .attr("y2", innerHeight) + .attr("stroke", "black") + .attr("stroke-width", 2); + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_6.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_6.js new file mode 100644 index 0000000000000000000000000000000000000000..5800faac32b56ad9be94522fe51aded9f9d7d1bd --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_6.js @@ -0,0 +1,744 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_6", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直分组条形图实现 - 带有图标和数值标签 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 如果不存在，添加副标题字段 + typography.subtitle = typography.subtitle || typography.description; + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清除容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 500; + + // 边距：上，右，下，左 + const margin = { + top: 100, // 标题和标签的空间 + right: 30, // 右侧标签的空间 + bottom: 80, // x轴和标签的空间 + left: 30 // y轴和标签的空间 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, groupField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + + xField = xChannel.key; + yField = yChannel.key; + groupField = groupChannel.key; + + // 获取字段单位 + xUnit = xChannel.unit; + yUnit = yChannel.unit; + + // ---------- 4. 数据处理 ---------- + // 使用提供的数据 + let useData = chartData; + + // 获取x轴和分组的唯一值 + const xValues = [...new Set(useData.map(d => d[xField]))]; + let groupValues = [...new Set(useData.map(d => d[groupField]))]; + + // 如果组的数量不符合要求，给出警告 + if (groupValues.length !== 2) { + console.warn("此图表需要恰好2个组字段"); + } + + // 第一个组是左侧柱子，第二个组是右侧柱子 + const leftBarGroup = groupValues[0]; + const rightBarGroup = groupValues[1]; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8. 创建比例尺 ---------- + // X比例尺（分类）用于主分类 + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.2); + + // 分组比例尺，用于每个类别内的细分 + const groupScale = d3.scaleBand() + .domain([0, 1]) // 只有两个柱子，左侧和右侧 + .range([0, xScale.bandwidth()]) + .padding(0.2); // 同一维度柱子之间的间隙，增加间隔 + + // Y比例尺（数值）- 直接使用最大值映射到可用高度 + const dataMax = d3.max(useData, d => +d[yField]) || 100; + const yScale = d3.scaleLinear() + .domain([0, dataMax]) + .range([innerHeight, 0]); + + // ---------- 9. 文本宽度计算和字体大小调整 (移动到这里，在绘制坐标轴之前) ---------- + // 数值标签的可用宽度 = bar宽度 + 间距 + const barWidth = groupScale.bandwidth(); + const valueSpacing = xScale.bandwidth() * 0.1; + const valueLabelAvailableWidth = barWidth; // 每个值标签只能占据其柱子的宽度 + + // 维度标签的可用宽度 = 两个bar宽度 + bar间距 + const dimensionLabelAvailableWidth = xScale.bandwidth(); + + // 计算最长的数值标签和维度标签 + let maxValueLabelWidth = 0; + let maxDimensionLabelWidth = 0; + + // 计算所有数值标签的最大宽度 + useData.forEach(d => { + const textWidth = chartUtils.text.measure(svg, chartUtils.format.autoText(+d[yField]) + (yUnit ? ` ${yUnit}` : ''), { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxValueLabelWidth = Math.max(maxValueLabelWidth, textWidth); + }); + + // 计算所有维度标签的最大宽度 + xValues.forEach(xValue => { + const textWidth = chartUtils.text.measure(svg, xValue, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxDimensionLabelWidth = Math.max(maxDimensionLabelWidth, textWidth); + }); + + // 计算需要的字体缩放比例 + const valueFontScale = Math.min(1, valueLabelAvailableWidth / maxValueLabelWidth); + const dimensionFontScale = Math.min(1, dimensionLabelAvailableWidth / maxDimensionLabelWidth); + + // 计算实际使用的字体大小 + const valueFontSize = Math.max(8, parseInt(typography.label.font_size) * valueFontScale); // 最小字体8px + const dimensionFontSize = Math.max(8, parseInt(typography.label.font_size) * dimensionFontScale); + + // 计算动态文本大小的函数 + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + // 否则，按比例缩小字体大小 + return Math.max(10, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + // ---------- 10. 创建坐标轴 (原来的第9步) ---------- + // 底部的X轴（仅一条长线） + chart.append("line") + .attr("x1", 0) + .attr("y1", innerHeight) + .attr("x2", innerWidth) + .attr("y2", innerHeight) + .attr("stroke", "black") + .attr("stroke-width", 2); + + // 创建x轴组，用于添加刻度标签 + const xAxisGroup = chart.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`); + + // 第一步：找出最长的标签并计算统一的字体大小 + let maxLabelLength = 0; + const allLabels = xValues.map(d => d.toString()); + + // 找出最长的标签 + const longestLabel = allLabels.reduce((a, b) => a.length > b.length ? a : b, ""); + + // 使用最长标签计算合适的统一字体大小 + const labelMaxWidth = xScale.bandwidth()*1.3; + const uniformFontSize = calculateFontSize(longestLabel, labelMaxWidth, parseInt(typography.label.font_size)); + + // 绘制x轴标签 + xAxisGroup.selectAll(".x-label") + .data(xValues) + .enter() + .append("text") + .attr("class", "x-label") + .attr("x", d => xScale(d) + xScale.bandwidth() / 2) + .attr("y", 20) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${uniformFontSize}px`) // 应用统一的字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => d) + .each(function(d) { + const text = d3.select(this); + const labelText = d.toString(); + const labelWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: uniformFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 检查使用统一字体大小后，文本是否仍然超过可用宽度 + if (labelWidth > labelMaxWidth) { + // 如果仍然太长，应用文本换行 + wrapText(text, labelText, labelMaxWidth, 1.1); + } + }); + + // 文本换行助手函数 + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + + // 先清空文本 + text.text(null); + + // 处理文本 + let tspans = []; + + // 如果没有空格可分割，按字符分割 + if (words.length <= 1) { + const chars = str.split(''); + let currentLine = ''; + + for (let i = 0; i < chars.length; i++) { + currentLine += chars[i]; + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine, { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 当前行过长，回退一个字符并换行 + currentLine = currentLine.slice(0, -1); + + // 添加到tspans数组 + tspans.push(currentLine); + + // 重新开始下一行 + currentLine = chars[i]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } else { + // 处理有空格的文本 + let currentLine = []; + + while (word = words.pop()) { + currentLine.push(word); + + // 测量候选文本宽度 + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + // 回退一个词 + currentLine.pop(); + + // 添加到tspans数组 + tspans.push(currentLine.join(" ")); + + // 重新开始下一行 + currentLine = [word]; + lineNumber++; + } + } + + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } + + // 计算总行数 + const totalLines = tspans.length; + + // 计算垂直居中的起始位置 + // 对于单行文本，y位置保持不变 + // 对于多行文本，需要向上偏移以保持垂直居中 + let startY = y; + if (totalLines > 1) { + // 向上偏移半行距离 * (总行数-1) + startY = parseFloat(y) - (lineHeight * (totalLines - 1) / 2); + } + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + text.append("tspan") + .attr("x", text.attr("x")) + .attr("y", startY) + .attr("dy", `${i * lineHeight}em`) + .text(lineText); + }); + } + + // ---------- 11. 绘制图例 (原来的第10步) ---------- + // 创建临时文本元素计算文本宽度 + const legendItems = legendData.map(item => ({ + label: item.key, + color: item.color, + })); + chartUtils.legend.centered(svg, legendItems, {}, width / 2, 30, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: legendSpacing, + fontSize: 12, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + + // 找出所有数据中的最大值，用于定位图标 + const globalMaxHeight = d3.max(useData, d => +d[yField]); + + // 计算圆形半径 - 应为柱子宽度的60% + const circleRadius = barWidth * 0.6; + + // ---- 计算标签禁区逻辑开始 ---- + // 首先收集所有数值标签的位置信息 + const labelForbiddenZones = []; + + // 计算标签高度 (估算值，基于字体大小) + const labelHeight = valueFontSize * 1.2; // 比字体大小高20% + + // 收集所有柱子顶部标签的位置信息和柱子底部位置 + let lowestBarBottom = 0; // 用于记录所有柱子中的最低点（底部） + + xValues.forEach(xValue => { + // 获取当前x类别的数据 + const xData = useData.filter(d => d[xField] === xValue); + + // 收集左侧柱子标签信息 + const leftBarData = xData.find(d => d[groupField] === leftBarGroup); + if (leftBarData) { + const leftValue = leftBarData[yField]; + const leftBarY = yScale(leftValue); + const leftBarBottom = innerHeight; // 柱子底部固定在x轴上 + + // 更新最低的柱子底部位置 + lowestBarBottom = Math.max(lowestBarBottom, leftBarBottom); + + // 计算标签上下边界（顶部标签在柱子上方10px处） + const labelTop = leftBarY - 5 - labelHeight/2; + const labelBottom = leftBarY - 5 + labelHeight/2; + + // 添加到禁区列表 + labelForbiddenZones.push({top: labelTop, bottom: labelBottom}); + } + + // 收集右侧柱子标签信息 + const rightBarData = xData.find(d => d[groupField] === rightBarGroup); + if (rightBarData) { + const rightValue = rightBarData[yField]; + const rightBarY = yScale(rightValue); + const rightBarBottom = innerHeight; // 柱子底部固定在x轴上 + + // 更新最低的柱子底部位置 + lowestBarBottom = Math.max(lowestBarBottom, rightBarBottom); + + // 计算标签上下边界 + const labelTop = rightBarY - 5 - labelHeight/2; + const labelBottom = rightBarY - 5 + labelHeight/2; + + // 添加到禁区列表 + labelForbiddenZones.push({top: labelTop, bottom: labelBottom}); + } + }); + + // 计算初始图标位置（仍基于全局最高柱子的四分之一处） + const initialIconYPosition = yScale(globalMaxHeight * 0.25); + + // 图标需要的垂直空间（上下各留出圆形半径的距离） + const iconRadius = circleRadius; // 简化命名 + + // 计算图标完整空间的上下边界 + const iconTopInitial = initialIconYPosition - iconRadius; + const iconBottomInitial = initialIconYPosition + iconRadius; + + // 检查初始位置是否与任何标签禁区重叠或超出柱子底部 + let hasOverlap = false; + for (const zone of labelForbiddenZones) { + // 检查圆形与标签是否有重叠 + if (!(iconBottomInitial < zone.top || iconTopInitial > zone.bottom)) { + hasOverlap = true; + break; + } + } + + // 也检查是否超出柱子底部 + if (iconBottomInitial > lowestBarBottom) { + hasOverlap = true; + } + + // 如果有重叠，搜索新位置 + let globalIconYPosition = initialIconYPosition; + + if (hasOverlap) { + // 定义最小搜索步长（像素） + const stepSize = 5; + // 最大尝试次数，避免无限循环 + const maxTries = 100; + + let foundUp = false; + let foundDown = false; + let upY = initialIconYPosition; + let downY = initialIconYPosition; + let bestUpPosition = null; + let bestDownPosition = null; + let upDistance = Infinity; + let downDistance = Infinity; + + // 同时向上和向下搜索，记录找到的最近有效位置 + for (let i = 0; i < maxTries && (!foundUp || !foundDown); i++) { + // 向上搜索（如果还没找到向上的有效位置） + if (!foundUp) { + upY -= stepSize; + // 注意：不检查是否超出图表顶部，允许图标位于任意高度 + + let overlapUp = false; + // 检查与标签的重叠 + for (const zone of labelForbiddenZones) { + if (!((upY + iconRadius) < zone.top || (upY - iconRadius) > zone.bottom)) { + overlapUp = true; + break; + } + } + + // 检查是否超出柱子底部 + if ((upY + iconRadius) > lowestBarBottom) { + overlapUp = true; + } + + if (!overlapUp) { + foundUp = true; + bestUpPosition = upY; + upDistance = Math.abs(upY - initialIconYPosition); + } + } + + // 向下搜索（如果还没找到向下的有效位置） + if (!foundDown) { + downY += stepSize; + + // 检查是否超出柱子底部，这是硬性限制 + if ((downY + iconRadius) > lowestBarBottom) { + // 向下搜索已经触及底部限制，不再继续 + foundDown = true; // 标记为已找到，但实际上是放弃 + } else { + let overlapDown = false; + // 检查与标签的重叠 + for (const zone of labelForbiddenZones) { + if (!((downY + iconRadius) < zone.top || (downY - iconRadius) > zone.bottom)) { + overlapDown = true; + break; + } + } + + if (!overlapDown) { + foundDown = true; + bestDownPosition = downY; + downDistance = Math.abs(downY - initialIconYPosition); + } + } + } + } + + // 判断哪个方向找到的位置更接近初始位置 + if (foundUp && foundDown && bestUpPosition !== null && bestDownPosition !== null) { + // 两个方向都找到了有效位置，选择距离初始位置最近的 + if (upDistance <= downDistance) { + globalIconYPosition = bestUpPosition; + } else { + globalIconYPosition = bestDownPosition; + } + } else if (foundUp && bestUpPosition !== null) { + // 只有向上找到有效位置 + globalIconYPosition = bestUpPosition; + } else if (foundDown && bestDownPosition !== null) { + // 只有向下找到有效位置 + globalIconYPosition = bestDownPosition; + } else { + // 如果实在找不到合适位置，放在柱子底部上方的安全位置 + const safePosition = lowestBarBottom - iconRadius - 5; + globalIconYPosition = safePosition; + } + } + // ---- 计算标签禁区逻辑结束 ---- + + // 绘制条形图和标签 + xValues.forEach(xValue => { + // 获取当前x类别的数据 + const xData = useData.filter(d => d[xField] === xValue); + + // 获取左侧柱子的数据 + const leftBarData = xData.find(d => d[groupField] === leftBarGroup); + + // 获取右侧柱子的数据 + const rightBarData = xData.find(d => d[groupField] === rightBarGroup); + + // 计算左侧柱子的位置和高度 + const leftBarX = xScale(xValue); + let leftBarY, leftBarHeight, leftValue; + + if (leftBarData) { + leftValue = leftBarData[yField]; + leftBarHeight = innerHeight - yScale(leftValue); + leftBarY = yScale(leftValue); + + // 绘制左侧柱子 + chart.append("rect") + .attr("class", "bar left-bar") + .attr("x", leftBarX) + .attr("y", leftBarY) + .attr("width", barWidth) + .attr("height", leftBarHeight) + .attr("fill", colorResolver.field(leftBarGroup, 0, { fallback: "#4269d0" }).value) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 绘制左侧柱子顶部的标签 + // 首先计算标签文本宽度并调整字体大小 + const leftValueText = chartUtils.format.autoText(leftValue) + (yUnit ? ` ${yUnit}` : ''); + let leftLabelFontSize = valueFontSize; // 默认使用之前计算的字体大小 + + let leftTextWidth = chartUtils.text.measure(chart, leftValueText, { + fontFamily: typography.label.font_family, + fontSize: `${leftLabelFontSize}px`, + fontWeight: "bold" + }).width; + // 最大允许宽度为柱子宽度的1.1倍 + const maxLabelWidth = barWidth * 1.1; + + // 如果文本宽度超过允许值，动态缩小字体 + if (leftTextWidth > maxLabelWidth) { + // 按比例计算新字体大小 + leftLabelFontSize = Math.max(4, leftLabelFontSize * (maxLabelWidth / leftTextWidth)); + leftTextWidth = chartUtils.text.measure(chart, leftValueText, { + fontFamily: typography.label.font_family, + fontSize: `${leftLabelFontSize}px`, + fontWeight: "bold" + }).width; + } + + // 使用调整后的字体大小绘制标签 + chart.append("text") + .attr("class", "bar-label") + .attr("x", leftBarX + barWidth / 2) + .attr("y", leftBarY - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${leftLabelFontSize}px`) // 使用动态调整的字体大小 + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(leftValueText); + } + + // 计算右侧柱子的位置和高度 + // 使用groupScale正确计算右侧柱子的位置，确保两个柱子之间有间距 + const rightBarX = leftBarX + barWidth + xScale.bandwidth() * 0.1; // 添加额外间距为柱子宽度的10% + let rightBarY, rightBarHeight, rightValue; + + if (rightBarData) { + rightValue = rightBarData[yField]; + rightBarHeight = innerHeight - yScale(rightValue); + rightBarY = yScale(rightValue); + + // 绘制右侧柱子 + chart.append("rect") + .attr("class", "bar right-bar") + .attr("x", rightBarX) + .attr("y", rightBarY) + .attr("width", barWidth) + .attr("height", rightBarHeight) + .attr("fill", colorResolver.field(rightBarGroup, 0, { fallback: "#ff725c" }).value) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 绘制右侧柱子顶部的标签 + // 首先计算标签文本宽度并调整字体大小 + const rightValueText = chartUtils.format.autoText(rightValue) + (yUnit ? ` ${yUnit}` : ''); + let rightLabelFontSize = valueFontSize; // 默认使用之前计算的字体大小 + + let rightTextWidth = chartUtils.text.measure(chart, rightValueText, { + fontFamily: typography.label.font_family, + fontSize: `${rightLabelFontSize}px`, + fontWeight: "bold" + }).width; + // 最大允许宽度为柱子宽度的1.1倍 + const rightMaxLabelWidth = barWidth * 1.1; + + // 如果文本宽度超过允许值，动态缩小字体 + if (rightTextWidth > rightMaxLabelWidth) { + // 按比例计算新字体大小 + rightLabelFontSize = Math.max(4, rightLabelFontSize * (rightMaxLabelWidth / rightTextWidth)); + rightTextWidth = chartUtils.text.measure(chart, rightValueText, { + fontFamily: typography.label.font_family, + fontSize: `${rightLabelFontSize}px`, + fontWeight: "bold" + }).width; + } + + // 使用调整后的字体大小绘制标签 + chart.append("text") + .attr("class", "bar-label") + .attr("x", rightBarX + barWidth / 2) + .attr("y", rightBarY - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${rightLabelFontSize}px`) // 使用动态调整的字体大小 + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(rightValueText); + } + + // 计算圆圈的位置 - 确保在两个柱子的中间 + const circleX = leftBarX + barWidth + (xScale.bandwidth() * 0.1) / 2; + + // 绘制白色圆圈背景 + chart.append("circle") + .attr("class", "icon-circle") + .attr("cx", circleX) + .attr("cy", globalIconYPosition) + .attr("r", circleRadius) + .attr("fill", "white") + .attr("stroke", "#ddd") + .attr("stroke-width", 1) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 绘制图标 - 直接使用图片URL而不使用clip-path + if (images.field && images.field[xValue]) { + const iconSize = circleRadius * 1.5; // 图标略大于圆形，确保填满 + chart.append("image") + .attr("class", "category-icon") + .attr("x", circleX - iconSize/2) + .attr("y", globalIconYPosition - iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[xValue]); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_7.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_7.js new file mode 100644 index 0000000000000000000000000000000000000000..8a6e4065ee664f15db44f1d5337c863da27a5fdb --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_7.js @@ -0,0 +1,546 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_7", + "is_composite": false, + "required_fields": ["x", "y", "group", "group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"], ["categorical"]], + "required_fields_range": [ + [2, 20], + [0, "inf"], + [2, 2], + [2, 2] + ], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 垂直分组叠加（模式覆盖）条形图实现 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "10px", font_weight: "normal" } // Smaller annotation for labels + }; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, // Colors for group1 (e.g., Year) should be here + other: {} + }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : true; // Default spacing to true + + // 创建用于文本测量的Canvas Context + const canvas = document.createElement('canvas'); + const context = canvas.getContext('2d'); + + // 清除容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + const width = variables.width || 800; + const height = variables.height || 500; + + const margin = { + top: 90, // 为顶部标签留出空间 + right: 40, + bottom: 100, // x轴标签空间 + left: 40 + }; + + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + let xField, yField, group1Field, group2Field; + let yUnit = ""; + + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + + + + + xField = xChannel.key; + yField = yChannel.key; + group1Field = chartUtils.schema.channel(jsonData, "group").key; + group2Field = chartUtils.schema.channel(jsonData, "group2").key; + if (yChannel.unit) { + yUnit = yChannel.unit; // 通常是 '%' + } + + // ---------- 4. 数据处理与重组 ---------- + const xValues = [...new Set(chartData.map(d => d[xField]))]; + const group1Values = [...new Set(chartData.map(d => d[group1Field]))]; + const group2Values = [...new Set(chartData.map(d => d[group2Field]))]; // 指标名称 ("Answered", "Thereof correct") + + if (group2Values.length !== 2) { + console.error(`Expected exactly 2 unique values for the second group field ('${group2Field}'), but found ${group2Values.length}.`); + d3.select(containerSelector).append("p").text(`Error: Need exactly 2 metrics in '${group2Field}'.`); + return; + } + // 假定第一个group2值是主指标(如"Answered")，第二个是次指标(如"Thereof correct") + const primaryMetricName = group2Values[0]; + const secondaryMetricName = group2Values[1]; + + const processedData = {}; // 结构: { xValue: { group1Value: { primaryValue: y, secondaryRate: y, overlayValue: y_calc }, ... }, ... } + + chartData.forEach(d => { + const xVal = d[xField]; + const g1Val = d[group1Field]; + const g2Val = d[group2Field]; + const yVal = +d[yField] || 0; // Ensure numerical, default to 0 + + if (!processedData[xVal]) { + processedData[xVal] = {}; + } + if (!processedData[xVal][g1Val]) { + processedData[xVal][g1Val] = { primaryValue: 0, secondaryRate: 0, overlayValue: 0 }; + } + + if (g2Val === primaryMetricName) { + processedData[xVal][g1Val].primaryValue = yVal; + } else if (g2Val === secondaryMetricName) { + processedData[xVal][g1Val].secondaryRate = yVal; + } + }); + + // 计算 overlayValue + Object.values(processedData).forEach(xGroup => { + Object.values(xGroup).forEach(groupData => { + // Overlay height = primaryValue * (secondaryRate / 100) + // Assumes both are percentages 0-100 + groupData.overlayValue = groupData.primaryValue * (groupData.secondaryRate / 100); + }); + }); + + + // ---------- 5. 创建SVG容器和Defs ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + + // 创建斜线模式 + const patternSize = 8; + const pattern = defs.append("pattern") + .attr("id", "diagonal-stripe-pattern") + .attr("patternUnits", "userSpaceOnUse") + .attr("width", patternSize) + .attr("height", patternSize) + .attr("patternTransform", "rotate(-45)"); // *** 保持: 旋转方向-45度 *** + + // *** 修改: 图案背景透明，线条变细、变深 *** + pattern.append("rect") + .attr("width", patternSize) + .attr("height", patternSize) + .attr("fill", "none"); // 透明背景 + + pattern.append("line") + .attr("x1", 0) + .attr("y1", patternSize / 2) + .attr("x2", patternSize) + .attr("y2", patternSize / 2) + .attr("stroke", "#FFFFFF") // *** 修改: 斜线改回白色 *** + .attr("stroke-width", 1.5); // 线条变细 + + + // ---------- 6. 创建比例尺和颜色 ---------- + // X主分类比例尺 + const xScale = d3.scaleBand() + .domain(xValues) + .range([0, innerWidth]) + .padding(0.25); // 主分组之间的间距 + + // X子分类比例尺 (e.g., Year) + const group1Scale = d3.scaleBand() + .domain(group1Values) + .range([0, xScale.bandwidth()]) + .padding(variables.has_spacing ? 0.1 : 0.05); // 组内条形之间的间距 + + // Y比例尺 (基于主指标的最大值) + const yMax = d3.max(chartData, d => (d[group2Field] === primaryMetricName) ? (+d[yField] || 0) : 0) * 1.1 || 100; + const yScale = d3.scaleLinear() + .domain([0, yMax]) + .range([innerHeight, 0]) + .nice(); // 使坐标轴刻度更友好 + + // 颜色比例尺 (基于第一个分组 - Year) + const colorScale = colorResolver.scale(group1Values, { palette: "category10" }); // 提供备用颜色 + + // ---------- 7. 文本宽度计算函数 ---------- + function measureTextWidth(text, fontSize, fontWeight, fontFamily) { + return chartUtils.text.measure(null, text, { fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight }).width; + } + + // *** 添加: 文本换行辅助函数 *** + function wrapText(textElement, text, width, x, y, fontSize, fontWeight, fontFamily) { + textElement.each(function() { // Use normal function for 'this' + let words = String(text).split(/\s+/).reverse(), // Ensure text is string + word, + line = [], + lineNumber = 0, + lineHeight = 1.1, // ems + tspan = d3.select(this).text(null).append("tspan").attr("x", x).attr("y", y), // Use d3.select(this) + dy = 0; // Initial dy for first line + + // Check total estimated width first using precise measurement + if (measureTextWidth(text, fontSize, fontWeight, fontFamily) <= width) { + tspan.text(text); + return; // No wrapping needed + } + + // Try to wrap (limit to max 2 lines for simplicity here) + let lines = []; + let currentLine = ""; + while (word = words.pop()) { + line.push(word); + currentLine = line.join(" "); + // Use precise measurement for wrapping check + if (measureTextWidth(currentLine, fontSize, fontWeight, fontFamily) > width && line.length > 1) { + line.pop(); + lines.push(line.join(" ")); + line = [word]; + if (lines.length >= 1) { // Stop after creating the first line break potential + line = [word].concat(words.reverse()); // Put remaining words on the second line + break; + } + } + } + lines.push(line.join(" ")); // Add the last or only line + + // Render the lines (max 2) + lines.slice(0, 2).forEach((lineText, i) => { + if (i > 0) dy = lineHeight; + // Remove previous tspan content if it exists and we are adding the first real line + if (i === 0) d3.select(this).selectAll("tspan").remove(); + tspan = d3.select(this).append("tspan") // Append subsequent tspans + .attr("x", x) + .attr("y", y) // Y is same, dy handles vertical shift + .attr("dy", `${dy}em`) + .text(lineText); + }); + }); + } + + // ---------- 8. 创建主图表组 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8.5 添加图例 ---------- + const legendY = margin.top / 4 * 3; + const legendSquareSize = 12; + const swatchPath = size => [ + `M0,0 L${size},0 L0,${size} Z`, + `M${size},${size} L0,${size} L${size},0 Z`, + ]; + chartUtils.legend.segmentsCentered(svg, [ + { type: "path", size: legendSquareSize, d: swatchPath(legendSquareSize)[0], color: legendG1Color1, transform: `translate(0, ${-legendSquareSize / 2})` }, + { type: "path", size: 0, d: swatchPath(legendSquareSize)[1], color: legendG1Color2, transform: `translate(0, ${-legendSquareSize / 2})` }, + { type: "text", label: primaryMetricName }, + { type: "path", size: legendSquareSize, d: swatchPath(legendSquareSize)[0], color: legendG1Color1, transform: `translate(0, ${-legendSquareSize / 2})` }, + { type: "path", size: 0, d: swatchPath(legendSquareSize)[1], color: legendG1Color2, transform: `translate(0, ${-legendSquareSize / 2})` }, + { type: "text", label: secondaryMetricName }, + ], { + centerX: margin.left + innerWidth / 2, + y: legendY, + itemGap: legendItemPadding, + sectionGap: legendPadding, + fontSize: legendFontSize, + fontFamily: legendFontFamily, + fontWeight: legendFontWeight, + textColor: colorResolver.text({ fallback: "#000000" }).value, + }); + // ---------- 9. 绘制条形和覆盖层 ---------- + const barGroups = chart.selectAll(".bar-group") + .data(xValues) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d)}, 0)`); + + barGroups.each(function(xValue) { // 使用普通函数获取 'this' + const groupG = d3.select(this); + + group1Values.forEach(group1Value => { + const groupData = processedData[xValue]?.[group1Value]; + if (!groupData) return; // 跳过没有数据的分组 + + const barX = group1Scale(group1Value); + const barWidth = group1Scale.bandwidth(); + const barColor = colorScale(group1Value); + + // 主条形 (代表 primaryValue) + const primaryY = yScale(groupData.primaryValue); + const primaryHeight = innerHeight - primaryY; + + if (primaryHeight > 0) { + groupG.append("rect") + .attr("class", "main-bar") + .attr("x", barX) + .attr("y", primaryY) + .attr("width", barWidth) + .attr("height", primaryHeight) + .attr("fill", barColor) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0); + } + + // 覆盖层 (代表 overlayValue) + const overlayY = yScale(groupData.overlayValue); + const overlayHeight = innerHeight - overlayY; + + if (overlayHeight > 0) { + // 先绘制一个相同颜色的底，防止图案在空白处绘制 + groupG.append("rect") + .attr("class", "overlay-base") + .attr("x", barX) + .attr("y", overlayY) + .attr("width", barWidth) + .attr("height", overlayHeight) + .attr("fill", barColor) + .attr("rx", variables.has_rounded_corners ? 3 : 0) // 确保圆角匹配 + .attr("ry", variables.has_rounded_corners ? 3 : 0); + // 再绘制图案层 + groupG.append("rect") + .attr("class", "overlay-pattern") + .attr("x", barX) + .attr("y", overlayY) + .attr("width", barWidth) + .attr("height", overlayHeight) + .attr("fill", "url(#diagonal-stripe-pattern)") + .attr("rx", variables.has_rounded_corners ? 3 : 0) // 确保圆角匹配 + .attr("ry", variables.has_rounded_corners ? 3 : 0); + } + }); + }); + + // ---------- 10. 绘制标签 ---------- + // 预计算标签字体大小 + const baseFontSizeLabel = parseFloat(typography.label.font_size) || 12; // For Group1 labels + const baseFontSizeAnnotation = parseFloat(typography.annotation.font_size) || 10; + const minFontSize = 4; + let minPrimaryLabelRatio = 1.0; + let minSecondaryLabelRatio = 1.0; + const maxLabelWidth = group1Scale.bandwidth() * 1.1; // 允许稍微超出条形 for value labels + // *** 添加: Group1标签的宽度限制和最小比例 *** + const maxGroup1LabelWidth = group1Scale.bandwidth(); // Group1标签严格限制在bar宽度内 + let minGroup1LabelRatio = 1.0; + + // 预计算缩放比例 + xValues.forEach(xValue => { + group1Values.forEach(group1Value => { + const groupData = processedData[xValue]?.[group1Value]; + if (!groupData) return; + + // 主指标标签 + const primaryText = chartUtils.format.autoText(groupData.primaryValue) + (yUnit ? ` ${yUnit}` : ''); + let width = measureTextWidth(primaryText, baseFontSizeAnnotation, typography.annotation.font_weight, typography.annotation.font_family); + if (width > maxLabelWidth) { + minPrimaryLabelRatio = Math.min(minPrimaryLabelRatio, maxLabelWidth / width); + } + + // 次指标标签 (Rate) + const secondaryText = chartUtils.format.autoText(groupData.secondaryRate) + (yUnit ? ` ${yUnit}` : ''); + width = measureTextWidth(secondaryText, baseFontSizeAnnotation, typography.annotation.font_weight, typography.annotation.font_family); + if (width > maxLabelWidth) { // 也应用宽度限制 + minSecondaryLabelRatio = Math.min(minSecondaryLabelRatio, maxLabelWidth / width); + } + + // *** 添加: Group1标签宽度预计算 *** + const group1Text = String(group1Value); + width = measureTextWidth(group1Text, baseFontSizeLabel, typography.label.font_weight, typography.label.font_family); + if (width > maxGroup1LabelWidth) { + minGroup1LabelRatio = Math.min(minGroup1LabelRatio, maxGroup1LabelWidth / width); + } + }); + }); + + const finalPrimaryFontSize = Math.max(minFontSize, baseFontSizeAnnotation * minPrimaryLabelRatio); + const finalSecondaryFontSize = Math.max(minFontSize, baseFontSizeAnnotation * minSecondaryLabelRatio); + // *** 添加: 计算最终 Group1 标签字体大小 *** + const finalGroup1FontSize = Math.max(minFontSize, baseFontSizeLabel * minGroup1LabelRatio); + + // *** 添加: 定义 iconPaddingTop 在循环外部 *** + const iconPaddingTop = 35; // 图标距离Group1标签区的垂直距离 + + // 绘制标签 + barGroups.each(function(xValue) { + const groupG = d3.select(this); + + group1Values.forEach(group1Value => { + const groupData = processedData[xValue]?.[group1Value]; + if (!groupData) return; + + const barX = group1Scale(group1Value); + const barWidth = group1Scale.bandwidth(); + const centerX = barX + barWidth / 2; + const barColor = colorScale(group1Value); + + // 1. 主指标值标签 (条形上方) + const primaryY = yScale(groupData.primaryValue); + if (groupData.primaryValue > 0) { + groupG.append("text") + .attr("class", "primary-label") + .attr("x", centerX) + .attr("y", primaryY - 5) // 在条形上方5px + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${finalPrimaryFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(chartUtils.format.autoText(groupData.primaryValue) + (yUnit ? ` ${yUnit}` : '')); + } + + + // 2. 次指标率标签 (覆盖层上，带背景) + const overlayY = yScale(groupData.overlayValue); + if (groupData.overlayValue > 0 && groupData.secondaryRate > 0) { // 仅当overlay和rate都>0时显示 + const labelHeight = finalSecondaryFontSize * 1.4; // 背景高度略大于字体 + const secondaryRateText = chartUtils.format.fixed(groupData.secondaryRate).text + yUnit; + const labelWidth = measureTextWidth(secondaryRateText, finalSecondaryFontSize, typography.annotation.font_weight, typography.annotation.font_family) + 8; // 背景宽度带内边距 + const labelRectWidth = Math.min(barWidth * 0.9, labelWidth); // 限制文本背景宽度 + // *** 修改: 计算背景矩形的宽度和X坐标 *** + const labelBgWidth = barWidth * 1.05; // 背景比bar稍宽 + const labelBgX = centerX - labelBgWidth / 2; // 水平居中背景 + const labelRectY = overlayY + (innerHeight - overlayY) * 0.2; // 放在覆盖层高度20%的位置 + + // 标签背景矩形 + groupG.append("rect") + .attr("class", "secondary-label-bg") + .attr("x", labelBgX) // 使用计算好的X坐标 + .attr("y", labelRectY - labelHeight / 2) + .attr("width", labelBgWidth) // 使用稍宽的背景宽度 + .attr("height", labelHeight) + // .attr("text-anchor","middle") // 'text-anchor' 无效 for rect + .attr("fill", barColor) // 使用条形颜色做背景 + .attr("rx", 3) + .attr("ry", 3); + + // 标签文本 + groupG.append("text") + .attr("class", "secondary-label") + .attr("x", centerX) + .attr("y", labelRectY) // 文本的Y坐标在矩形中心 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${finalSecondaryFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色文本 + .text(secondaryRateText); + } + + // *** 添加: Group1 标签 (年份等) *** + const group1LabelY = innerHeight + 15; // Y 坐标放在 X 轴下方一点 + const group1Text = String(group1Value); + const group1Label = groupG.append("text") + .attr("class", "group1-label") + .attr("x", centerX) + .attr("y", group1LabelY) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalGroup1FontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 调用 wrapText 处理 Group1 标签的文本和换行 + group1Label.call(wrapText, group1Text, maxGroup1LabelWidth, centerX, group1LabelY, finalGroup1FontSize, typography.label.font_weight, typography.label.font_family); + + }); // 结束 group1Values.forEach + + // *** 添加: X维度图标 *** + const iconUrl = jsonData.images?.field?.[xValue]; + const iconSize = xScale.bandwidth() * 0.6; // 图标大小为X Band宽度的60% + const iconY = innerHeight + iconPaddingTop; // 定位在 group1 标签下方 + + if (iconUrl && iconSize > 10) { // 仅当有URL且图标不太小时绘制 + const iconX = xScale.bandwidth() / 2; // 在主X组的中心 + + groupG.append("image") + .attr("x", iconX - iconSize / 2) + .attr("y", iconY) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", iconUrl) + .attr("preserveAspectRatio", "xMidYMid meet"); + } + + }); // 结束 barGroups.each + + // ---------- 11. 添加分隔线 ---------- + const separatorColor = "#d3d3d3"; // 浅灰色 + const separatorStrokeWidth = 1; + + // 1. Bar底部水平线 + chart.append("line") + .attr("class", "separator-line-bars") + .attr("x1", 0) + .attr("y1", innerHeight) + .attr("x2", innerWidth) + .attr("y2", innerHeight) + .attr("stroke", separatorColor) + .attr("stroke-width", separatorStrokeWidth); + + // 2. Group1标签下方水平线 + const yLine2 = innerHeight + 30; // 定义第二条线的Y坐标 + chart.append("line") + .attr("class", "separator-line-group1") + .attr("x1", 0) + .attr("y1", yLine2) + .attr("x2", innerWidth) + .attr("y2", yLine2) + .attr("stroke", separatorColor) + .attr("stroke-width", separatorStrokeWidth); + + // 3. 图标区域之间的垂直线 + const iconAreaBottomPadding = 10; + const maxIconSize = d3.max(xValues, x => xScale.bandwidth() * 0.6) || 24; // 计算最大可能的图标大小 + const verticalLineStartY = yLine2; + const verticalLineEndY = innerHeight + iconPaddingTop + maxIconSize + iconAreaBottomPadding; // 线的底部在最大图标下方 + + for (let i = 0; i < xValues.length - 1; i++) { + // 计算分隔线的 X 坐标 (两个 band 中间) + const xSeparator = xScale(xValues[i]) + xScale.bandwidth() + xScale.paddingInner() * xScale.step() / 2; + chart.append("line") + .attr("class", "separator-line-vertical") + .attr("x1", xSeparator) + .attr("y1", verticalLineStartY) + .attr("x2", xSeparator) + .attr("y2", verticalLineEndY) + .attr("stroke", separatorColor) + .attr("stroke-width", separatorStrokeWidth); + } + + // ---------- 12. 返回SVG节点 ---------- + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_8.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_8.js new file mode 100644 index 0000000000000000000000000000000000000000..899ad6ed8af81d53e0c570e03510f31d930f081d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_8.js @@ -0,0 +1,414 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Grouped Bar Chart", + "chart_name": "vertical_group_bar_chart_8", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 5], [0, "inf"], [2, 3]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 600, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +/* ───────── 代码主体 ───────── */ +function makeChart(containerSelector, dataJSON) { + + /* ============ 1. 字段检查 ============ */ + const xChannel = chartUtils.schema.channel(dataJSON, "x", { fallbackKey: "" }); + const yChannel = chartUtils.schema.channel(dataJSON, "y", { fallbackKey: "" }); + const groupChannel = chartUtils.schema.channel(dataJSON, "group", { fallbackKey: "" }); + const xField = xChannel.key; + const yField = yChannel.key; + const groupField = groupChannel.key; + const yUnit = yChannel.unit; + if(!xField || !yField || !groupField){ + d3.select(containerSelector).html('
缺少必要字段
'); + return; + } + + const raw = dataJSON.data.data.filter(d=>+d[yField]>0); + if(!raw.length){ + d3.select(containerSelector).html('
无有效数据
'); + return; + } + + /* ============ 2. 尺寸与比例尺 ============ */ + const fullW = dataJSON.variables?.width || 600; + const fullH = dataJSON.variables?.height || 400; + const margin = { top: 80, right: 40, bottom: 80, left: 40 }; // 边距调整，增加底部和顶部空间 + const W = fullW - margin.left - margin.right; // 绘图区域宽度 + const H = fullH - margin.top - margin.bottom; // 绘图区域高度 + const colorResolver = chartUtils.color.resolver(dataJSON); + + // 获取主颜色 + const primaryColor = colorResolver.other("primary", { fallback: "#C13C37" }).value; // 默认为红色 + + // 数据处理 + // 获取所有唯一的x值和group值 + const xValues = Array.from(new Set(raw.map(d => d[xField]))); + const groupValues = Array.from(new Set(raw.map(d => d[groupField]))); + + // 计算每个分组的最大值，用于比例尺 + const maxValue = d3.max(raw, d => +d[yField]); + + // 计算分组间距和条形宽度 + const xGroupScale = d3.scaleBand() + .domain(xValues) + .range([0, W]) + .padding(0.2); + + const xBarScale = d3.scaleBand() + .domain(groupValues) + .range([0, xGroupScale.bandwidth()]) + .padding(0.1); + + // 高度比例尺 + const yScale = d3.scaleLinear() + .domain([0, maxValue]) + .range([H, 50]); + + /* ============ 3. 绘图 ============ */ + d3.select(containerSelector).html(""); // 清空容器 + + // 添加数值格式化函数 + + // 创建 SVG 画布 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") // 宽度占满容器 + .attr("height", fullH) // 高度固定 + .attr("viewBox", `0 0 ${fullW} ${fullH}`) // 设置视窗 + .attr("preserveAspectRatio", "xMidYMid meet") // 保持宽高比 + .style("max-width", "100%") // 最大宽度 + .style("height", "auto") // 高度自适应 + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建阴影效果滤镜 + const defs = svg.append("defs"); + const shadowFilter = defs.append("filter") + .attr("id", "bar-shadow") + .attr("width", "150%") + .attr("height", "150%"); + + // 添加阴影效果 + shadowFilter.append("feDropShadow") + .attr("dx", "2") // 水平偏移 + .attr("dy", "2") // 垂直偏移 + .attr("stdDeviation", "2") // 模糊度 + .attr("flood-color", "rgba(0,0,0,0.3)") // 阴影颜色 + .attr("flood-opacity", "0.4"); // 阴影不透明度 + + // 创建主绘图区域 元素，应用边距 + const g = svg.append("g") + .attr("transform", `translate(${margin.left},${margin.top})`); + + /* ---- 文本和样式设置 ---- */ + // 提取字体排印设置，提供默认值 + const valueFontFamily = dataJSON.typography?.annotation?.font_family || 'Arial'; + const valueFontSize = parseFloat(dataJSON.typography?.annotation?.font_size || '12'); // 数值标签字号 + const valueFontWeight = dataJSON.typography?.annotation?.font_weight || 'bold'; // 数值标签字重 + const categoryFontFamily = dataJSON.typography?.label?.font_family || 'Arial'; + const categoryFontSize = 11; + const categoryFontWeight = dataJSON.typography?.label?.font_weight || 'normal'; // 维度标签字重 + + // 辅助函数 - 使用canvas测量文本宽度 + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(null, text, { fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight }).width; + } + + // 文本分行辅助函数 (针对X轴标签) + function splitTextIntoLines(text, fontFamily, fontSize, maxWidth, fontWeight) { + if (!text) return [""]; + + const words = text.split(/\s+/); + const lines = []; + let currentLine = ""; + + // 如果单词很少，可能是中文或者其他不使用空格分隔的语言 + if (words.length <= 2 && text.length > 5) { + // 按字符分割 + const chars = text.split(''); + currentLine = chars[0] || ""; + + for (let i = 1; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (measureTextWidth(testLine, fontFamily, fontSize, fontWeight) <= maxWidth) { + currentLine = testLine; + } else { + lines.push(currentLine); + currentLine = chars[i]; + } + } + + if (currentLine) { + lines.push(currentLine); + } + } else { + // 按单词分割 + currentLine = words[0] || ""; + + for (let i = 1; i < words.length; i++) { + const testLine = currentLine + " " + words[i]; + if (measureTextWidth(testLine, fontFamily, fontSize, fontWeight) <= maxWidth) { + currentLine = testLine; + } else { + lines.push(currentLine); + currentLine = words[i]; + } + } + + if (currentLine) { + lines.push(currentLine); + } + } + + return lines; + } + + // 新的文本分行辅助函数 (针对数值标签，允许字符级换行) + function splitValueTextIntoLines(text, fontFamily, fontSize, fontWeight, maxWidthForSplit) { + if (!text) return [""]; + const lines = []; + if (maxWidthForSplit <= 0) return [text]; // 防止条形宽度过小导致问题 + + let currentLine = ""; + for (let i = 0; i < text.length; i++) { + const char = text[i]; + const testLine = currentLine + char; + if (measureTextWidth(testLine, fontFamily, fontSize, fontWeight) <= maxWidthForSplit) { + currentLine = testLine; + } else { + if (currentLine === "") { // 当前字符本身就超出宽度 + lines.push(char); + // currentLine 保持为空，因为这个字符自成一行 + } else { + lines.push(currentLine); + currentLine = char; // 新行以当前字符开始 + } + } + } + if (currentLine) { + lines.push(currentLine); + } + // 如果没有产生任何行 (例如，文本为空，或maxWidthForSplit非常小且文本也很短) + // 确保如果原始文本非空，则至少返回包含原始文本的一行（可能溢出） + return lines.length > 0 ? lines : (text ? [text] : [""]); + } + + // 创建轴线（基准线） + g.append("line") + .attr("x1", 0) + .attr("y1", H) + .attr("x2", W) + .attr("y2", H) + .attr("stroke", "#aaa") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3,3"); + + // 检查x轴标签的宽度，决定是否旋转 + const shouldRotateLabels = xValues.some(x => { + const width = measureTextWidth(x, categoryFontFamily, categoryFontSize, categoryFontWeight); + return width > xGroupScale.bandwidth() * 0.8; + }); + + // 绘制x轴标签 + xValues.forEach(x => { + const xPos = xGroupScale(x) + xGroupScale.bandwidth() / 2; + + if (shouldRotateLabels) { + g.append("text") + .attr("class", "x-axis-label") + .attr("text-anchor", "end") + .attr("x", xPos) + .attr("y", H + 10) + .attr("transform", `rotate(-45, ${xPos}, ${H + 10})`) + .style("font-family", categoryFontFamily) + .style("font-size", `${categoryFontSize}px`) + .style("font-weight", categoryFontWeight) + .style("fill", "#333") + .text(x); + } else { + // 如果标签太长，分行显示 + const maxWidth = xGroupScale.bandwidth() * 0.9; + const lines = splitTextIntoLines(x, categoryFontFamily, categoryFontSize, maxWidth, categoryFontWeight); + const lineHeight = categoryFontSize * 1.2; + + lines.forEach((line, i) => { + g.append("text") + .attr("class", "x-axis-label") + .attr("text-anchor", "middle") + .attr("x", xPos) + .attr("y", H + 15 + i * lineHeight) + .style("font-family", categoryFontFamily) + .style("font-size", `${categoryFontSize}px`) + .style("font-weight", categoryFontWeight) + .style("fill", "#333") + .text(line); + }); + } + }); + + // 绘制每个分组下的条形 + xValues.forEach(x => { + groupValues.forEach(group => { + // 查找对应的数据点 + const dataPoint = raw.find(d => d[xField] === x && d[groupField] === group); + if (!dataPoint) return; // 跳过没有数据的组合 + + const value = +dataPoint[yField]; + if (value <= 0) return; // 跳过0或负值 + + // 获取对应group的颜色，如果没有则使用主颜色 + const color = colorResolver.field(group, groupValues.indexOf(group), { fallback: primaryColor, useAvailable: false }).value; + + // 计算条形位置和尺寸 + const barX = xGroupScale(x) + xBarScale(group); + const barY = yScale(value); + const barHeight = H - barY; + const barWidth = xBarScale.bandwidth(); + + // 绘制条形 - 圆角矩形 + g.append("rect") + .attr("class", "bar") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", 4) // 圆角半径 + .attr("ry", 4) // 圆角半径 + .attr("fill", color) + .attr("fill-opacity", 0.7) // 设置透明度 + .attr("filter", "url(#bar-shadow)"); + + // --- 新的数值标签逻辑 --- + const valText = `${chartUtils.format.autoText(value)}${yUnit}`; + const lines = splitValueTextIntoLines(valText, valueFontFamily, valueFontSize, valueFontWeight, barWidth); + + const actualLineHeight = valueFontSize * 1.2; // 每行文本的估计高度 (包括行间距) + const wrappedLabelHeight = lines.length * actualLineHeight; + + let labelFillColor; + let startYForFirstLineCenter; + + + // 标签放在条形上方，最低行贴近条形上边缘 + labelFillColor = color; // 上方标签用条形颜色 + const labelAboveBarBottomMargin = 4; // 标签底部与条形顶部的间距 + // 计算第一行文本中心点的Y坐标 + // 目标：最后一行文本的中心 + actualLineHeight / 2 = barY - labelAboveBarBottomMargin + // 最后一行文本的中心 = barY - labelAboveBarBottomMargin - actualLineHeight / 2 + // 第一行文本的中心 = (最后一行文本的中心) - (lines.length - 1) * actualLineHeight + startYForFirstLineCenter = (barY - labelAboveBarBottomMargin - actualLineHeight / 2) - (lines.length - 1) * actualLineHeight; + + // 为上方的标签添加背景矩形以提高可读性 + const maxWrappedTextWidth = d3.max(lines, l => measureTextWidth(l, valueFontFamily, valueFontSize, valueFontWeight)) || 0; + if (maxWrappedTextWidth > 0) { + const rectPadding = 2; // 内边距，主要影响高度和文本与边缘的距离 + const bgRectWidth = barWidth; // 背景矩形宽度固定为条形宽度 + const bgRectHeight = wrappedLabelHeight + rectPadding; // 背景矩形高度基于换行后的文本高度和一点内边距 + + // 背景矩形的Y坐标 (矩形顶部) + const bgRectY = startYForFirstLineCenter - (actualLineHeight / 2) - rectPadding / 2; + + g.append("rect") + .attr("x", barX) // 背景矩形X坐标与条形X坐标对齐 + .attr("y", bgRectY) + .attr("width", bgRectWidth) + .attr("height", bgRectHeight) + .attr("rx", 2) + .attr("ry", 2) + .attr("fill", "#fff") + .attr("fill-opacity", 0.8); // 背景稍微透明 + } + + + // 绘制每一行文本 + lines.forEach((line, i) => { + const textY = startYForFirstLineCenter + (i * actualLineHeight); + g.append("text") + .attr("class", "value-label") + .attr("text-anchor", "middle") + .attr("x", barX + barWidth / 2) + .attr("y", textY) + .attr("dominant-baseline", "middle") + .style("font-family", valueFontFamily) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", valueFontWeight) + .style("fill", labelFillColor) + .text(line); + }); + // --- 结束新的数值标签逻辑 --- + }); + }); + + + + /* ============ 4. 添加动态图例 ============ */ + if (groupValues && groupValues.length > 0) { + const legendMarkerWidth = 12; // 图例标记宽度 + const legendMarkerHeight = 12; // 图例标记高度 + const legendMarkerRx = 3; // 图例标记圆角X + const legendPadding = 6; // 图例标记和文本之间的间距 + const legendInterItemSpacing = 12; // 图例项之间的水平间距 + + const legendFontFamily = dataJSON.typography?.label?.font_family || 'Arial'; // 图例字体 + const legendFontSize = parseFloat(dataJSON.typography?.label?.font_size || '11'); // 图例字号 + const legendFontWeight = dataJSON.typography?.label?.font_weight || 'normal'; // 图例字重 + const availableWidthForLegendWrapping = W; // W = fullW - margin.left - margin.right + const itemMaxHeight = Math.max(legendMarkerHeight, legendFontSize); // 单行图例内容的最大高度 + const legendOptions = { + color: (group, index) => colorResolver.field(group, index, { fallback: primaryColor, useAvailable: false }).value, + markerShape: "rect", + markerWidth: legendMarkerWidth, + markerHeight: legendMarkerHeight, + markerSize: legendMarkerWidth, + markerRadius: legendMarkerRx, + markerOpacity: 0.85, + labelGap: legendPadding, + itemGap: legendInterItemSpacing, + rowGap: 6, + itemHeight: itemMaxHeight, + itemPaddingEnd: 0, + maxWidth: availableWidthForLegendWrapping, + align: "center", + fontFamily: legendFontFamily, + fontSize: legendFontSize, + fontWeight: legendFontWeight, + textColor: "#333", + className: "custom-legend-container", + }; + const legendLayout = chartUtils.legend.layout(groupValues, { ...legendOptions, context: svg }); + + if (legendLayout.items.length > 0) { + const paddingBelowLegendToChart = 15; // 图例块底部与图表顶部的间距 + const minSvgGlobalTopPadding = 15; // SVG顶部到图例块的最小间距 + + let legendBlockStartY = margin.top - paddingBelowLegendToChart - legendLayout.height; + legendBlockStartY = Math.max(minSvgGlobalTopPadding, legendBlockStartY); // 确保不超出SVG顶部 + + chartUtils.legend.draw(svg, groupValues, { + ...legendOptions, + x: (fullW - availableWidthForLegendWrapping) / 2, + y: legendBlockStartY, + }); + } + } + + return svg.node(); // 返回 SVG DOM 节点 +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_9.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_9.js new file mode 100644 index 0000000000000000000000000000000000000000..00fc30fee2602c7ba31c1d7e7e38249f26d0965f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_bar_chart_9.js @@ -0,0 +1,248 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_9", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.4); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]); + let currentWidth = chartUtils.text.measure(null, xLabelText).width; + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + barGroups.append("rect") + .attr("class", "bar") + .attr("x", d => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()*1.5) + .attr("height", d => chartHeight - yScale(d.groups[group] || 0)) + .attr("fill", colorResolver.field(group, 0, { fallbackKey: "primary" }).value); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_dot_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_dot_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..5d7c60ea2f3b310f8b73ab99d66c040dd6e29858 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_dot_bar_chart_0.js @@ -0,0 +1,297 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Group Dot Bar Chart", + "chart_name": "vertical_group_dot_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]); + let currentWidth = chartUtils.text.measure(null, xLabelText).width; + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + // .style("font-family", typography.label.font_family) + // .style("font-size", typography.label.font_size) + // .style("fill", colorResolver.text({ fallback: "#333333" }).value) + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + // 计算每个柱子的最大高度 + const maxValue = d3.max(chartData, d => +d[yField]); + const iconSize = groupScale.bandwidth() * 0.8; // icon大小为分组宽度的80% + const iconSpacing = iconSize * 0.1; // icon之间的间距为icon大小的10% + const maxIconsPerColumn = Math.floor(chartHeight / (iconSize + iconSpacing)); // 计算每列最多可以放多少个icon + + groups.forEach(group => { + barGroups.each(function(d) { + const value = d.groups[group] || 0; + const iconCount = Math.ceil(value / maxValue * 10); // 将值映射到0-10个icon + const groupX = groupScale(group); + + // 计算需要多少列 + const columns = Math.ceil(iconCount / maxIconsPerColumn); + + // 计算每列的宽度 + const columnWidth = iconSize + iconSpacing; + + // 绘制icon + for (let i = 0; i < iconCount; i++) { + const column = Math.floor(i / maxIconsPerColumn); + const row = i % maxIconsPerColumn; + + d3.select(this) + .append("image") + .attr("x", groupX + column * columnWidth) + .attr("y", chartHeight - (row + 1) * (iconSize + iconSpacing)) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[group]); + } + }); + + // 添加数值标签 + barGroups.append("text") + .attr("class", "label") + .attr("x", d => { + const value = d.groups[group] || 0; + const iconCount = Math.ceil(value / maxValue * 10); + const columns = Math.ceil(iconCount / maxIconsPerColumn); + return groupScale(group) + (columns * (iconSize + iconSpacing)) / 2; + }) + .attr("y", d => { + const value = d.groups[group] || 0; + const iconCount = Math.ceil(value / maxValue * 10); + const rows = Math.min(iconCount, maxIconsPerColumn); + return chartHeight - (rows * (iconSize + iconSpacing)) - 5; + }) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.groups[group] || 0) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + }); + // // 添加图例 - 放在图表上方 + // const legendGroup = svg.append("g") + // .attr("transform", `translate(0, -50)`); + + // // 计算字段名宽度并添加间距 + // const titleWidth = groupField.length * 10; + // const titleMargin = 15; + + + // const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + // x: titleWidth + titleMargin, + // y: 0, + // fontSize: 14, + // fontWeight: "bold", + // align: "left", + // maxWidth: chartWidth - titleWidth - titleMargin, + // shape: "rect", + // }); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_0.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_0.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..82045ec9911362aab37106c070556bd6d7d044a7 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_0.js.bug @@ -0,0 +1,274 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Pictorial Bar Chart", + "chart_name": "vertical_group_pictorial_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + const icon = jsonData.images.field[d[xField]]; + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]); + let currentWidth = getTextWidth(xLabelText); + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colors.text_color); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => formatValue(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + // .style("font-family", typography.label.font_family) + // .style("font-size", typography.label.font_size) + // .style("fill", colors.text_color) + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + barGroups.append("image") + .attr("class", "bar") + .attr("x", d => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.groups[group] || 0)) + .attr("xlink:href", jsonData.images.field[group]) + .attr("preserveAspectRatio", "none"); + + // 添加数值标签 + barGroups.append("text") + .attr("class", "label") + .attr("x", d => groupScale(group) + groupScale.bandwidth() / 2) + .attr("y", d => yScale(d.groups[group] || 0) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color) + .text(d => formatValue(d.groups[group] || 0) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_1.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_1.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..6472b86f5377112e1443c10932d3bb4199d9aebf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_group_pictorial_bar_chart_1.js.bug @@ -0,0 +1,274 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Pictorial Bar Chart", + "chart_name": "vertical_group_pictorial_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 6], [0, 100], [3, 4]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + const icon = jsonData.images.field[d[groupField]]; + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0.05); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]); + let currentWidth = getTextWidth(xLabelText); + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colors.text_color); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => formatValue(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove() + // .style("font-family", typography.label.font_family) + // .style("font-size", typography.label.font_size) + // .style("fill", colors.text_color) + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + groups.forEach(group => { + barGroups.append("image") + .attr("class", "bar") + .attr("x", d => groupScale(group)) + .attr("y", d => yScale(d.groups[group] || 0)) + .attr("width", groupScale.bandwidth()) + .attr("height", d => chartHeight - yScale(d.groups[group] || 0)) + .attr("xlink:href", d => d.icon) + .attr("preserveAspectRatio", "none"); + + // 添加数值标签 + barGroups.append("text") + .attr("class", "label") + .attr("x", d => groupScale(group) + groupScale.bandwidth() / 2) + .attr("y", d => yScale(d.groups[group] || 0) - 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color) + .text(d => formatValue(d.groups[group] || 0) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_lollipop_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_lollipop_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..6f91bc3dc0caa30060e7fd61f128cbb542be9037 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_lollipop_chart_01.js @@ -0,0 +1,576 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Lollipop Chart", + "chart_name": "vertical_lollipop_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "overlay", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 带图标的水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "bold" }, + description: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "16px", font_weight: "bold" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + variables.has_gradient = variables.has_gradient || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 40, // 顶部边距 + right: 60, // 右侧留出数值标签空间 + bottom: 90, // 底部留出维度标签空间 + left: 60 // 左侧留出描述文本空间 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 计算布局参数 ---------- + + // 创建临时SVG元素用于文本测量 + const tempSvgForWidth = d3.select(containerSelector) + .append("svg") + .attr("width", 1) // Minimal size + .attr("height", 1) + .style("position", "absolute") // Avoid affecting layout + .style("visibility", "hidden"); // Keep it hidden + + // 辅助函数：估算文本宽度 + const estimateTextWidth = (text, fontConfig) => { + return chartUtils.text.measure(tempSvgForWidth, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // 计算动态文本大小的函数 + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + // 估算每个字符的平均宽度 (假设为baseSize的60%) + const avgCharWidth = baseSize * 0.6; + // 计算文本的估计宽度 + const textWidth = text.length * avgCharWidth; + // 如果文本宽度小于最大宽度，返回基础大小 + if (textWidth < maxWidth) { + return baseSize; + } + // 否则，按比例缩小字体大小 + return Math.max(8, Math.floor(baseSize * (maxWidth / textWidth))); + }; + + // 预计算所有维度标签的宽度 + const dimLabelWidths = {}; + sortedData.forEach(d => { + const dimensionText = d[dimensionField]; + dimLabelWidths[dimensionText] = estimateTextWidth(dimensionText, typography.label); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + sortedData.forEach(d => { + const formattedValue = chartUtils.format.autoText(+d[valueField]) + (valueUnit ? ` ${valueUnit}` : ''); + + const textWidth = chartUtils.text.measure(tempSvgForWidth, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvgForWidth.remove(); + + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "barGradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", primaryColor); + } + + + + // ---------- 8. 创建比例尺 ---------- + + // 创建X轴比例尺（用于维度） + const xScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerWidth]) // 使用固定的innerWidth + .padding(0.2); // 增加padding以确保有足够空间 + + // 根据比例尺的bandwidth计算列宽和间距 + const columnWidth = xScale.bandwidth(); // 列宽直接由比例尺决定 + const barWidth = Math.max(columnWidth * 0.6, 15); // 条形宽度为列宽的60%，但至少15px + + // 圆形图标的半径 - 与列宽成比例 + const iconRadius = barWidth / 2; + const iconPadding = iconRadius / 4; + + // Y轴比例尺（用于数值） + const yScale = d3.scaleLinear() + .domain([0, d3.max(sortedData, d => +d[valueField]) * 1.1]) // 添加10%边距 + .range([innerHeight - (iconRadius * 2 + iconPadding * 4), 0]); // 减去图标和边距空间 + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建网格线组 + const gridGroup = g.append("g") + .attr("class", "grid-lines"); + + // 添加水平网格线 + const gridValues = yScale.ticks(5); // 约 5 条水平网格线 + + gridValues.forEach(value => { + gridGroup.append("line") + .attr("x1", 0) + .attr("y1", yScale(value)) + .attr("x2", innerWidth) + .attr("y2", yScale(value)) + .attr("stroke", "#e0e0e0") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3,3"); // 虚线样式 + }); + + // 创建并添加左侧值轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickSize(0) // 不显示刻度线 + .tickPadding(8) + .tickFormat(d => d); + + const yAxisGroup = g.append("g") + .attr("class", "y-axis") + .call(yAxis); + + // 隐藏轴线 + yAxisGroup.select(".domain").attr("stroke", "none"); + + yAxisGroup.selectAll(".tick text") + .style("font-family", typography.annotation.font_family) + .style("font-size", "12px") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // ---------- 11. 为每个维度绘制条形和标签 ---------- + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + + // 找出最长的x轴标签文本 + const longestLabel = sortedDimensions.reduce((a, b) => + a.toString().length > b.toString().length ? a : b, "").toString(); + + // 定义每个标签的最大允许宽度 + const labelMaxWidth = xScale.bandwidth() * 1.5; + + // 计算统一字体大小 + const baseFontSize = parseInt(typography.label.font_size) || 14; + const uniformFontSize = calculateFontSize(longestLabel, labelMaxWidth, baseFontSize); + + sortedData.forEach((d, i) => { + const dimension = d[dimensionField]; + const value = +d[valueField]; + + const x = xScale(dimension); + const barHeight = innerHeight - yScale(value); + + // 1. 绘制垂直线 + g.append("line") + .attr("x1", x + columnWidth / 2) + .attr("y1", innerHeight) + .attr("x2", x + columnWidth / 2) + .attr("y2", yScale(value)) + .attr("stroke", primaryColor) + .attr("stroke-width", barWidth / 4) // 使用一半的条形宽度作为线宽 + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // Define circle position + const circleX = x + columnWidth / 2; + const circleY = yScale(value); + + // 3. 添加类别标题（在底部） + const textLabel = g.append("text") + .attr("x", x + columnWidth / 2) + .attr("y", innerHeight + 20) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${uniformFontSize}px`) // 使用计算出的统一字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 检查是否需要文本换行 + if (dimLabelWidths[dimension] > labelMaxWidth) { + wrapText(textLabel, dimension, labelMaxWidth, 1.1, 'top'); + } else { + textLabel.text(dimension); + } + + // 4. 添加图标圆圈（在线的顶部） + g.append("circle") + .attr("cx", circleX) + .attr("cy", circleY) + .attr("r", iconRadius) + .attr("fill", primaryColor) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + const iconSize = iconRadius * 1.5; + + g.append("image") + .attr("x", circleX - iconSize / 2) + .attr("y", circleY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 5. 添加数值标签（在圆圈上方） + const formattedValue = chartUtils.format.autoText(value) + (valueUnit ? ` ${valueUnit}` : ''); + + // 计算数值标签的最大宽度 + const valueLabelMaxWidth = barWidth * 2; + let valueFontSize = Math.min(20, Math.max(barWidth * 0.5, parseFloat(typography.annotation.font_size))); + + const valueTextWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: `${valueFontSize}px`, + fontWeight: typography.annotation.font_weight + }).width; + + // 如果超出宽度，调整字体大小 + if (valueTextWidth > valueLabelMaxWidth) { + valueFontSize = Math.max(8, valueFontSize * (valueLabelMaxWidth / valueTextWidth)); + } + + // 定义标签位置，确保与圆形图标有适当间距 + const iconTop = circleY - iconRadius; + const labelPadding = iconRadius * 0.3; // 图标顶部与文本底部之间的间距 + const labelY = iconTop - labelPadding; // 文本基线位置 + + const valueTextLabel = g.append("text") + .attr("class", "value-label") + .attr("x", circleX) + .attr("y", labelY) + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 放宽换行条件：如果文本宽度超出最大宽度(即使字体不是最小)，也应用换行 + if (valueTextWidth > valueLabelMaxWidth) { + // 清除当前文本 + valueTextLabel.text(null); + + // 应用换行处理函数 + const words = formattedValue.split(/\s+/); + // 如果只有一个词，考虑字符级拆分 + if (words.length <= 1) { + const chars = formattedValue.split(''); + let line = ''; + let lines = []; + + // 逐字构建行，确保不超过最大宽度 + for (let i = 0; i < chars.length; i++) { + const testLine = line + chars[i]; + const testWidth = chartUtils.text.measure(null, testLine, { + fontFamily: valueTextLabel.style("font-family"), + fontSize: parseFloat(valueTextLabel.style("font-size")), + fontWeight: valueTextLabel.style("font-weight") + }).width; + + if (testWidth > valueLabelMaxWidth && line.length > 0) { + lines.push(line); + line = chars[i]; + } else { + line = testLine; + } + } + + // 添加最后一行 + if (line.length > 0) { + lines.push(line); + } + + // 计算所有行所需的总高度 + const lineHeight = valueFontSize * 1.2; // 行高 + const totalHeight = lineHeight * lines.length; + + // 计算第一行的垂直位置，使最后一行恰好位于圆形图标上方 + const firstLineY = labelY - (totalHeight - lineHeight); + + // 创建所有行 + lines.forEach((lineText, i) => { + valueTextLabel.append("tspan") + .attr("x", circleX) + .attr("y", firstLineY) + .attr("dy", `${i * 1.2}em`) // 使用行高系数 + .text(lineText); + }); + } else { + // 有多个单词时，按单词换行 + let line = []; + let lines = []; + + while (words.length) { + const word = words.shift(); + line.push(word); + + const testWidth = chartUtils.text.measure(null, line.join(' '), { + fontFamily: valueTextLabel.style("font-family"), + fontSize: parseFloat(valueTextLabel.style("font-size")), + fontWeight: valueTextLabel.style("font-weight") + }).width; + + if (testWidth > valueLabelMaxWidth && line.length > 1) { + line.pop(); + lines.push(line.join(' ')); + line = [word]; + } + } + + // 添加最后一行 + if (line.length > 0) { + lines.push(line.join(' ')); + } + + // 计算所有行所需的总高度 + const lineHeight = valueFontSize * 1.2; // 行高 + const totalHeight = lineHeight * lines.length; + + // 计算第一行的垂直位置，使最后一行恰好位于圆形图标上方 + const firstLineY = labelY - (totalHeight - lineHeight); + + // 创建所有行 + lines.forEach((lineText, i) => { + valueTextLabel.append("tspan") + .attr("x", circleX) + .attr("y", firstLineY) + .attr("dy", `${i * 1.2}em`) + .text(lineText); + }); + } + } else { + // 单行文本直接显示 + valueTextLabel.text(formattedValue); + } + }); + + // ---------- 12. 辅助函数 ---------- + + // 增强的文本换行函数 + function wrapText(text, str, width, lineHeight = 1.1, alignment = 'middle') { + const words = str.split(/\s+/).reverse(); // 按空格分割单词 + let word; + let line = []; + let lineNumber = 0; + const initialY = parseFloat(text.attr("y")); // 获取原始y坐标 + const initialX = parseFloat(text.attr("x")); // 获取原始x坐标 + const actualFontSize = parseFloat(text.style("font-size")); // 获取实际应用的字体大小 + + text.text(null); // 清空现有文本 + + let tspans = []; // 存储最终要渲染的行 + + // 优先按单词换行 + if (words.length > 1) { + let currentLine = []; + while (word = words.pop()) { + currentLine.push(word); + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + currentLine.pop(); // 回退一个词 + tspans.push(currentLine.join(" ")); // 添加完成的行 + currentLine = [word]; // 新行以当前词开始 + lineNumber++; + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } else { // 如果没有空格或只有一个词，则按字符换行 + const chars = str.split(''); + let currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const nextLine = currentLine + chars[i]; + const isOverflow = chartUtils.text.measure(null, nextLine, { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 0) { // 如果加了新字符就超长了，并且当前行不为空 + tspans.push(currentLine); // 添加当前行 + currentLine = chars[i]; // 新行从这个字符开始 + lineNumber++; + } else { + currentLine = nextLine; // 没超长就继续加字符 + } + } + // 添加最后一行 + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } + + // 计算总行数 + const totalLines = tspans.length; + let startDy = 0; + + // 根据对齐方式计算起始偏移 + if (alignment === 'middle') { + // 垂直居中：向上移动半行*(总行数-1) + startDy = -( (totalLines - 1) * lineHeight / 2); + } else if (alignment === 'bottom') { + // 底部对齐：计算总高度，向上移动 总高度 - 单行高度(近似) + const totalHeightEm = totalLines * lineHeight; + startDy = -(totalHeightEm - lineHeight); // 将底部对齐到原始y + } + // 如果是 'top' 对齐，startDy 保持为 0，即第一行基线在原始y位置 + + // 创建所有行的tspan元素 + tspans.forEach((lineText, i) => { + text.append("tspan") + .attr("x", initialX) // x坐标与父相同 + .attr("dy", (i === 0 ? startDy : lineHeight) + "em") // 第一行应用起始偏移，后续行应用行高 + .text(lineText); + }); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..26850c02ae3fb2b03bdd035289a5e90ed7a42321 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_bar_chart_01.js.bug @@ -0,0 +1,489 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Pictorial Bar Chart", + "chart_name": "vertical_pictorial_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js创建简单的垂直条形图 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = jsonData.data.columns || []; // 数据列 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xColumn = dataColumns.find(col => col.role === "x"); + const yColumn = dataColumns.find(col => col.role === "y"); + + if (xColumn) xField = xColumn.name; + if (yColumn) yField = yColumn.name; + + // 获取字段单位(如果存在) + if (xColumn && xColumn.unit && xColumn.unit !== "none") { + xUnit = xColumn.unit; + } + + if (yColumn && yColumn.unit && yColumn.unit !== "none") { + yUnit = yColumn.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField], // 确保y是数值类型 + icon: jsonData.images.field[d[xField]] + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colors.other.primary; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", d3.rgb(baseColor).darker(0.1)); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(baseColor).brighter(0.1)); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function getTextWidthCanvas(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return ctx.measureText(text).width; + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (getTextWidthCanvas(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 35; // 标签开始的 Y 位置 (保持和原来一致) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加延伸到图标的柱子 + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("image") + .attr("class", "bar") + .attr("x", d => xScale(d.x)) + .attr("y", d => yScale(d.y)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.max(0, barBottomY - yScale(d.y))) + .attr("xlink:href", d => d.icon) + .attr("preserveAspectRatio", "none") + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colors.text_color || "#333333") + .each(function(d) { + const valueText = formatValue(d.y) + (yUnit ? ` ${yUnit}` : ''); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = getTextWidthCanvas(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + // 在维度标签上方添加水平线 + chart.append("line") + .attr("x1", 0) + .attr("y1", innerHeight + 20) // 直接位于维度标签上方的位置 + .attr("x2", innerWidth) + .attr("y2", innerHeight + 20) + .attr("stroke", "#e0e0e0") + .attr("stroke-width", 1); + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", "#ffffff") // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (getTextWidthCanvas(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加圆形图标 - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-circle") + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-circle") + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + // 添加圆形轮廓 + d3.select(this) + .append("circle") + .attr("r", iconRadius) // 使用变量 + .attr("fill", "none") // 无填充 + .attr("stroke", "#2D3748") // 更深灰色的描边 + .attr("stroke-width", 0.1); + + // 如果有该类别的图像 + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加圆形图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_percentage_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_percentage_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..faf91fb94e4e185e2c63cd65737d9812f14729ff --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_pictorial_percentage_bar_chart_01.js.bug @@ -0,0 +1,336 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Pictorial Percentage Bar Chart", + "chart_name": "vertical_pictorial_percentage_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 10], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 实现花瓶形状的柱状图 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + other: { primary: "#4682B4", secondary: "#FF7F50" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = jsonData.data.columns || []; // 使用data_columns + + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名称 ---------- + let xField, yField; + + // 安全地提取字段名称 + const xColumn = dataColumns.find(col => col.role === "x"); + const yColumn = dataColumns.find(col => col.role === "y"); + + if (xColumn) xField = xColumn.name; + if (yColumn) yField = yColumn.name; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (dataColumns.find(col => col.role === "x").unit !== "none") { + dimensionUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y").unit !== "none") { + valueUnit = dataColumns.find(col => col.role === "y").unit; + } + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + // ---------- 3. 数据处理 ---------- + // 按照y值降序排序数据 + const sortedData = [...chartData].sort((a, b) => b[yField] - a[yField]); + + // ---------- 4. 尺寸和布局设置 ---------- + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 120, // 减少顶部空间 + right: 30, + bottom: 80, // 国旗和标签的空间 + left: 30 + }; + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + // 创建主图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 6. 创建比例尺 ---------- + // X轴比例尺（瓶子之间的间隔） + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d[xField])) + .range([0, innerWidth]) + .padding(0.2); + + // Y轴比例尺（瓶子的高度） + const yMax = d3.max(sortedData, d => d[yField]); + const yScale = d3.scaleLinear() + .domain([0, yMax * 1.1]) // 添加10%的空间 + .range([innerHeight, 0]); + + // ---------- 7. 创建瓶子和蒙版 ---------- + // 定义瓶子的宽度和高度 (不修改这部分) + const bottleWidth = xScale.bandwidth(); + const bottleHeight = Math.max(bottleWidth * 3, innerHeight * 0.5); + + // 获取瓶子的主要颜色 + const bottleColor = colors.other.primary || "#4CAF50"; + + // 定义国旗和文本的空间 + const flagTextHeight = 50; + + // 计算瓶子底部应在的位置 - 让瓶子底部接近国旗 + const bottleBottomY = innerHeight - 10; // 瓶子底部位置，紧贴国旗上方 + const bottleTopY = bottleBottomY - bottleHeight; // 瓶子顶部位置 + + // 创建一个数组来存储所有的值标签元素引用 + const valueLabels = []; + + // 添加瓶子图像和蒙版 + chart.selectAll(".bottle-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "bottle-group") + .attr("transform", d => `translate(${xScale(d[xField])}, ${bottleTopY})`) + .each(function(d, i) { + const group = d3.select(this); + const bottlePercentage = d[yField] / yMax; + + // 为第一个（最高值）瓶子使用不同的图像 + const imagebase64_2 = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="547" height="1410" viewBox="0 0 547 1410">
  <image id="瓶1" y="17" width="547" height="1381" xlink:href="data:img/png;base64,iVBORw0KGgoAAAANSUhEUgAAAiMAAAVlCAYAAADNjMxOAAAgAElEQVR4nOy9aaxl2XUettY+99431jy8GrqL3dVsDs1uiiJFtim1BktWIidWrDgDEiOIAsRAkAHQj8AIEhvIjwjIn0wwjMAOnMBGgsQ/7MDOACEQYseyaVASLUGkRLLJnthzV9f45nfvPXsFa/jWOfVUQ1fVe1Wvuu8mX9cb7j3DPuee9e21vu9bTHs0Dh06RJ/73OdoOp2SiNhG27alUgq98sortLGxsVe7uus4c+YMPfPMM/TBBx/Yvh90PPnkk3T06FEaj8d2boPBgA4fPkzf/e53aXV19aGc08mTJ+mJJ56g7e1t+3k0GtFkMqFaK83NzdG1a9forbfeeijHcqvx1FNP0fHjx2lnZyf/Oj8/T1euXKE33ngjz+H8+fP2mns9/k996lO5fb0GzGz3Fvbz5ptv0qVLl/bl3C5evGj397e//W3b99yROTp89jDNj+fp0luXqJXW/q7HdP36dTsnHcPhgA4dWiYuhXZ2xqWdTkdVKk/GY56fX+A/9ad+ce70ygoxyXQ6vTqYttvNDs8X2RkOZNIWoh2uUgoNmsFwMGylSN1au1bKoBnOj+aJKvOUpk0zbFh2Kq2vrTYTnpdDi4syGghNhAbTusPj8Y4MmlIHg1GdbjM3o4Yn7ZgK1zIcDEpDgyJVasttM+AhDQbNuHI7nU7appSm4dJwEZlIW2lCVKpIw1TLgJtSWAZEQmubm+14MqlLS8vNqBlWEmlrkWERaXa2J7Q13q5UqY6GI2rmRhPm2tZKTSFumgHTeFrbyWSbajul4Whx2JRBHRXhtpVmc7zVDkdDbnemrBteWFpumcq01LYMBzyYVKKN7c3p4sIcDXhYhaVIS8RCJEWYB6XhlqbSTmodDKjWQiR1UkpTiak0Yr+ZcmEhppZouDkZt5PJZCqLi/N0+PCaLCystGtrw/bv/x9/V65euVoXlxbroCmT0WhIVfy6MzENh0MSElqYX7B7YHNzk+bnmU6dOkOHDh2nyWRszw99Nuo98/rrr9MHH7xPg8EcLS4WOnFinra3p9S2lUphmkyGeifR2bMr1DSN3fP6DNDnrN5vtxr6e/186Wt0Pzp0n3Zs8WzW1+jzTP+u3+MLo//50s+nfo71WG83lpaW7Jmo+8TQz4Ee8/r6us3DoxynTp2y5zienzofeqw6T++88w59+OGHj/T4PsrQc8DzU6+lHr/OsZ6DxtdXX3113/Z9u+tLca/o9/oMx/11P2Owb0f/iMbKyorddPpwOHbsmAWS1157bU8PRicfN8JsfPwHrvNNHzSOrwDdk8mUFhbm7Z7b3Nqk8c64mU5b+spXvnjk1JmVF19//c1/4eqVa8+1dbo0KEXRxeDG2tXB5vY6kxBVmZRaWxFuqE6JWgs2bWO7ZObCRaMFCVcRqfq5rQ03XKUlYRauGrqEKu/wxvp1YmlbUbhBVd/oh8rc2kFL21Spfhaiv9awwxa9RUMQc2vYhKmxfUoRDdjUkBA3GigHtVYNXcVimJAeuG16c3Nbwz9TlZapWmCmyoXYXirrvG0nIBoEi+2/iu6Y4wUkQrLdiCjisfkuQkWnQYGPHqysrq1XJm6bwmzXRIruu66tresEMBXSt7b6etu46KEKF5Kp6MlN24YrtWXQ4MJS0SNWnMXCo9GwZeJxW6usbTB/eGXScNloScrOxWee3L7w9JObo8Hg2uLi6IfHT5z4J2Om3/tH/88/Wlu7sSZzc3PT0hTSr8l4Ys+J6bRYYEewvx2ImI3Z+CSPjxUYUSBy4cIFQ78aQBSNnzhxwv6mqP5BUNtsfCIHoobdOLrKs5XmgOj0C6fLqe1T9cY7N2hnsqPZBPqFX/h5Gi6Mzr/51pu/eu3Da396a3Pj0ObGeHT5g6vH5kbzZ06dOUPD0tBw0FArlba2d2g83iLWQF4astiv0bkISdFdj+xn/x/769gCrx2YvY0aO0x2aBCvr0TVP9qNHnnx92pMFmpJpKGBoxNSeGIbKzhL/aH6sRT/lW2VB1T0J/EVM9sRWWS1/ej2HdnEhDW6T3GA0yg+iD+wH7dMa2y8dLMc27cfS/e9FD8K+5UdnQOIRrejRxWZMjsCfZHmT4rkcRWbN31xtWMqzcCuIeN4KLIo9oNQq1DE5rKhtgpNpiOqdap4h44eP0nD4YiotlRrO1lf3748adurTz7xZFvPtpOTJ0/+7pFjh/7exvrWb/2z3/39LTuVopmTa/TCC1+hY8eOlG9961sVGYvZmI3Z8PGxASNamlEgsrW1lalHijSpprc0Jfn2228/8uOcjcdqyNGjx+kLX3ie19ZWddVr99N4bUIffvtyvbp1lbbGW/TiT7547PjRI7927dqH/+L0miw3Zfj0ytmzc02jBRi9FwstLS9QM2yoIa2IaIwUOXQoUIZnP6pFbE1zkEVH4crCng8xQCEe/6VGCoGpAlJYNJYaP5eiOYlaxDamkdU2WTWtoOhDHDr4iwWIgxxaWMpVcwpV32dHoGkP3VIhDkAviRFsm+KgQjdsmQoRwCXmiPcSPylOamzLVQxzCVCKv8xAk/5eEyj+KWbL2Oh7FUrEIRH5+TE7/nIsUbDcEInZItsXGWbR904Vv9gEVtuNobCqWRF9hcKYGofiewlIVAyncJlaRsnSLVTbOmyn7dlSBmefevqigcBa26+sbaz/2a3N7UtPP3PxlTMrR//nlRX+v37zN7/VfuMb/5SWlxfq1atX6ezZs5ZqV4A7WyPNxmx8jMCI1l8VhACI9LMgyk3QQDIbs3Gv48iRZdre3hIFsgpENL7N8YiePfXpeartn18ezv1rhenseDJ5fnNzrRkMRrSweMjut6YptSnKQeDSagFAqxPUWq5CQ57yH1g8ckuAEpFSPXQaxtAwarwGLSKI11H8T1abIK9qaBmnH4CrVyVsj2S1EopahkSgJY/+llLQwyier+BEGp5/KL5HZDsUH4ghk2JQSCIqe/Ikf7BEjWEMRybsGzVMYACkMk0BfKSV+NZP33CPzg05YBA7QQMZlb2W5BBFGTRalPEMiuVDbBaj2lNtb/p3qeKASefDUGBrO2uKAQ/qzlm4h6J0v3iIMBIvFakgvZx6fUdzQ6sw6by000qTdjIYzY3OVuGzC4v0Y23b/tSlS9MfPfXUZ94qZfDXvvnN3/5/iRp66aWX6OrVa7S2tm6Zk9mYjU/6+NiAEQUcSNfeaszSorNxr+Po0Xmq9TL97u9eIuW9zc/Pla985ce/OhwN/mJleWE4mH/6U89cHCpWGI3m6Mjx48KlSDudSJ22SlgtE4pyhIdQDcgtR4SVysrPMCgi1WsJ+ttAGV7DEA7sUTnggv29eq6CI8I6aSMgiS/6jYlJEpE6AIPSQ6qST2ubUbc4d8Q+O8UZGMYd8X0WAZxAKK6GKKRyK56X0P/qzxQIR/9RSihz5UpIfbCftgES2wRHicUmxj+7zg+xDIUfc4ntWarHMzASKw2bmOLHVg2w2DukdfZKtVcXKbFXS3j4/Ors6UZtzpRE4pUpinSRsLRsNCHmLHwZpONaHAxZLqW0esjtNA5crBjWNM306MJRoaNF+SJle3PrzPra1pnlw4svNlz/uS9/5UvfW1xa/Ouvvf7q33/rzbeurq6uWYbEeUnFcjSzTMlsfBLHx47AOhuzca9Dg0ExxcvOTe8cDpleeukiffOb79Lp089eXD4y/5+vr238uZGMljVIjeYWaWF+TomkqqjhdjrRIKp1jgAXAUHEGRns1IUmyjKoX2jULBaqnQxSAjdg0e71DKtBGGCwrINv0CsKtgmHMh5BbRMqZ0leR+QU7LWFgnUqYEz4Jp2TC8aswZjMoiS/wtMlDkDYdqvRXAIx+H89hRG/M2ARB+lHwYSdSaRU8B/HZU5vcYDEPVIHI2/DxX9XvaaFJYgk4LIMUB+IOWoKWFQsieLv9pSKITDbbfCS/QD8/D3z4tWixueYlT+kgMSnhu0aGQJiamsZ71TihlsuZbK4tDRdPrTUKJF1a2Pz8ImTJ1/c3Nj8Wjsd/+UXXvjcX3vllTf+xurq+rWdHSW7TqiUOUWoShemGc91Nj5JYwZGZuMTP5RTpGW+l19+mQbDgZYjLJM2Hg/o0OFnjj/3hRP/1dvvXv+l0U5zdnFxmQ4tH6a5hbmpqi2mk7aM644qQ52dEAGMS8RBiyoUwhWpUWNx1MG2pidUQvTvHCEo8IKLTTKsB4OCM0IHlPDcS7V0AxcncSJmR5GESdqgojgDNmoDtXoQjowFB3mlcC7PHURUql5Q8kyKS0Etz2DYodiZcnBP2UO+7bh6CsdAQ9GzAMu1BG3FiiPiR8IlIJJ/56RTFLAMdYidKKnimYMJU4J5Y++UqBAFyVZqVpkUIuKwOMs5VqWqkZ7i6hRYzeng7IObwx2mMhKvQj6Gwkokal6EDekRt+1kQHWqoiGl8UyXlg9tKxhsSjNaWFy4uDPe/i+feOrJf+fYsSN/5Y/+4OW/sbFxrf3Ccyfltdev85UrWz4bwjNQMhufiDEDI7PxiR/Sowe005aaQUNL80v0mc8+++/+4R998B+10/GXDh8+RIeWDtHc/PwONczj6ZjbaQ1uR3XJijMsrPCQIZed+9FbalO8jo1zgaAtnHxSKGiQyyiWe9CShIAjAo6r/2PE0hJpAfGKgqA4E2mYiKTS6Vp8Oa+MBQvIFOAmchIUOMByNoo4iic2fOsGDTjILpUTslh4b4vXGhx1qSjZaCslSCQdc7ZKFooy8eGAi1DRAbHVil3FpTgW6kNVbwkaP8taAttU5wdLR46xo7X9OiHHh0A+5NtN4a1E1saIOVHF6XRCqehxhkk/dRQFKVNqV/Epc34sq21IS5OmKQOaX1wc6y9H07n50dz8c+Od7b/66c889Usnj3/tL7z22revvPrqFVFFj/KPFhdHVHDAszEbH+MxAyOz8YkfIpKcIi3XfP2lr3M7mfwPmxsbvzoYjYbHj5+SpUPLk+lkKjvjnUKDSPqLURpA4aTgkApqJ5Dc+roZ1FGWiKPVZS6RF9H6TfAfKoMSEaviGqoS8WBKXmMgsDyC/Grr6A5alVTiOHxhHjgLpEZ5whIRgRAcslhKRZzO6kCJnR8CfaydYsspLi4OxPwAPGZz0ESiDuK4KNIsgiMRBzPG3HSoIp1opiLv4wkJO4YSqQxj/Eb9Koo3sVcTA9fQ9TrNt0NW3Cu6eG7Ipym26sMmuYohKaeoeqorQFPofv27GvqeyF45XyWIN26cJpFocuMThzoqtpEpt8UrMXNzc2ujwVzZ4sHSeLL9Kxvbm+cWlp/4y1wu/eZke93KNnNz6mfEaSCm9+lu3xvAqFLKzL5gNh7bMcPcDzD6bnSz8egGHADvcaRtGd6vD/Mvf/XHv768tPT3mAd/4djxE8PTK2cmS8uHx9PJdDCZjoemwqjm1dmQO4JkBoOiwECVUhricVwjuX3rWl1XhBiQKM4AqU7ECHYkvrA9l7aIcy07LolHIWNuVCsLRQGnKEmVYf6hWy416iMlCCTuOsL4TaladjDwUfSwqqdqQtNaqFSAIXsB5jlMyNj+zmB9GLuFJdIYdli2YffucFzgdafu77WQT4blYmqwUijSOKzn09WNGNQOP5dqX17WcRV0J1oOUmswQ7ww02WNUEmSUgNhhCaIgbbYUzJNgAyzJbVEjkGu0DtTviPqaDGTpA52Wk/S862a2aLGoF4Vnk5ksLM5WaTKo2PHjm0vLR1SB8uvDUr7v7zw/LN/dX5h7phitdOnT5uRHtxQT58+zYuLi9x3TlXOk7pw0oyoPxuP8ZhlRu5j2LqzFFpcXEx74dl4dEMfwCqlVVt42FgrUNxNSN01BNSJzY1Neumln5r/wvOf/0+vXL36H9y4tnry6PFjtHxoabqzPW62trcH7IkEl2GKcz2csUiwFbMAXhmuGkU8me8hF7wFgYaU8/2gsoby1akYkq93oWvxyk+QS5Ruad/XsAkxA9GQ1rJblnoliHsOIuKs1OA9hLdJcigiQIdjR/Hg7BUYi78mMSY4kwQ/AlTULB35VkHfQOGi478KCLChH2ZJlGNbq1EsKi5ervn+dBNx97JAPW4k62rfYPFaNgLK5Oo+aCaDptZhjCMW6JdFOA8tJysUROKWcNIxbivQR1BDutPmUMEEHgwIJMGsKYQJrhxbd//ZyXTcTDd2BsPhXPvEE0+W9bW108z1P/z0s0//9OmTZ39tc3Pr/1NPkuXlZf7BD34g6+vrgvtdMyX6pXbmKjvX32vLCP3dbMzG4zb2DIzcaWX6ccwg6Dlp/xt9ANy4ceMAHNEnd+g1UCCiJFRdJWLFqL0SdvdE0gc1tBcyJBouDJQnsnTj2tX/rQzLLw9GQzp+4iQNmqZubm6rY2nbsC2EIyiJO3wYVYRRiGjFVSrBbixdaGOvHTh3MjkcHl0Fa3mnZGZloXikovTx6LxNGYrf4J8Yu9J91z1lIQFLnB8a7wdH1UQ+9sditRiUO6IogzoEJz2E3CHEyg4wHXF85A4oHvlLDeVK8D0KJisCOPBNH810ZBmUcIJvG8FdOlIHOedDczYUeMpRR4qg1XGkmtuK/q3CLA2mqg4CS+AZcTGSE1ZhfuZeJsn5YN9XHkgNQU5QYpFfyivmiqiYP1BwY25rT5EdiuZgD4uDJUWcOzvbPBwM65FjR2R+aa4pg8EXq0x+49jxo3/uBz/4wW9cvXpVtJ9K0xRaXj5k97s+c/Vf7f2iZo+4vw/aOMilI72Os2zSwRh7VqbRD8puj49+BmH30N8vLy9nenGvx15+APQYFxYW7Bz1uM+dO8faOEi/f+655x6Jodp+f8Bx3fRhp+d+r9fpbsf3oMfffz/KLPpQUZConjP6pY2d9Dph6DngnJpmQKPBiH7sZ7+4/MJPPPd/v/vuB788rpVWzqyMtcyxs73DUtvCEMySN20pTTp8aQqg2PK4EqdEBtkCFjAbOKoZYe3l6lxPh0iBrYRXI8wVHnLgoIbWZEkysE+svYW66Acah3C6gljDGliTIkYWsiY2LI1uXUCwSAYIQxzrKQ5nxXq6J+N7ATPCgAF8SOKdLI46Aq3UTEL4+ZfU34oxYFK1EqWrTDt4BqNAjUzW2qVyEnKtutOamRkbjism4ykUTvqN26QZ+gorfCPj2jPK+DSi1R8zqfVshRvVMuTQNRI3YSQXGh1y85Oo9wSDJ4s0Zn+GJBi5hW4Qdh2e2N+LoHIU7CBFc8w8badlvLNd5uZG7YnTJ2RrvD2/sb76t86dW/lZtZPXRpJ63z799NMMMKIgBAvBPmfkUQOA3Z/PgzZwfAB0j9s4SNd3r8aeZUa0B0zf+VQvsn6vQUEb1+n3KGno686dO2f1UO2WuBeddXcP0Pj24oOg3X81iCno0IC3ubkp2ol2bW3tpk6YD3PoPnWO8fWgx9Dv6qmrK7XW15/VRh9ddbUz7kcdmP/+Sg3NwvC3Bzn+u11fbFPBiKaw8Vq49Cpo+Zmf/Bk6urj8P753+d2fPXvhPC0fXp5Od8alTs0c3PiTIrVwQACnjTpPo6DSwL1KC8XfrQeKL5eD5hj+GqGZAcEyXNVTxeIW627nWQWAw8mXyGS4AVoajojAC17SotQVp5XCvr0wqBHO3uDACOlRQnHkyNlE7sIJGXnIXl0qYWdSo+lLNV0sp5KEoIIJT1ddj4QohzLHE+WZDnBw3hYc54Jwj8qSxu2KylpYfxgVp9ciR3LCO0ZQ3FfhIoLJFuiQGBrrAJjiZJYqkPf2K02Q7trJszN89Da25ntxOxRn0lrTYE+UBa1WGORdJ+rCvkRd+wMD2i3dCo+3xzQcDSZPXnhy+MG775+atDt/++d+7qf/7d///e/85sWnL1r5UbvoLh9apmtXr91UjnR7+Zs/X3SL4HG3z1w1oTY/0PMTxHB9dmKBcFAG5kdjknYT1+fc5cuXD8zx3Wqga/NePD/3YuCZulf7fhAwks8oimCGYKOTo0SrtbU1QcDW7rl6YyJAnTx5kjWo36Guf9P273owwRXAv2fOnGFNbepN1u+YeT/b1zTo97//fQtsAFgfoSX2PR3/XTfWOz/9Onv2LK+urop+mPTD/qClIgWT6O2j23/iiSds/pAhUTByt+PrP7xOnTrFtVbpt/XXbeP63+vx7z5/vX+0fq73T3d9OV979uzZcu3aDbl+/Vpeg9332tbO1n9X36n/+qHlY3T42KF2Z3tqxYnSWNljwNSRJtU6XB3cq6k9hbvWbFEHsTyGO7yH0jXW4SySyImC4VAtgWAM1ooCjPNbJaxMpXBD4EF4BkLcdERKJi48iVHCE60KrEydxhJZT2OjIkkjFie9pFQ4yzRGXgHtljvlcJh8UXBrU5ec/mREUCJbfqgY+7OatWqJLFCVLvi6NxhaBYd1G8Q8XQnEKyRN14TP/xbZH9cPETfFrcuqwRkX/VjIr6GzDktX1FJqqJ1KoJcCE32C0Jhhr29plnCMBRYRCatXJ/dGGY6hg/ZSkKuhwxMuLNw6Q34KD1t3WXMtOLewy68dx4an0/F0MBzN19MrK+WD9989s1E3/uaf+KkX/40fvPzDf/zqK6/J1776VW6aRt579728n7HgO3r0qH6e7fmrP4P8iuChz+eVlRXWz/SNGzcEWW18dvXv+v7t7e1dn6+bP5K7n294je5HP3/x/Bd9/mvA12fBPZRE9vT5iYE50Pigzw99JulzXXub7TEY2fPj15Kzzh/imx6/Xl/NXO8DFeKWx49H2blz54ruX6+vZpz1OO4RlPyx7T9ImeamDe1GaAo0cIAKCPQLsjRzI9zaotXVVXrvvfcoo8gdtn+30UeJkb3IG/82k3RP21cAcv36dQuaHwGI3PP2P8oAmNNz1IcI5H764XrQcheuC7IGly9fFihMKFxK7/b+PlrX+dLr+/777xOurwJTfQDqMd/P8ff9QPTeQgsAiUKHWmnrQlC/btxYlfF4U9bX1/749WeiZz77qV/f2ln/teHCPB05cXw6Ge+0DYvWZVoBxdNMxhnZDYtt4QsqEdiq92qRzvdTvFl9NLbrJDaFb1pGWHVASoUAxaCL0z4k1usCe41Y+Lt5FuoGEppaSqTW5Sdcz6EhMNI2hZ18GxmEwmGQrlPlPAv30+BM7xABAETgdhWuT0qJ4G7HEAZt3HFgvVbhECxyQpCxcOqgYbkCp7IoExmZww7UyKmtN6kRHFwYnOA7buN6qkjZ0JtvtfhXLRUkW3eHDWJp8SwFdMKxhXSjE25U5SyAERyEXuiAokOyRC0nKkzSHSLAj3hyLeo3XgaroBOZJ3546ZrHG5fIr1VnzsrWzra+YHr27Hn9rJy7ev3K3zp3YeXrh48s0fvvfyBru56fesQI+BokKBaJ+IzhM6pfGxsbulCT/ueq/7W1tSX6HNidYel/HHd/Nvvb14XGzs6OYPGm/95jOXvflvo6Fzo/Ok86P3T7GPEgYy83mM9PrSQET8ien0gC4Dz26/j7z14dsZAUxI37qEL8sfnZM85I/0amQHEKQJCq2w0W9IOggT0Q3Z5cuH69VMFQH4w87vr73R92vTF1fnEz7MX2dTu4RpoNutft9+d4Op2Kgrfd1xeluns9/v41xMMS17dtdW62aDjUVv5japodWl//UEajbTp9et5s3THm5uYGz3/xC79+5tyZv7RydoUOH1keb29uFcVFFhlMsmur72oBSTzPLtU+KyUoEwR6py5nayXAlxIBXaGAkQ6otmg2orEGUs/IJtQuX+8t3UrIUd2Vgj2ah7LDe61k9xeLdNVsUSuh0UvjjmTeHi7EO06TrH5uguW8ZoBAJbFjt4yBH1s2mbP3iveSUX6LDAAravjY+znG/jE/EnoWhk0bBfySpusAQ1rZqIL7xp1hjSPCLXiqPsk+v8AqoaUVbzWYkM2ui147DjWNbrtGj13bfePHyKVKFMBwdMB7du0Dtwia8Nn+Pa/FjndgsuY9jNPPhIurnJwdVMPOpCa0tTmCRb0LruzGskslzpBuPH1Vm9paNz/Z2RlTO61y7uy56XTSPj3eHP/vL/3kSy/pZ+v1N96gF154QVfJgmCkz90f/ehHttjD5+tW3iT6OgUJ/bLpbrB/l8XcHUeAkXz+I2AdlLH7+XYf1gAPc+TE6XVV8NE//v71fVijf333Kiuzbz4jqG/RbQhM+rf9ZH7fJrX4WI/++aQqZA8JYnu5fX3Pra4v7okH3X63nRHVuk3T6XVaXCw0N1dpOGxpYYHps5893pw9u8SLi74iW15eoi//xJf+s0OHjvylIiM6cugI1elkUCdTBQNlMq2DKnWgdqbc6vrffESa0Jt4fNG0R8uNBGgJn3bzQq8enotXRqSEM3rjeg+x5mvi+X8jQXhw9pYuWp2JVEOJBbj+a14mdvAed82rAov0omyF8AO17TuDJV7PJRQw3rGW4viqBzzqtu+t76pKX43QWjyIWqfgYg3/a/SfM3yDtIN1vQX4MJaFAhZPdNRIdFSfg1psSi1VYK369T1VyQ0lMIfBrsgINA6zfN9GAo1SSLU5Cu6rA8ZGYv4sjaLN+whgsnpqxDoGeppCHEgUXA+287frrGQN1ibA7iYn7olv4M224yC9tcZ/Nr8BVQv6Coq4uKq6qYrvx3oeilNpnfaif7UEiDrD6LWoBlCdp+z713ktDRM3VGWgAGVnPOG2cjl39jyt3tg48/4H7/2dabvzRQX0n//85/n555+/6bOmGUn9fJQ7WLf2P38onWr2E6DmQZ+fWLFTr4R7kMZ+PD8fxgAnqH/8j2Lsvr57MWY+I7PxWA79QOoHYjBo6I033qe1ta34oFLIHwf0zjvrlfmotO2O/fzTP/0nPjee7Pz7G5tjOnliRdpKdTyeNKUptpRG3xJfIXpcgo6C0zyC0A+Fgp4Yxl1oqhsuEq56FYkOuAX2EuHT6ettW0RbQEavOk90OG/DYy+kO2A8+lsDX7gzaiiVUaWprjnfGAUAACAASURBVJhxSYignx0JnMSiAa01YiHKaolEhSUUu5TpimiYE44nFJYjkSBg8VY0nNamFGkGj8HhyeZ2G+BuwpE1PUa8K45UNOaBajZ6+Ug6k8Aq1ss1pQYogbSlEKV1CjOIHubTQkLJgHE0Vl3MU2rZXSeWjqUT/I+0ppfu/WHyD3kVLmNKnNLXpSdXjnpKCGo4egWDTuwNhby1EUfqxu+/7fF2WVhYkAtPXeD3331r5fy5lf/irbfe/7P/4B/8QxmPd5IPBV6b/qxqxbutmPW1mvbX12v5WQMMtjEbs/EwxwyMzMZjOZBZe/311+nKletxCl26sJQBPfHEBfnUpz7NN258U86ePb04Pzf6ny5fvXzm7Lnz1hBvY3OTyfkTJaK4hAEngT4AZ1QvCaDljK3wbT+Iui5TkS58SxiQwrkTzWHQfcXFpeBu9OgesYeK7YvASTQqI2CSphgGTE1018+ViiSLw5khevwlPV59x+ySWKHe+cESjaJw05P7UBIUupORkpYe2eQ22/AGfYLRLg+zG6gudlbQC88gTyO5gWKt/uOleL9joF73X3c/sf8Lc7QPtqlsvNTFUf64SYAdcy1w6ufAOeQ9Af04O65PyF2SJg3LmJiHIM1UN4WNaxOTwglXSHoL8mgUUJPSAlToPOgSHXuiqw5tb23xwuIinV5ZodUbN/70mTNnf+q3fuuffmM8nhiAOH/+vP2LsshuUuHuTAmAiKb+VR2IdLsap6kCUss4CmaU67EPnITZmI2bxswOfjYey6GEV/VdUInjrcbGxpjW17fo5Zf/SG5cv0ajEf/H11evf/3k6RWan1+Una1NJScw2tFL9IKhZBOSa1mDewGcYUG/BJuBW3+TINJklLG2dgzPCjR6MZZo19a/OoTIugyszXxdX9PnI+zPBBHQ/UA4PSwEOuLIbzAiXalpiWHsjTBro7BA5SZhAYiZiNUgTqTbWsTvqO9wkDa9N51zREoWXIJt20vGcM8JrOL4NDEAfkx4j5RoFQPcI9w1tuua0nST1OtMQ918ZEcb9/HI4SzT2vfEL9HkOC1x4/pa055SpHcsgYXCri2ATAmDkQj6ZrkGJbcETANmiesW5BGOJsbx7u4oa9RxjJ/rWSdx03u9Fcc7OzS3oDYD88P19dW/PhoNT5HbxNPzzz+v/iMGX2H+h3INvvqlGWREXnvttZvq/m+//bZ9KS9BeX1KOv+IpP3ZmI37Hp8YuHun+ulsHPwB47l+Pw5d+envd7so6s/Hjx+n9957x+rnX/7xHzs8Nzf4t2ozpMXFQ7K9uWUcA25K53FlMRXeHAQbL2+X5umSWACjiR2iYATfrl+em7Rn71dYlcNOFC5n7q3hf69W7XDeaOhEvA9fIhznqyJrAkRACOtwI1d6rOGINv7kfqk1MxmZvuhVDZwIw+GuIdxb8xPsatnZti6tRdWoCFrfCcOgnbLmA/gRxx8qIrdRcfARgMVOpWV3V9d9tewn23jaIHIq6YNiFA941ncZm87zVtzArFIv7RBg07mrNea9BE835S2Yf4cIxTcSmR2osNXulQF4UNHi7lrHPAebxUs3UXXyE4+/Q3kDJZFUJKQkbpICq18HJGbnqmTLpsjC0lK5dPnSF5586vx//9aP3v3zb7319mRl5Yy9W4HFrfha+hnB50j/VaChGZFblXIU6N/LAEcMRPu+3wn+9nHj8B2k8XFoAbDvYAQoXcHAfpre3MoBtr//A86Wvuu4FaFMzw2uog/qAns7whr2cbft327+92poBkTTyfqg1WOFsggpZLj8Srj+qs/N97//fZc3zg/+ymBx6TOLC4dkMtlp2+ibWoLZCQNNyTU8ImnxSFY4Wu1G+iNW7yUTKu5JASUuDEoLnEalt5KHkwQhJ+BZE0G2wrmslEkKcB0sx1E7LYyxQD1ohySYwRiJoWLeMEeF7ymkLQwQEQdSEMW7VIk7g0akL9zv6VK9mKIhxgTKUeSKaFsgz4j7oQrgTih9wzjdldIBvfK8JDMQlLUo9yylOFton4nwwrSMpeRqpGcblc5Ct3alLaR20p6faqagwqnFjOZcw2QpJJfIIPci0D8jkVMZHYELoc1vQBN2i3xKzhCIJhX05SbaALdR6vNrqTkbgaMrzOwNVExkMDeanDn3xHD1xtV/9amLF/7uN//Jt/727/zOb4v6ZWi2A6Zl/QG3Uf0860mqmaMqMvZiKNDpK3DwrMdzF6WjgzbwfHscXVipd/yqrtrP8TBIyHsGRm4XyDRYaBDRm1Htuffq5t89NI2oxl279w9DLW0m9TiP3asdnJuu/FV7rinV2w19QOlqSPkVtxu3Wk31569vXvZR538vx9WrV+3rdgO9OYjSHl70nL/05Rf+zLRO/k3zMhk2k512zKVppNaesyhRT4EKR1P2sOusgU5bFytYr8S4iVc0hfXaTQ2OgoaaCg+QSK84YTEIk1FDiDCfTFU3TzN4E8pRj3oFflzgcLoXuTWBS8ZJLMALDOXjiDs2h3fEd1xRvRmed9rJxIYbp8RaPLBEmMpLh400yptLinusi8ltbEYIYCwopx3i8ab6kSyw8kh1CKb6F9W1WO4FsylwN2MUpaxNHQtM2N3LHaUrQWUohEQOcQRMXBBwgxJcSlS1xA6Eo2Nh5E/cj8wlwxQJpmQAOyuXY8ooevoQSMJOT2Vc7UgBQQBcOhKzS664gOWavm9xzQJYRoJNTEdl4JlLa52jpR4+tLy9vbUxv7668V/Pz89/61q98YqWVBSco6tvf+jPGrT2o7mnbvNxaxoq4dCsz1AFZo/jUBCl1/zVV1/d16N/GP179gyMaCDTD4HekKih6kSp/EwnShGykqJWVlb2pf6o5j+6f2wfgVT3/4Mf/OCxz4zoDafBVWvDuurQD5F6Bbz88st3XXGo+6F+acbgdjcttq+vg1Oq7kNBzh/+4R/edf52z/+9jL2wFN79INRz/ZVf+RXa3F77tfcvfTBanFtq28m0ljIcqSyT1f/D2YqwfrD0BjMYpQKrrkqtS2QtyHuQpKi9lJ7sgsKXzPcvEc0Z1mNdWI44U7xPG8HHNdIkJXr0O8BBOPJvBGbrQkALwSWpuT6HNX3ADj8FcFa5k8RYNKebNC2RMCnZcz9pmsH3lJqpCHivm4I1dljCjlbC4N0CaMk8UCnp2hriE+hg4leBBONOAJXXQI+WRlwUXcAcKRlqK0ecdmkM0iZ+3qF0DoSZZZWec1xQQaK3LgxovTePhPucwOpEBImYAmWQq6AqoyIVLzYiLZIsaSUX1Tm9nhW1HYI0SkfD6PYMGqzdpCE0EiC9adWWvePDRw/XN19969zFZ5/+l4Tovzl35gm6cuUyq2nhbqPCT3I3Xz13XRjD2FHvUVUb6TNUn2+PS7M8lLv0C6qn733ve/ueddLnq8YCnbPdCYW9yprsGRh59913rWuqTpBOjAY2RZxKjkIg0zqkHrQG1P0Y2L4GRN2/2vvuFRDR7T711FN28bXO+rCH7lezO3ocem4KGDTT8VHOTdO2ei0UaOjr9fh3B39sX1N+aiet/35UIIJxv9dX7xd9UCiLn4JA96BjvDOm8XTnZz788MpPDJuRnk/d2tyaQ7NbaFmjKgDfTPRfkUAoqKmEOiPVs4JUOiHqRa8yS+5nySBKPba56pgD/XixzjbMgMoFSCOltwIPViiFxwklwUXQoK9AtGqROqod1aFG2MN6nGb0fqOO5BJ8Dm856z38latiiRfP7HhiJ5b2gVGyUsPo+Rs2baC1ZD99KV4A8TRBB3ASdDAwSeSPojuNRIBOLESOHzkgQQVNxc1XQgPjYAcG+eGPFlDQXfhTG2SJLxYEfA6GLO6E7HGD2loQfcAbCcu3EnrsaHrslbQsDEmwiUJjIzXrUdkfMf4QIKerEsLtzstYwTXp5E5tW2k8noyaZtQuLx8qMpn8xaY0v3H+/Lnvzc/PmUX3bjAC3twPf/jDP9Ya4eM+9Hx1waWB9MiRI7lQvZfn20EYCgrgB6PPcX2uP6zyl86X3qI6dwB0/RYCDzr2DCrrRdYUoAZKvfAaLHUVvhtFacpfJ1Ib5elE3in1fj9Dt68XS7MHmjXYqxtNP8jPPvusAR2cx6MYmDP9YH3UbIKWTzTY65zov1pyud17dfu4hvczf7i+Z8+eNTCzW+2iyBqddMHwR6sABbMKZPQGv9/5xYfDeCXS/rfD4fDHT506JaUpNBmPS8+9gUJ0WeDxgKZzyO1HEqCAbcmSKAP8yUiyIyOSUhDpjkTSO4OpKxxEi9uo3qCbbGpyKcKgdbAJ+4mMT6HNkZJW6/GmCPAVFApKhksRJDryj2GK0XWsY/i8S2fPLqhQ4CwkxMwM1Uy6ZMCDg1NVU6S7IjD96IiocKb3NrjJSelzUhl0lEzsBIsT9RQC3hOn7SSfhym10pQHCGUMNEKI7MVSXl1CIxhDQS+B5LokzwYaHeSfCvc4Pg7aJBooByUnSk2SkqQuNeN/KB0xBFkSZ9Km1Kgz+qegJFmebFAG1AxK+eDSleULT134vcsfXv79Dy99SM2gucn1Gl/eimH1QDWtexhDg7guTvW5qUBN5+K73/3uY5cx1+eyPlf1Ga7l+YcNKnV/ACT6rwIhjRnIpj/I2FMCq6bn9QLfbWj3VwS8/Rhqh7wfAyUo5b7sRWnhUYy7PYT0w6nZrAcZen0V9NyNH6SAQW9m3OD4V1cu+tC816ZaWuqH8dmXvvzFH5+MJz+9MD9Pc/PDur2z02j3klojpyHURWxQKm5BtPDShbMkek3RMj2S7eg6LkBYo3MIWyOHEIwUlpr+VrDyiv1zhq/In8C5Q6I0oACkdeJqpg+SKCFhnBE2HGkWgjPyHEDPvsRDYWHuGAux+4KKBliyUNb0JajSSV29wAXxSO4uv+mlobKNYHfZQl0S7mY1FT6dmKfGOzH9HEdZQp1Sofhh5Ky6eyJKWOZfnycASxFOyROlwUowfJF0xq0R7BUBEahEC0SAWEI+JZMpHeRMbxI3yQvqbNfoGaxY1zN10AvTLjCB6wRcwFVFakvzi4v18LHDevv/J++9+84/fO+9D17vO2B3I+RQ5tFTLLvySRz30n38II79JqvebWiGRO8hBXX6/V5lZh6ZtFdX3Y/r+KStKu5naCr4TkMfxzqPClj6NUc0f9JS0e08RG4xnERQnJ9w6NCygqFfn1+YP3noyGGq0yp1qvKCUkwgkUtYZsnshj/pWcJOpPFObTWMz8j7rZhzRIm1b1ioekM0j2zR9QwcA/17qVjEB8kxXuQun5Ujje/1HE7+aLI+PJ47wRUy4Y5mKtgom6MquvfbiA3562tYcXEIOAjVqgy3ETm97CGoFHjb/RjRi9Y1z5GkCLQhKHm4wZozVRyaRYbE+w1LuKFmvSwIE4RUUU1tjwmL0BiwZjLJi0WpLHJih6RMBVKbSH7o/PvFSvVSpkg8MSaQ2gIvlZRVxfWNo0fbnwKQ5xiihmCIAerMQ4Q58A9lPQywDoJeyc34601VxZIOaNGmGEWyBIXM0QeYhSeVZFia9tSJ4+Wdt9/+zLPPXnypbdvXr127Ye7EtxrOO1BS4ierVDMbezf2ozIws9WbjYc+AERuJT+kuxCi9PdaAlJUPplO6P1336PW0s8qPx5aie7FF1/81Nr6ta/NzS/S/ML8dLKzE1TPWiE0oWx5AnZhNIFHVlygSJFcoAYzIL28snFf1g+klm4pb0zQcJZwLqokCTHOz9MhkUOo/vvIkHBiEkcPtXT2rUSUTfZQGXLcBLsvO3wmmHmFmoeCdACyQz9NoMCi9hxlMeHV2S4FR5gpo0y7dGmfSj2jtzCEjaIY9t3RaaLWk+Yhzrzoev9WL79IFo7ayL7EaTHcQ9KeXkBlCZk2eVPlaK8XDQWjXuL0Ga4hmUklDCehJ2cfGl4XLsdsGRooIfjuymSUYt4kmoDt7CddIqVaUW7vnW7stzNFYcqW1MVxqpu6CKg3mkup0k4nPDccyqHlw4pa/+WN9c3/dTKZtJ75uHX2dmb3PhsHbczAyGw81AGgcTsgQnTnLsv6HiXiKhg5tHzIxAeX3n+XjizP0dr6OEJN+++N5uePL84taaqlbWs7iKqHBAECDkwqznUCBoGDiLYr7rMRDlscaQkBSZSoM6JCL5XMrZcCuwxf+Fc3JaFM14PGaTG4moAmGuL42xMioOF8yQpRJ6ahRD3mQxLdeZM0S1k5MP+tkvGwh/TYwyKIssHQdTarYygwPXCebAUrEGYBqCKTUFANcb8ulJXkpqIRx+qfOtfYMBhldxMrWYrIbFKQRwJPoBcgEj9duqGzEuOktnaFD7F2wPgeKpxwbcvUiPduFpyk801KTKSY66z1QuRsgxOlMu3KF76q1HFPUyOU6SjumuRwzcRLibY9pl/261FS7NRVvTo+TVSaXE3O01qnh48eHv7otTf/5LRtzzDzOzBg63/W7qPV+2zMxkMZMzBCZMTJY8eO2WpdU5iPghj0SRsP8kCEqVPDDY2W5ujwiREtFqIrV8e6eJ//4PIHf+bUykoZzQ3H4/GUW/U4sztdumU/CwoAyJoXicw47CI8DnrhvXhXthoxKTmv5O7wJvqtUY3BSjvFNwVG6535qgTNhP2vUI5k5xOPZBrVWvwMJkJ6jxUpCJ4cLfYJZFnpbDHCvp4ISZzas7awkAYflBZeYeE3AvpE+L8TVC4gcFYE9nBOZUvXGMukjdyT1Z7cVp0r6kgpUZFIPrE32it5SARJtPj7C5Iv0kENKHwSBEbaoIQBiBS42REBSoGkLOlGq1WhYkb0YK9wZC2qJ5SC8cvZ0QcQCO5qkaNguxyW8vBUUhT8BOIaq1xVSYYIfGTj5PM00LYPKaXCva6H6G7jmTy7eex87cYshZaPHDry87/wc1/6Z9/6vXcuXfqQ5ufnaDgcJbjHQmBm7z4bB23MwAiRESY19a8fUOUrKEFoBkYO7oDVdDttqU5aaqdCE57S8vI8vfDlnzgxGPBxjYZl1LTjzdoUb4FH4aTecQeR6vfQQSX601YqvTwESvtJLEQ9wc2tYBZBMIIocFIN87NY3Fu5ACTYLuzY+1v0mAmZq7dPU7pD0V7CxUsNLheBDiNb77GH/SgcdY3fCOxZ6iidlW/KeNhpNbF8r5nYSRZprPAp45gTHjNpZdZhRdCbx2zTS+wf1Q87BgHVBEKUXse54t183b+0pBVdL6EBvq0lf9yiIxQl4cgaslp2Q1x35mA0nGFMBEVaSCQlQd4ikcOnBHCGwc0oYZ0a+mjPDzWShNkS9bSsa1UC8nKUqhkUnV+nHWlKpXZolQkuNSmJtluxo+rapWUIe9EIx7lLeq4l+LmOl8ygZmFujoeDwa+Ox+N/rOK4hYVFEwtANaK8KiWGz8DIbBy08Tg2bNnzHKMCD1XK4N/H3SBt98D5YFV00M9vd6+Z/tBjV6OipcUlevLCk1zmBrQ93qEv/dhpOnlipMHil+ZHc6cbDQTTdq5S28RyV1MXTfSZq9EaNcJcQIoQfoRbVvQKoZ4cxCs6yoO1SJcOVNTm2rZAAMKZeWGP9BXS2aivWAgMp/ZqrVA43u1tUOz/iqRKgBTwFaxDXZQ4wH/o5CQuy4BG1H+BdE78mZx72/EpgyRZgleCbm6E9IP7czFYtg4gwirdmLGV4JbqNvg1wALgCGW1BjUWlH4csXl8hYradcO9Oh3H4p+yGhTuG8nlYDBuXTZUO76GOEOIk9lK4QxfOx2SXWrp7dG5IEHqCRJqdjHE/SPhT8KVW7Q6DGFxa9xjqTC4bxnkFE80tbGP8KLNPcPsvub8Oxj0GfbzThxqbr4o3FW9V1RB09Bb77z9kzs742PoCYMyDRrnzco0s3EQx+OYGdlz5pV6X1DkRTUzcrememgG9ZgMHg6HNmca4NUVF+6tj2LciSuCoa/R1dztJGzqFTA/mKcd3pH5Z0fNsckZ+c53rtatHaLFq5f/laWlc8P5pcU6nbZCtS3sLXQJsdcZAdmLxC1JY/EcdJUICAYYGpAtNVZWZ3FEpkVaYWlihV3DWkPcN4xq4xGlgZMHKACexqjUOV0AAFDjQd3au2kDnpZcLJLkCMlAHNRYY4uAr2qxPwUoyTchsGS5VAkiZAENtWUohTmIn9VzHzXEIo25g1mhREsCnb41Ugnmiu/Bni0t1IbtvDdpqS4R4UiD6OyUUgPMdfkd3BI4vnShMwApcN7w69T5uJrKJf3a3Xwl1L1anLP5cemRMU6bGj2MQ7VcBYmH1EGRA1WomVma6kIgIQKNo9aOmZNOJM4dqshtGbyz6+eWLtECGHZ6Drm8Q2KBNtjPutbIdwF7IcvVOe4J/Old5RMNdcImTYiP/OI//4tHfu9bv4fOvHzt2jUBGFEp5ozAOhsHbXwiyzTqE6I+GBqcFXw8++yzvLq6KmiydivpLhqzUTSFO8hDz0+71qpsVoHIhQsX7GGkDyE0ynpUYASGQ3camqE6deqUPTSVv9MfevzK8SmDUn74/R/W4QeD+tnzz5Xvvv1D+urXvkTD+bIy0evaNLIzGXuXeIukEkHIg2rQOwRmVgRTkcQM7FQKjb0luKvB1WC0K3HHjxpMVyzFQwdRrcuZERMVUGAdrj8wogsHtdXqFAYCKhzWpHMnkdC6VjTr098UEC4ayYV1gCwFMuwe7enq3hEYQs/qbNfqbBjv1AcKbeRYgsbaWLkISQQBSyXUsJbaCXJGCE6N40EAbYwqiteyAgVpl0L3w1eSqxe8cgrZkZuTSksCtshROQAC75WKa3wEjXGdYqFba0Q7EDkftjGmsoSnW4qfvAoCybD4/Hk/IoL2uURlK+bTS0BIKkWBxo9fUCvqMs7VyzZSYPobIqkS5CUUaCLR5PsPm9bC0m0PvXQkQV8W3KoCSn1PW1Ut1jRNKfPHTh5+bjQ//LYaJKohVb9302zMxkEcn0gwoo3j1OkTJRkN1JrOVO6I+vzfii+iQVC/NMArGLl48eIDm4Pt11Ay7uc+9zlz6gs3U1GApa55atuvmYVHMRRg6LHdyQwNSho9Xu1lpK/ta9pVuqtf65vrsr2+zVurIj+49nJLZUInTixd2NzeXo7sh0eOUsKUg1CrMGFJxPmSht3ZXFeCyWErTha2Kk+l1mJGKaF+lWzcyilq5WBdom2reNtXAxVpisodgaGG0jPX6sWjbAhvVCdhriaIbBplq7fcr7GEjx7z3rQNamREul7Lm5CsBp81eLy+f1uY+7SHZmfg4uCgxqYdCEMuPEg7fI/URJ0hip56yeqCftto5ESDPBh2wHAfxw8qLQG/RNKoBCapqUD2JIsiC7bjV5yBJErx1n+liPuqWFbLbysP8RylNr/cirTSys7yWm4BV6xuo4khzQoNHAKBy2KM19Tyluj+GzjTz7Lg7rMWgCXuxth9AaHEZs/+XtDwufjt1MTdKOEOLJzdjcBbCuil91fJbkM6y8PhgBbnR4MPL33wMxsbG//n9evXN2SWBpmNx2B8IsGIBjcFIciAWEfX0cjqq2ptu3vo3zS4U/RR0YyKZh70M36nTriPaigI0T4zcDTVgK7HeqfSx34Pna8LFy5kE8O7yXp1jnU1p/1q9Fqp0x+Fy69eg+l0KsiwXF91cPX+B+/9yvxo4VPzS4eid0LAEhg/gEMAvzCs9SVDKjGqB+Bf1Cpgi1jmwUmL6doq6bblXEbOooO1ZSldUaOryHTbD0JoLNZZYKMKVzDvruvy22ICDBNeVBWmIHSFS7kdrAlSS1qY+eLfWabc+ceCoBGtcDPdEeZl1l8HVI4a2ZYCda+kzBUGJzUNVbPzcZbEpCfL6bxgo9qRDhtJvREobGs44BOa1FCmIJJtEQyLQCkcEKwIoI9kviOlvrH9Gs37kSmDe24Ns1zB9dDkVkV33pB3E+jJqepJhRbc2jrDlE67E6QXKIBucmdBBa466Ov5s8H9Hxu1vaTYnPF+QOJWGrXqXlqk9bWNn1pf3zhTa31VWyFoU+W9Hlru1fYYcKbWrLIu1PT5szujORuzcbfxiQQj2i76o7aM1g+Z9qRRXokClZWVFV5bWxP9wKkCRz+I2rH2IA11Lr0H99J7Hel5dS+jz8W5VfdQAJSzZ8+yZnIApPSBp98DjACk3Gp8+OGVn3ziyU+NBtqYt07TMCRqAG2IIqVGgiF5B/5NBHJEnJommaVLXlD1qF69jFGCi8AlXT18qSpufG62G2Gq4YEkmQCdW5j4kt47t4GQkpZenLxQryIa2wSmnUY2qBGrYBhCAF6l60eMKXa2KjrEoK0wDNJQB8mL4pYpUXWIFrgM7q4UlIG6hveU90e2juMeSSgKGRwASeK0nVFbjQ/qwAn8Xe/Ei+7Jvu3ihBmdaMNdtW/54gb5cA0L1rHLYsRt1CiPBd1q4HoCj7VKaEnMIJRqZajWbEEctvnZOyAazUiW+1I/7vsqcfLOA4Y+22jIaC0IEki08CO4nkGfDaOzHjLLTki4oWxXpfJgULZubJ4nqYtNM6C5+RHtbO+AFH5fn99bDe15pdlOfC71Sxc8CkQeYzCyZ/PzMR37Nj8HRU1zYOndyJpoANTvNzY2RAEIgqKWPj4G417m/75uRH04aXMn9JzZ/aVZDs14XL9+3RbD/d4ad+LoDIYDGo68O+nG+uYJ1vcNGm3watgBXmNmZVEgXuUoloC52jXuLRGiK5VoAotw6YYbDmy8fCA9mWsWZCLdUYlby4mE55jbkWQzF1vguow0xBQiITRhLLB1O21nq4WeeOjQ13ilovoh1+jXW2BEko35HU5063gGkaTCkat4YsEeMkbmQKJCUUM3USX9WbLlCrdxR/ibnP+KGlEbQbWgfS4TSk5GhK3u6RpG/I5FhaGiNRVsNuYlFIyc3+mb6HCboN1g55DKRcJRzDU/wVcuIJra9S0AOOl3m8pk7t0rzoIpHUckG+K1FCTdWpySaoZ1htJKiNDf2wAAIABJREFUi2mvxUt+WpBBc0OR0sLTVjzbwd49mMPmFyqetFSx28s7Hhg8qpS+u+LlRrcsqeOdCQ2a4ejnf/4XRufOnTUJvHqNPMjnd/fQkrYCEc0yLy8vK0me9bmoWdj76FVykJ7/n0Qgsu/P/48yDgoYOdA3QP/DpQAEnAcNoh+TPjX7Pv8KMPTB1ZcX97+gUNLsE6ziIe+9E9m2tpWGoxH94i//4txTzzy9tLOxHXUIe2C7BtdinpEwi0SDEXfWiEhkreXVy5WQ+09HeqREaudmnqmDKKigVUkxKqt17w+PkgLLUrS8kQxnvRyChXDPdkCRyj1v9wITEnRkcSoJqiBdKqRgEa2RNHrloN8Mw2eWosFMoWzSAzZnyV6yqAF4voRDqNukga1nVDiFyeCChrNqQS4EGMq5msUTShBScy+pYpTTpksxcDqbARIElcawVnHYE36sgqaBTiWmjnbiGmSrf9j5cwqKkcEwdXXwiRUdAhMxo5cijENaspKbQYDwipEw6nfs6FQZT19UzGx41ko62HGqgoKBHExoSIU8Qxi0lIo1qBfFOvJJ3IvQcoM/hESY2sDXts6feeLEycVDC/b8Gs0PSMs1ezU0A4IPiX6ut7e35VYZz4/6eNizA5uNx3b+Z6Zn9zjQ9l4D5Uyvf28DD6s79Z3RLAgAi5bGtJz21ltv3XY/4I2cv3C+ee+Nt3nzxhY5D7TtigORGvFUhCXsTeMaD/ws4Hfkh054EzzXwA3VGqSE3zdJcj5sceppBLh1QSAbTYJ9KeuESjarUyqthGRCvJShK+zommLcjIpMvysnPI0DImWtUVQBm4C5DSGG24XUxlM8leBv0lJt/PiskuQd/PT34fRhMlzm6KgXvdg4hELK48lW9yGlEaIpReNcA1y1CLrFiQywxK9J7JDiE647k6biXkgvUynmzu+T3pgWhruu+kw1zNOLg5vi+R59XTTmg8NbvIlx7c2NrFVCKoxzxcm/nrwSnYRwIDNCaaqn2ugZY6xmz39km2FIr6T1ElLbuOrIbe/EylDF7Ua8cbBLn6LJn5NcvM4mkY2jJkTF+u7GOTslCUAtBOruVd9UMIyCZFKlNmXY1OGwodWr28MrH14+NzYyvt+Dc5bh3d6TzzKymXpVVImon22YEc74srNxP+NxND2bjU/AUOm1rrheeeWVu55snU5p7fL1la31zYVmrqFw+/AFcYVFOtiTrqbggp5oNrzi0fPpjAyAeLIjWK6ZPA/mpFlYODOkc3IPw3LYqlX4djglJPWfFOzMmrYm3tcFRQ5tWRONcSI94ZjH+I6QRpdq5yfwa0sVkduNVDA3avQYTqcLWKF6D5a2ZsUAjecIBaPcXvq+2dTG5hxGVP+rB+7Q6dQI11SJOaW/0MtagqCEX4tOUo2EBYAehRwGDYX1hzYqY34Aio6KSBt9bwoQTc2iFAikVsQokCxlsBRc7rym8UNY0gr4o1EZAYE0txPdZMKHLtxDavxSj30q0eOmhk9aR3rGLZFqY0Hr4WT5mmaKcXsKWhhXcF2Eu1vSTqkN5KUW8KUZ0Oba9lem4+mSvkCzIwAMez0+ijfTbMzG3cbsDpqNAzdgzKQy6zsN1eiiAdzm2vpXiemcPhi753rtbEPgAtLx/0IAgZbwXTwDO8MDTfEv74svJQyyzJ6dfRmsje6CACkpDk7uZK8vL2fdIYoTUTzodKPpzeaVIgkLj9B0yk1FlCD9IhdhdZYovaDUEV5hKm82J9cgnCR7gsFfdVsut0gRVFZQRIqKEEQ3Afa8RhAOsZYBiIa1ln+hCOvo9JcMjCAqh9gYHJGYBmCDgn6EqWUFplALFdcBhYw5bNK5N2vRt8+vp4A97Dxfv97pl5s6IIrTsp8bRi1GL62UhgEwwvosrplSRtBAEaRU96Enyv55KVomzp7CaSlX0VLPi0jhE1M434N7M2pvuCh+N3HUBRnuuQ74hsNRnZufo/WN9S9tb2+ftjJTW627tcriRyP/mpsbmRR4NmbjIIwZGJmNAzcgR76dJTyGpuctAVJburG6+vWmaU4NB0PnbChDQYmDYGsw+qXZcNFFcY1pFTiRwPKiIsJZEDNtbpiFlmzAaowDNwqLlnhRSwhiCcf7kXDgFN1kpsHdU5M9xomGCBUOO0IpXXM4StRivdZKFBcoF8tY4Rvb0RfvFV1qpIudoevI5EZnlIH4hpZ6Fc1qDK0kVgHTwtk0SbB08FVcgyspI4mtp8s7OMENNMWuxQmXdqQI3IzNmSESnf+rIClFZmUGInHoggB8QntSOHIudgCoeETwFk6MhaPL3ndB77DkDfJQ3NFZeicR6S9QPziaDjooLUnojVRQsnJKmMeFZVsAvsJguXjqxrTXFKTYYkASbvoUaS+RaGmAv1AZDCZzCyPa3Nz41M7OzrLxsUR7OE1dnR6lZsXQKIvOxmw86jGDxbNxIAcemHdzaxUjGLd04/qNJ9XIbjgYkRmQuMQ2X5TG2cEAyQx7LHhdwcreMA5tSBhS1HxYR4LfIgRyGJx96GBs0oJcirje+VHgtRn80wML6/nMSkSFQrKFDhzFa41+wtRrghe8XDeMR74/DxGuodLNR4bheFGJP4V7Wfdmgg0qXq3SnZpVEOh0muCydNR8a9wCRXDyX+Kv0MViTsCKSQOOTsOUJTLASYHImDxkSz8UR8/l0h0Hjpxh5VFLNgfIV/W9b8I+BlYhXhopnFWiFsu4AJfp9Y+7C/Uu6TCS5MuBnPxaFS9kuRiIM4mX+ZRg0nI0YPRDBfO5K0CWBJXurDsYjGjS1iPb2zsjAyNtvSWXAyTUGc9jNh71mIGR2Tiw405ARP1HNHuiyht9kK7eWD2sUsPh3FDatvoKGit50DzRwQXrSw+QKpLVgFtT0YCXRT0fnljuDY+wAcFshsFgWxJ1sII6ngnKRHBcRRB0Ske8oAR4MfNyKm4Ur0zO6NZaAKzSqUSgXYY0Rbrg2sWzcCJJ8mU6bmUbXQcdNdUtMIhLLINsjHE0w0S/uCu7M21Dm+LmqX4QqHuEADjoJVZp4aRboHN/JlJ60boDjO4PwzAxpQrjEXSzzYY8YcjBoH1mvc3hRlvRRqajsfSwDLtcKbehG2nCOa924b/rcGyOu+JWcxKWt6FRjg7PneAp5NugIUUr38JBc6kM1xHpAymba71jW9yLPRwlLr1Cn2nLIJVSuGHjvw4Wl5YGpWybJvh2+Q8F/fpZupMz8mzMxn6PGRiZjQM3AELUsfVWQ0l4arikkt8333yT2qpNU3l5KmZLNZVWHbU92xEsAlfDRvo9xA3husqxYsY6HJTBLhoVaEsiwlQ4h6W6tvV2e50LlYhAvOnDzghameSuACw5KOBQS/Q1PSlDjcjpSYDaGb8ie5IFnux6T8HrNJCRzmkc2tcaFRLvB0ioiwSaoGDT+vkLDM2ky1iAJAoybNeVh1qL6MUDr2R7GktNSeZeKHk5ggMFARcZBGN4AOgwlMUdmZY7zFWLQIadrejykPWfBqfjbmUhbyFCaiF4NKGtCZFtnFDUWXC+jPeTCNz9uwbQeYY3J4PYS33g4xIOreJ7Sdf4DmB2U15LNx+d4W0H2dqE2ZbSK3qPV6nyzMWn+b33LtHW1uZtyav6HvVLunz58seuY/lsPD5jBkZm46ENfRjeqVGePv5VRaOv0wekWsHfqp6tr1MHXCXjaa8bLc8QTZvxzpTQz4yd8MCUlQFkQ4JFGF3RCqH1fWVkLQhUV/fukHDJQi0GZqphKV69hyp1fqzRkDbX+yiCOEkB6pBwPRfQaIOrAe9VhDE2j3fOioWPLrHQr7Ug+kZPWheD1CBEMnUBOsNcV16ILrTGt+FQ1jjH1p3ju1lBW34oR4RKw+BPZjUCCRU3q/fefyhnWNNbNzTLvvuRu3AQF34qwa3tKlEoC/muvBMhZ38+cEXEYWAPyBUyKTdUSE6gBQJLq7rKkhkV3XThUPpwZ9bCpgk28bFUa5njUu++MMdddrUXQEXfgTi2vGxVeoXD6g2LzAlOfdjiLSiAoY6SPXG8w4AhTIdwmcdzeZS0rZTS0KRO6Op71+vccJ7m5o7e8WOunzv9XCogmY3ZeBRjBkZm46ENtXVXue7tjOI07ulr4Fdwp6Gde8+fP2/x7LVXX6Wjh5fk/NNPZZa7JNkw+KgSZZuaTXBtfWu8BmHvhYJOLx7bijtxVu7SGiHfpB4ZlmFJSh1+SC4JdZqKcGUXSZ/y7BqfWYASAlusyJk7BAGKbI3QHBkdHBF1Bq5+DNVX2FKiIWztd1jzaFtMzqyH1ESRx7MYyPqAeNmVrChLNoTuOaZKTmf55OcQMjCMpT4sXCWaxWW/XA/eFT3zk2vq9FGJ3sCSDNyO6pHgjB0aAgxBsxvJHqrRHxeudhUkFUJvwyhI+SSBuuJHX7KMlMRkIjjCO0qpcfMUt3XhkmRadwER7k+k8Wgk9EddixlgxOA0S/Qu6PoUBrmXID3nCjNZCfV2FCPb6YTVdXVuND//2Z94rnzw/iW6evWKgffbDf3MKahfW1unnZ298SKZjdm4lzEDI7Px0IYCkX4H3gcZWsI5c+aMrK7eoOs3btCgkAyGja1cpbbUMQbDvCtT7NHHxZ70xUFDkYK/B+/DZTphTR5raagcxGv/0pNGBE5hbxafzUcgyujjqtLlLrLO4CyMTN6Hn5i5YeEXBfrRgh610YeNo9cMd1UOlAlKF7EFLNquIV129E0ypLiXWI/kCoMLpgKgY2oWDqMWA1ZFap5zWHDYAWeHQsm+L+xZJCAOyaxTYCpGpsPl1hXYp2uB0yt0RWJAgCSi67CprMCi8T6B7Lod32X66iYvNrM4qUcK0/pewzvulU+qhDA30ZfYDdRS2vZa39/sJ5McE8kMSgGRJ/Ii9kttEN2CyYTDwZ0iWdWK+lFmyiTpQtIVidRAkBs6dvTo6NVXXqU33njDeFa3HdqteTighYV5ahonj2tTylnZZjYe1piBkdl4LIdyRbTOjYZcZVCoSeOlNMqwoGg5juj5jzUzS+bPHZd4vlyxiPqQWZQp0bkmGrfZm4vxCsK71NGAyyvdET1DO0BGiTIHdWEoGBhJ1gxD8BpkBzf9SPKDH39EeRRJwqlDMkXv7X0rmCidTwYs1pmRvihIDSQ9wWpaWV/KjsHU9cgnxOTQbZArZgvYwYElgMCiQsbRUIZC9oMUEkWmJvQqyoNlqKOhdOJIIDiJF2mDuDDQ2KrlW+naA6K4JpBQxzENYvYlGbqwnwlLGBSepAicXDM1ZAxZRhtANGvu63Aii5K4F5ms3qHCpIXCQT9hYSaXCL56jCINwWeFUYmRHl0G9zDjRaVaN5yQOkt8FmQyuT4gGodq5g7ZRlZV2sQyJIuL8+GG7Gq2jY1N8ymZjdnYzzEDI7Px2A61itcVnDbtWlhconYq/njXZWcNSiny3Ond5RQKSzuEFYZ5vGeKXAjCz9otmCm2HPUFSyFoliIS49ZOJPmNjIxFEg3DejTiVcnVPnV6TzAwKVfTng7J9jiMaCXOvhDuMhHVgxwHG6XzGQ0+REUrO6oiqSNJUgpSPWGK6j3hKjgLluCYmokp97kr3vMFtQ4GwYGCQxFnaiApGDUcKqHgsnL0brEkArglJJ35vhnWFwlrFGwuoneVcPTgTEGV8GhvgEVcVgw1VNRUUnHEQdWBzSuQUokSk2QqoqKJnZdWsh9iRHdcVE7hUpBy44pUL5clsccgUFsCcUhYoeCdkPhm56HIxmR2poQ4Cv1pwiA4QVm0RNIfm3bYjEQ5WE2xrzsN5Mm0w6NRjQYNjQZztt3VG2uzB+Vs7OuYgZHZeCzH0aNHjTeixmgvvvhiee+dt2lzfYNOnDiFTrYhMpGQPKbAgaSCD+E/wB7E50Gi27zZT1H4gnv8aYJhWTnq+ZJ/N4kn58q5z61AMSLCNEi02JnzNEWyhuTgoIQA1P2qwoELlhDQ54L1CfqJAPFE6182mmUGa8At8CKLxUGRVtzVNJIeSZFQP3rv7e9RzlIqnAxbgmwocEz0wGeYh+X8VPTkc8Zm5KYMUFQUorI4FBmNxk+YWiuKgAia1GJFBobfKpr9i2TFBo0KYWjnFNbsK9gJZ2sUYyTs3iFdCUPU8EIxnqpVzYp7tHcZqegUwCjTuXbJ9M5RHgu1TVSWYhazwR/ATqctQiuiuFG4IwXBLIYDt0Tuy4bTZAp617C5yNrtvzNlmUbnwHpnHlZ/2Dy1QuN2bKRz5Zt8TJqCzsYBHTMwMhuP5VCiqzL/1Tb+G9/4Rp1fGPETT15QboAqbZlaLHZzvcq9tWf6f4ShpqCZHKfis1oJn1wW7GGgRq8WV5ukR1dBkAENgTPhbnUfz8yX6iDG8zWm3knBCUy0QlgLS00JvgMjlRCvCcYjQ3UTOiDjpNoy3Zip0bM2++8iHKIhLUNWxNG+D1LfCt1u9IJsIq7X9H8Lp9ce/SKX1V1JpCOjOiNHY1vQdLMxS4qAnApToiVLddZMS/DigHWrheA2sldNzKIzURhlNspkWI36nCt3PFchJYpoNYU5pTAyJBWFHgk7fQUkngCLsgq5zMYSb9JzeOthzB4rBhc62a9goRheABwqQSSSLPnEAQSzx9TI4Z8bBvI1nfCy7XA2k269JZD+qR1Q8e6GAFAfHY/g0tiBLS0t0PXrMzAyG/s3ZmBkNh7LsbW1lc6RWq45dvIYDUYjPxWzt+gsULtMQMSE6rLSXG2jkVsmM1Ikmt4SUbAp0aw+FqTQnSJWBixh0w0b94Qji1LdzdtsN9BSjeFdwWHFwdQTBGP5G06mWPhnb5fI8qSUGKv1AAw18jtR1Yi1tlAXjoK8WQitVSSzFl0PH4yortR0GgOYQxaFneUaaRiswZNmaXUkRj++EjmLjhMRYqO+4VeNc4Y/WeYRsvKUfmwcEimHXMG5RUGqOKMi+LFhaIb2RX4HwUY+gFLJE/B7qKD8lu0W06GEoyBXO56wZbPQRzASIGGiZlOIxBwmE8rf7MkcnZzRra+7NwF8YAzrhiIu+OEO/YQ+SX9fJ6MB1aYEsVVuAk8fdWj2Ucmtw9GQJuMZIJmN/RkzMDIbj+1QdcC5s+fotddf85W1VO8mK0E6zNJ955suYYMGJal1qOk5f0bMdxJk9bJDymwl4nctDG5jmGC6DUVx+qBUXeqquEI8sS9pedoJQlIcQeh4T1Fz8BdK5Nxj0d8ti+2PTkLxxvbAVQG8ouZQUlzBJfUnWaWAMz1H1qVj/Ia/hvmboNTkAAPB2mFIKRIGq6XDLTW2gcDPjDU80iBdxSWSPp1yOXQgcGMxZa31Juz15fEcVvBfJdxJs5wWU9pt0z1AmNDRtvrrLUHiLFu/LEV65FpAK1fOwvElZdgF8Es4jWQ5LNlj2CYa8TRI7YEY1I+YwyIkCUFhYhLZmg5ZsPc9trkp0rn4ghmUmmD2Q0appwZ+MnZwU2i8M6HxzgMo2XJ/8Unp2+fPxmzswZiBkdl4bEfbtvzcF56TG6s3aH3thjcCI6htIZRoohV8jeWsUyOgAMn1bpqIdprNWsA/YKQNvE9vp6RlaE/FM+vUaVBDLhzLdU5AEikCNtet7LgPPCGZTFfBSu1s6WFAz+it4zwVZjhT9NrJIEKha1+MjsdbAhtUJEuMI1MBfpAacbqDvU7hVY2CBxI0FaYeIU9NvIU5xLeB4SLCeukhcAJKZ0xYziOFIsX90QnwxnGSgD8jPUoFkBRRB7mqA8SobhSkGjo1LneZr44Q6gCtAEcydTgkxCxpi1dwrwGRpdTG0k3pGMPuPlIYOmfOE8qDdQARt06hDqc53jR9bels8QhCnZjeajokONTotZqMpzRtaTCayqhMvTkedzXFex8JgvxwNFuiHJJZX5vZ2KsxAyMfYSh5C49F+1DPVgQHYjRNIx9cumRurIPGI6RentYbl7jXBTzCuw4l8OEMVa75WUrJbiVWYbnJRKuz0IyWLWgRFw32BQ1lGAEmkVDnSxJ58yCspiYEZu3F+/V5XIO4Betcre2UqNfY6lpPDbFQCEtWjnRQLyhz7h7kXc+wcOF8lUuVvV1sp0iRMG+X6LbCEP1SF/6R0+kEsxScWd2aWZ5K3wckclZe0uFMBEnPMyPFy8hP9OpB7MZzZmvC0DNzGJqVfpYlFbMSljEu3+YS2ZKw9qeEnYIikfOXPS8DXEnZYCas5cAoDfBEMOcPDbL5pHRJixrQkroMWArDe0VAcb0S6i8oeGXP3y73kpAKcLrCEBiFrmw5IDKZivap+dKXvmxS3e3tbXuGPcgA+LB+lDMgcmCGWh0oh+5x7TG0b2AEdt4ayNEKXifq/fffv2tr+IM2tAeK9kKBM6j+qx9otVDWFtyz8WiGklh/57d/2+6n06ePAU6476avQXV57c9r9rK+L8rRmcYf5iXIGJxeU4g/JZ3CakTgZB8yfKikZj4l/oLQBF5nrChrbyWMNAcWs2mwiY9P/D7K/CF/9ROjmrtyDYvAayLbvogTHQSdW8Rb7UnIT6QLxh7xm1ChcE0AAN1wiDna6h39reQRnEy1sLXIa5wY9z7X4o5XyjgsVj1/oTWfwh3JA3imZBEoyKoCUgbHsbk2B/7ptpHaARwluQYIRPRGzyAOQZBIR7ON2Y/z94KbwchaO1ZKdqNzbXBHeE7fmQCd9v6UR/eefXG+nRw7nVgA26iXLLJEDDvUggMbqk7BbCkVqblUhiULWzrvmBQqA1rVSqN2PK20unaZjh8/bse3V0Zm+rnrZ0ZMBFbKHZ1e92Lo81f3ocBqNnysrKyoI7XN/yuvvELXr19/7GZmX8GIdlFVtKbpPL1x9QZaXV2ltbXHR7OuH9yXX37ZpKR6oTUAsqVCS3a7fFhDgY8CvP6KRH+nrqaaHXiYx6IPBN23zsethlpL67VXc7L9cnFUySHuLfiue1W+qUxTk79U5hYVirDvztIBMiXQp8TiVmWgEo1J9A5ow5IzLOYFTu/mQe6xN9UT6D0voEQ6ldWlsyX74xVQJtVhrXImLqp1wkVQDvO1zhAkGt6h/ysW39JaOOu1ze/cSbyNiZY3zMPV5SAuurHDbV24yl1FxbMrlTN3gMwQqkfMtTNzd0sKUF+9Q18T4KgWMyIFPxSpm+jiI6wN9VooUFLOExlIZ7DqEas4pHhKpVex6spq8Ej3ckkvheEMDAlhj4GhqLGEWYertL2rX5j1d3jU80AitebhgyDcpSq4hokMd87uAU/YzdNQ5qFOsMSeN2Fp9PoozHN+DF5YSpCWEmygQodOPVl+0zNsnZ4EUZe3TPL9E8uoKHmF3nv3PVtU7dXA80cBzvz8vC00kUG+evXqvnzeKZ53n/vc5+zZos/lvXJ01uPWxWU/A46u4Adx6LPvzJkzmeVaXl42cKaeSwpMZmBk10Dg1htVA4Z+Pa5pvUd9cfWD/tnPftZImzqfmEcFBXpTqqLktddee2jH8ulPf5oOHz5M3/nOd8w2evfQvz399NMGPvfr4aQfPD33P/iDP6DJdBq/dZkLXMqcWGp/4AwKaTUiMPtOfzCqAm4FTCJKukog1QEQY71fdM1q4bkk/aTG+tXKESHOdFmvhGolXVkNRjh1wxSk3sIeyQ9PzbSdx4gfNSTFcDRhpq52iDayYXoSgCDOrqR9ScwLLL+8kBGARzwDE1kWa5IflRpLD8ArJKazJGGFg6NhXmVtMipCsRqHn/1uMZGgASeXwlifYcFvShVBXSfQHrAtAEXUoUrXws8zMCUVxJF4iInLR5CiAnNZEUdKAr2OsOditPhRImvjZR7JvFi6+cIcHngULQBDMhO/g/dLTIG+oFRO+g7ISPrSivJZL/EASVXwelJ3Fdpupcg0XW9hSdbsZGeg4FAD1LSdmgrtdt1773Xo81w/2ydPnjRAogHy1VdfpStXruzJ9ncPPAP1X30G6vff/e53bSG2F9vWZ5oCEp3whYUFOxfN5B/EoYtjXZgitmIO9OfH1Q/mwYqHs7HvQz/kinrxQdGskiJgBXr6pQ8XvfkeBsjTh40ey1NPPWUrFP0QPPvss7ZK2T10VaHHuZ9lLD3nixefoZWV07S9tRVL71I9HqhvexpGFTRtia+OURFG2Z51QL964gQ06gIBhw9fdroghMOO00NfWlRFzOJsdifhnmY0UM3SBBvFNL6o/GQ5BKbghSmMYKPfbfikVgAZgCNnyXTxNSgTKXxgY8YUcEfwxejF5oadDawoopTAfQtzTsda+2W40We1yTIhJbw1arB1LThytAhqAmcYOcepo6mu4c6txF27KHi9kqWsEGVHjshc70PoFEWwJhQvlXBF8GYAMIMGOnetzwyEuxa2VRfkdRZ1UasFhZzw6ihhhCso26SkGtqbbPbs1bygxiRsLU52Zcr5N2xSo7NzcfwQPW/iHgP9FXQaU+t2Xm59yojWIItTUBoHXhU5LfPOU9ZKpfXNDZpOu7LKg3xh6Kpcg59uU4O3Lob2C4joc0SfNfoM1OeKPvM043rx4sVbPn/uZyDjrP8e9J48enw6D4gFRL31yGM6ZmDkAA/9sCsI+cxnPmNAAN4auwceLPs9zp49aw8EPRaAIV1RPP/889a4bvfQv+uKTLMk+zEUGF27dpXW1zfUA8ErAiqJLU01mkjxoBSxwfQbkc2oLn2Ffyd1sVxTHYVaLq4P6bXJC1Wn5TnakJ5WCl4Jw5jc40Nr1hYMgUhSPhtBuxKPX7XrD0NgA0iEQV1vt3q4TZrSR06hmDwjmKz6lR6zFGIZPYfqC3+Xp6AqZAfZlJgbMFJ65m/hZe9hrFRqLEsQqCERjkKNanCPwy4O8a/GdJXoxctdt13bYWUvHXnQFYqDD3F0TIODEjbbM3NS96oZkIA129d47m3lwv08DXYpPcys0hXS6yAHw9HOoVLbWZbCbcXe76UT/zuYHaH3EdwOzvuFQUpxp5jQw0ikXVxLXOze6xreFNtuDTZXj3xlAAAgAElEQVRzTHnXw8doOQVNp+PEQkfUO37xC+O9EwujPQ6Hm6wdZFsGA8Mwa6urVGv7wAFrN5jRZ5QCA23EpyaE97O9c+fOWZbzTkPLQfp5xzNQv/T5ouBEn0t7MQBE+v/OxsMbM/blAR+Q0WEF8iiHfjj7x6JfmgHRlYk+FHYPEJWfeeYZeuedd+jSpUt7evTvvvuuPQT1YXjy1HEp3ERRAb1gXFARjeyLrblLamx7RZeK5DYFm0N9ymuogFMAIb7KxSJWQ1HD3UZK+obpZmqtQT/Ixifh4Rki0ypBoUCugwXRyFmhEh3sIhnhHfTCchxVkhI1Bev6y5G8iCIBEIBEzYPh4GaG5BLyjoirwaIsVdJiJNgZ6OtCMEwHT5QKlMnMuYKvGbW9QAauBHTL2eethgV7Tp5JZdOJPuii3ty2hNgkur0lJkFGofOaS1lzr5jTudiaG02Fosg5ttgyzEKyR4xHynTeh7OM9EAjcTbchXFITFJlEI/DHraINz52BGmkZ0ILPgLnxP9b4SqPW6tCJx0qG5B10YpIQGWpSWsRBR5hmzPFc8M+t/f5WdOT0uzEbm7ag3JEtGSk5dwf/ehHd+R/6H52E2bxu1ln4Y/HmIGRAz4eVtbjo4xbHQseCLdSSOnfFCjo6kkzJLpy6j84FMD01Vb3MvR9IBErGBqUhq2zaMMDam0x3evSC8eKymFH2iTBk6CacI+q6gTVgqKMB4Iqbp8aOXQhByERM6ol+DkYEzBzlyYbmFk8cheyMAlhbMh7mbBRbt0K3BFBuI9C2ev7R6PXiroFSimmds2OcuR+5RS9eLPqYeQRZUdqviOqVdmPOOw+I8ihfS24EEnrQDs+vxdqSH4o2+WFB0lJaU/wI5yUIW7XD80O9Sg+uhJtKPESU1xDC9pVwpM//NmkSe/0KEzY5RJGRyGUzkLcy2E1D2qQFJi7SAURJbvFOJ7gbBMYtJheTx47vOpgrPpdVTpmKQvyGFn4csu56lkiff8g2cfhtgo7OUZbZGtJfLPVLqTVblIfzXDc0FZzfJ2Hnrvu2TxOC42Nnls4e+3c69DTUtCgXX33WsGix6/Zjmlyvm7/uvv522w8PmMGRmZjX4dRK2q9JalKyzef//zn7+sBByCi237yySfptdd+yBubG2bx0cIcitPto9TIhUfv+siCBKVSqajhSeLNUdDFxTmeyFXEkt4JoRoaGoIDeKlZ3xcgmHStFCOhUlZgNAdfgsmBrLtpRC3NUDsiQjac83oA5KWRqYnzk+j0H0v66v9xsWen34lY3pP9FC5N8EGlptwFpRiGiRdBLNJESqZ27mvW1Kb1ySlBuMRb3Bekx9jsilMJtUKlI9FKR2e7ZJ/8jlPsvuc9skZfnUK5w84QLHSxXgCDhhoEH4h9fX+Bw0zFxEFKSUJpXMNKSVaNPUT+xzCtdRrkWkrPNwS6GlBr7AqKyYhrxznGq52mG9BLUmLMeR/BStjrfEp8QdkpsEflSNo55NEsTMOmyhlRlUGwn5t7NTxD+oXdLG19ayalnY39GzMwMhuPbGim5Hvf+56tuu4n1Yra7ltvvUXKkz13/nwGWwkdafiDeps3t/LiDi04Y6P4Kt4LGp2bVSdeYCTEYcnpIb7zyAhCYQYYtz0DJoqkvgUjc1CNrANR59wZ+YGwB2FoQtyww4gbtdfoVd/kffI9uBcQXdMiBGYV0RfHndQi9+JHWwIcSLSOi+44bOkh1C7CQ4OzJpI1EoR+D/gWZAuCXY++CxtSdI+TjgXhCagoejnFs03VNL460/NkZcKWPWgTRTNi/q4iULFAvUSS9wLAREXyIK6JM2LCpyP2kP1xOqMVAyc1aHYx07U7SkmkFAQiifwRowtyDQZRAb9Y64biDBPX8jJsYQiOMj07ePjR9OhN+IpKmoDx7L3yqIFXXrKb7zWBIESDpqHVtXXa2ZnMyiGzsa9jBkZm45ENjVQffvjhnuz+6LFD8tTTT+lDvC1K0Yw0vC9ki3EtBebt4X4qaJ3iBpZeOiggXLhbSNqL1lCYhJ2YMwjRH74zLlNlh/FGa9AiInxlb5Oq0ALW4hDPwkFN0vqrr38thK6uvWb46jSb9JHoBRMVonRvDfOttCbtRSMmIAXhfrTiDKpOGXXSg3FKBdUPmzTulwUIHnOw+cLaPzgWyHgkETdU1zUSARG/pXZ64sypSDcdrpfK5nYSu4kGO6F3xZ4x52DpM/oME7rmmMtbtiiWrlkPh6LKpDpEZRrzU2Alku6o8WPcXzjGjndiCmHPwJXOij52KWYaD5GupLQo2wPgzN2HPxsdBGjB/HmJJlxSrL5VCPCnTNtRrdWlvEnQ+YjDvDYmLW1t3dpLaDZm4/9n781iNcuyM6G19vnvEGNOETlEZFZmVlVWuiaVDbJst7AfkLrd4gEJIQHiCbVQS0jNA0/w2JJbLZAshIRo4AFQ048taLoBtWQ8dIPBdtku1+By5TxnxpQxZgx3+M9eaO31fWufGxU5xXjvjbNVt27kvfc//5n+s7+91jfczTGraeaxL8bqYkGLU1A3JsvAkq6crdxcMI/WtBjJ2FRE/iodPPoaWSd5+dDBZAmCSXomFLAYtS25WaUxBJPQ8I40FzNmrWJJzX1Xg8E4Uofjz9wuLLQTsOtqfNhwlEdrgY2lSt5KWyWHCyrT82smxuSB5kHzL6LbQv5F1pNyB80oBwI/BAxKa1reYFViok1jU7rg9m5WKxK0CzGg8tB9zQRpNZIUHMCRKj2amP8TECqSk4JTWhHdm7irIkURb1HZWZkE40k4xRsrLta3l72bZNxOo4DyUksKcSadO+IjMk/zGqQ5SRxfne68KTxwgKSrCbFz0y7DPL/iXoykmlqd89kAl335L9/KtWs35gfkPO7LmCsj89hVwycDl/GVUj6TmObMfjdUo+HaWEdTN3MqJCcI3as4AzX/C/hihkijQqjb7LCCCVIqyYHkJRROKhkHCzUpwujhgsGJcpRM2u0kxbahCu6DkthKPoSVMKSH1ZgH5KXal8v5tA5RIiUEskyYoO3gK4mTPSSPtmKGLg0rBL1aklN9IiSyNQ2hdDYpOjQyik6aU+xMEQKUmABVWRVqGl0bFN0JFlWYUIiLw25Qz7+hlAd7oPmixG9Gbk0/o2FnmtwYtFHo0uFbKUwXimOlpsngPZs6I1RQSp5fkjmsN+zI++iFGEWzbYJEDCE5055OwhY61zMqz3pNpLcbZVItSpE1q15gKoE9C1FRETr6fdH+zNSgMgirnnMyV0XmcX/GDEbmsauGPxCff/755mXyWSobf1i6zPDUqVPtoblYW2htAXlt1im5/kw2IbzGJhOIxLwUfNWwLdMEMKpJxJyksUZjJJzVMUlourYKVqzZzpe+EvfVdTNBN+04YUpWFCzpg88I7op1/gjDgNsfKgkese3M3avJBenL9JB2kMAR82gRG2vk73OjhbtdA2tQizw5Y8xfC7+LElYqyp8CN2i0K1oFRqAACs0pjcHgyxISoLwmRXuBii0TmewTQoKU9u48PLidCks1VRNIZOlFcNImnYoslfESle4GMw4sCXU3M3JBko5r0pFWIwLV/Dc7ZOQWoV+X/B3R3hlr1a6KvkxBmiAaO7rDWc1o4YsX9uNkBNGOMjcBF4m7nzN8c66WWVtbby7PPnar++g89ueYwcg8dt2gu+JnEeYYLeCGcM995Tl5653XdPP6dZhg0ngqOB9I6yhNUlKazaXR3dJaP6Gt4UvRbCBEPn+LsZ/KPoMbkFOAlzTSh1QZzIsYOTHU/g3WXoXu82k2hv0zWq2Sx6mallITH/rG33DXLpeStreukOBy2jY4vGkeZiH3M2AH8gOtmZxTa2JMookaQAXrwWCBLrSw1+Kk2VIzcVAyASd2oKSSuv3GU3sK44sVZGGB3XwAF+u8C2TtI5oY3QsNqNiKIikqRlAyaygwb6kK/QxqHhq5zdGzQ/yMwG8/w3YYRUwqiLL1IY1pBLN/g+KWMM/olMv+kcVuowDWuUqBsZhTVML/3TSl1CI7GoET7qyxnGZsWiWDdWybKiiFWWHzsEFLapNju9VkMWxbGUb+/FM/T5Rqe56Yq9z883U7JmbzmMftjpkzMo9dORhaRQnv9EtgTf8Lv/AL6sDlj//oj+XcqXP1wMEDYe0Z2Ss5S5YgFnSDLdAea42uhiuECxkRRkdUY4guY9ZiBovMPLd3pWsDl8AGke2Er1DCTrz5iZJGKYyPCReQJmdVy3IJ0mAMAfiIoauRhO/7W5LA0gkMzW21Vggy6DFhNctCxt5HzZMCt/MAIbWEcXgKYE3oqdKC8Sqy8BP6TKZRGljEaQCxhe2b4EmU5gablYJAO7FRoq2Y3ZOKoqT+xDnPmNva6TnSex0Alz0MJ9TN8MANR9cMHEKnxUjYJWCU7ljX3qHUfP/IE/B9HpOikoWLaQ2jA5FOCVHR9IIrPZhGFOb4QmvXWtMrP+zdEVpEe5F8v3ZD4L6reXXx1u0zY0s3AzPR7eViuVy6BN4+9cu3s729lEOHDjdbd0ZMzGMe93PMlZF57KpBqa7zRqZui9PhqzYHI/5Qv3jxonky8GOPHtbFygoqI0zxgN1EzPiTvBZanxcrYWBV3MAh1tXRtumqB82UPEpnugNm4TyG1W4Yo4W7qgBZYEotfY9ASajgTjQ/zjLgDStNX9vc0lb3jLVNYkPqVVpPpETJIV0+4JMFi/VqQSwZkpcanmPhauYlj9IUrqXk2iSEzp0B0eQatPZETA8YqNwhZM5O+SuhYR6sBb+VtIXHH4THR1RC2imGbLYiFLnsqB6JJsyyRC5I1pc8v9TEmCVM6mUjFitM0pZO+P6ByMIYLVTKtLyFOLeTe7kNdOU8dhgpgnHXKc1qKP0eI4QApbTONIm6j6F6U6hTinjBqN2pdjxIpzhD0k9e6bSF7Xb5KW5StcWwuiSAv9XaU9G+87bn0aOPzAZi83hgYwYj89h1wxOS/ctXaZ81Tp8+bVzBraytWh1hddbct2sL72/huDqQCWKysy0QP8QERJP4NFhv3htuaZWkzp4eZ7QlA0pBQ4SCHpFc5kdobzA1IF4NgUS8rvapkdWFCQFTo2qD4nt6ykKEQ0sLOpxYpQiVYIrEVWp0mGeMJXyaawRXoSZe0yR5CM1XJoCo1yJaBo1moovQ1LRJpZv3qPWWhGkP/qc7LRS3dN7Pa1CE9qMQripfnb720V1icSjKHTmXqk5LFxyTwktWFOrQmjc1jFrGaOwhxEjSi04kvdt5jZM7yhAZ+tFHtQJ3mdEstZ9RGvw3OGv0Vu30pAx+SOt7BZAz6IezOFOAjRG8hyoUTWVEDh26Ymtrm7JYqKys/DzQcBBy4cJlGUeTkycXs5fIPB7YmMHIPHbtuHHjc2WF+XStS49fVVA7RZYR1ULfKenLdWHSfWN3NO1EzgXRBChUT3I924BJVlay/2A6UmbDiQdGaTAUL5ydsUzuviOR/CZBAenGpzoNYlNYhxutO7TPxzWCe43kEpnCFYpMWneitlC9hnlitytKGwJaraZHOmonTZDBZshIb440BiOW62UAI3UD+8Dz5ziiJme0M3DT6K2g2NSFJziPlD9xgtU++wsjZfxHY5BKmAwHMWxyURHAG/4blRyRdn6CuNyOH7AJl6A0r5h2Cmp6qMH8rQFHGrM0ClG3VUkmcNJK4K1KuS5/EZk8JA4Z/Pa00u6XZbjovRUAFK1FeMYLnerDVyXgAws4YD8PoeMezp3dks0bKmtrB2QYVnd8eBbDQm5s3JCtrbBidyDyadXIeczjXo8ZjMxjTw9f2Xk2zcrKiroaAPZX7tlelEZQXHtOZCEpZbVgRnaCQ/wu/RzAUp1CmWziUJhKFY3wYY6mf2u7wJir9vR9alS4xOXCXpWMx76+Twf3ZJUgdifoi5bEWfBuw3VWs89iSvyRUyG+0YwWJ6mBndpVOkFr7V0ApOAVRPFmXO3SGJqLOZSRLJxFg+zATkcB5aGlBNIbXnq5ARxaurIXxvQpI3IRK2MRfZjniCexILIlBLYWub9C+FDhI1IAMZuNekG+T5rFKbQwFbjDkqMjwjNBhinVulDMTG4ig1QZ5jbMmCExSEkK0pLKoeSEpM6KnGfWR9hoIT9JbAwIRbgdKqhSS/jSWF0c1e26IhsbW7Dv79eprqhcuxYW772VM495PJgxg5F57OnhYOQ3f/M3y3vvvyPXNzbheQlTKc38WuOKU6deFkFlwMAMivK+Q5lgKWS+C30w0i8VMlK8RiaQBcRMyE6oSZEkTmhUOVK808ihYSQW5fxYV4OOAfPxSNXpObphZtVVvNbwF73mQVs1RvuGj8rEXyTaKomxwr1MmUvMibNBOx0AGyq83nASwMUEJNihkzWQYWLDMM4vTOKLug7DlZVll2AGBySg9Xp3UO3XDyCrGg3pGWWccmelFJtQka2UELuQ2DshFVO8nbHCHXukk30Wg7I/ZqQ9C/pJxRI9kTMEL19uLZtK3AASBAODFaVOuuAmAF9HM82QO9eOJfChZo8qfEaiqlNUx8PPFh3eq7K93JJVz+czhOaJysbWlmxuznkz89gdYwYj89iTwwmsXlb2OPM/+uM/rqsrpT73/FeEXqSST/dW+UhjKSpSMfnDlBtcxamq0ukd3ThMwQAB6mhzBDxYm/w3tagyYbzCszwCXQsnNSpOQ9NrwtRRjWW99OZAMEdDPkPlKELe6M8lSJfz/TE6lWF6rOExQvtSkhySgInjYx1homoJDFWjiqKIiitkO3JKDfaqhlt5IXSRlBYh/UUGWN+aZnWAS3uJhLekgBo89gHirEXjwss8c2mJF7pliKVNP2gwTVnk/I8mLtFJHl5WojQNeEtnKbNYweoU74BoT9UJAaed8WwekScNBFnwJy14NxTBga4CKKBNODLNDwqbhtWiY8PmHv4CBZ8CRknNmLwaIcap4uktnjHos8v1rYvjynhDFoMHWlfxAD1/m0+uXIv2zNyRmccuGXNtbh57cnhF5Fvf+pY88sgj8uEHH8ily1d0sViNwLCYEiOolxaU2iciuJbnvNjoAUbvCiUrwZLK0VfYItQyKP1G6TlhzJITFBxqm5SGppqJNWtNJmcDQ60KUeBiwZk8mRsg14ZA19B1MCxq29tE0FpDNzWlMujxsCPVnTyc9sJ4nnCVQEfBuuFZurT7Waxw0YehfJYMyOmobZ4tZAaDEByzvNGn3YoHFpMvWkCtBSc0ywRg4TIwV4GJUtAyidERdo7SXN52VGU0dcy95WZsprEwFEHMKbBR2LMaFUFBj4UA2dKrtQKzFcYQ8v15WqiqaqrlFuLHIhdlxrg/1KRzmdiNUZqBgCmtTBskbQj7DpDH8hdZLXhlXPXVteKkVPu//tkPxrdfOy2lLGTrxlK2boxy+cJV2dqcgcg8dte4L2BkDxKi9Av8zTwe4Fgul/qtb31LX3zxxdiJWIx7oWARcl1W9EsPp6H9KBfQOa20PJoS2ly2L1LQOS3bZ+0+KgZdtSLsxAd9E1krqZ2hRAb8CvQIkiaRjpyF0owgb9QCT/Y0wRKQaQEhoEVuXErfb5/9SvBGGiYr4WXBSNo267ZCR4GOVZsDiJ+fBnNKWJ8V0hMSpgiJNcrp2ArFI0h2MUa9aWXniMeSYKkZtEDjo0wFTHylfI0KDMUK0RFwX4EmpQBzIpqXWTma9IlI7JeIw42+EvTerf2h+L2CZRr4oNDaP3tNyRo1+L5JymyDz6L0uUPnj2URwNqSyqNELIX8pdK8UOhIK4WbLAWuIeE3Q283pgwidib9SvDOlta2RdFqtLGufeWFb688+vjTHlotK6sHpdogy/HTFTN75Vl9r/Zzr5N39/L+3xcw4uQodqv3yNgTV5Q3np/bz7JOv9fv/0V+/3mOql9muF31d7/7XTlx4oR6hcSrI6vrC1uO220V2er5rS9SIIW03gSoLBZAVQO+pw7N0SMz8rjXGcFS2mYba7Q2WioKJ4WSWfh6CIwiGmmRk0ortLfEOC/XxJXCFBQTtqHB0809MRdydSyDhf4nOLE0PTVFnL0MUmVoLA0LeUZpXyVVtG0fMj4v9CQldCbNTJYS09S3oP4BLiorIM2dBKv6AALp+d4yXwrlrDmRl2T7tuMvMIYL4ggIvRU/yzi3aHT4/hdUb8yoc60pvGGlB6KeAmZtTWYFuK3WK02ddEpBcgn7VKqzW/8lYU6RLPg0+MY2l00ILOA6A24xQzE0MCikBXwadIrrAjQEIVmSXJKW9Vlp0qy5BbEGTJyIoSlkJA0BT2vIcySIU6pf//oL5fHHH21HtrKy+NysmQfxrP4iz6+b9+te7Gd4HhcnwzfTRX+27OYxfb6yfLgH59oc9xSM8GQ9+eST6hfX+/wza/vLDQbG3eqLN51P8p/nyXE3xs03+efd9KmxMGvXHkZldzraveRgxM3Rzpw5I7/xG78hz544WTavb6aN6rSckLNCZpLBhHWijSHDg3NLCSVHyXIGYELt3XmlXiJm1Mr0F//d0M3AMCfWdFXnql35dmSiMGSkedNPXMKNvSCSC8S4HM5ZOUgj7Bwkt0LxdCoC04+Q24SCw5IIQkfSWmtrIFUtXMoPQbaNxoFVapKQugcqjBVAqQoScIlo5GSDaMAkth+AJGiqHmUBte6PUZLhkrWX9oPmhE8dNOzuCwmd7mGKV5UoQFFy08J4NBU+bN5RMgyn9xpGK/RwaeUmSQDTymUWwbn+EBvS1b/SgjbF3+D5sKXlhaM6eoguiUIBu/AXjZBko+9+jVqQgYKjheWQdn9VGMQEy6awMiKEMBVdoBqQ0wbTq9eujhsbm+2/PVTSOVafNnzy5bPa857ux3AQ4l+f9/y6fPly++4BmX7GuJ9+XA4e7nRwIn/mmWd0a2tLP/rooy9iLfBAR9LRVROEPPXUU3o/5oJ7Me4pMvCT4jfM5cuXzU/WxYsXM2X1Ho9eF/2MsdsRZHdGPNrO4/r6evsisDt58mT7QH7yySfy6KOPeqXgnu6Pf+i9KuFSWn9//+D6vz9tVeO/Z+iWH8NXv/rV235vfz/fxsGDB+3EiRPlZz/7mfze7/1evbGxIa++8qpcOHde19ZXmzMDVJNtsjIW8id63MJOvFqUDloVoKaFBidiC2kKgYJg9kamWwpJslXDknlBGE1UO0oyM8iAHZBUUndYbMTaPcxBCuwnKK4ljaL9xoowyJVMVpIt4nAKOwelJrECDvjKRkbrz+gypChKHVDobQtKRm64kZG4FX2U4gk1yUaRhD6BbopmSSUM77OHVWBtpuzFUJ8E1GE9r3aCEEGmCNfz9h4jQ37CsIQuYdb9XqzAoK4CFpR0KxkkrMwqaLdCTmgKp3s1BBer7HiSFCU5pDmowNeltUTYmcH1j6vbSjsMO8Qmo8LG/lEhnykexUNrm00rLDwXbWUSOA9WdobumPa2I5GUi3obWXVzc1MWwyCPPfbYFIjc8vnoBoLnz583n4T9s/5ln498Pvhzn1+ftwDxv+HrPuv9/Hf+nHMw4uPMmTPmgMnvQV+Q3OlghfXSpUv2yiuvyBtvvNHmq90wfO7kc3R6rl944QVlbIb/3v/98ccf29228v/Od74jzz777D0/E/dUTeNo1k+anxy/cdy2+z45/N2yf+D7wv0ZhkF9HThdKfgHw/czXT1XVnxCbf/2D9W5c+cSod+P4R+0t956yzNY2ofQHyzTaoNbofv+++8c5F27du2e7tWHH34oFy5caOCD5Uz/8g/yzQ8S3z//YPv++e98391V9XaHv8+xY8faauX69et29uxZu3Dhgv7Kr/6qHT92rLz56l/Jcmur6ShGqDTxgA9PDFTx2RaI1ScwB0Qp1Sqc2tsTnkAd6/mwIGsvqpqVfpEAFkJWQoGZqcOiruKE0LcGW1JKa/OUrMELBDOS6tKYG4PWEergCOUH4bNi/Y0YEwMPM6sONDShvRjLIJi8FW5cBQX9LEEwsq9mjkwm9tBcvcfcZ9lioqMNSWpBlq72IDwL0xX6lAYoit6PdSBSC0zm45TQ+UPoxBXm99BBpeV9vrdIcmzYn6GaGO8PSk/6ttiOWRk+L608NPFnCSQZ8CCE0gjZRfFGI3m3WoTrsURScA0aGq64FSnRVe22JOwdFR41/M8k85v97hmD05oJgemO09Vfvp9DyxrynRl02N7a2qrby+32/PKFA553P/d89OeyT+o+IfuCZ2Nj4zOrKLcaTz/9tLz00kvtc87K7fnz5+Xdd9+95d/7Z/rll19uf+fvdau2rz/bnKju++7VCk8S9kWXH48/d95++225cuXKbT9XOPz9HYT4s39ra2vXtOn9OP0c+XefP30O8uHHfOrUKfPz8+abb7ZnsvPnfP7i39yN4dv3e8K/HJzdyznmnjXF/MbyicuTH/07b9AHORw9OsLzD80v/uIvFgcWHkPP4dH1X//61xsC98nW/9tXFL4i94nQPzT3O8nSPyR+EzzxxBPtwzdFvUy3dUTsN+q9Bkp+o/tDyoGFfz979mzbPz+H/uHwn3HwoeZ/69/9QecPk8n4wssuf2h5VYVVIb82L730UnsEf3zuXLu3trZu/K3Hnzj23OEjR+pYawnmSFcoaEz2rGRYriMleQAEIBldiykX2W80DcvJPmaNVg8oXEBPuJjC1Nvkh9ARLKY2BZMzubJAR9HuaUWEiOCvQTmN9spUX6vYSAlahmEdz/o/G1GtlNAMaaNwIVCyUM5q6MkAYGQRSdMzta22wV+JTlEtoOJaNyg3JNeyHaaZsFtUoF8FfIqeGI6pZtQgWlRK865C9klQkjMgh2RXkEziEsdO0jE/diStW4NgGhkxMbX3Po4AdlTVMnD7lN5YXp8QAUMXDbARnZIUU/dwH5RiEh7W5BfBF5a5wYF0iDiCT8z7M35c2vFjuwAjNjkXVDZHJmCU7LWO43Jx7ZNry9defSPDW1UAACAASURBVP1/vHjp8of+nODz49MWhP5Z9UWNP29OnTrV/vvLDFZvfQI7duxYO34HI/48vXn4Z5ggwyc43yd/fk3miHZynnrqqbYg9P32ffPniP/9k08+2dq0d+t57O8LALYryuV+rY4cOdLmIwcivgjzeciP1/d1e3tbHZgxOsOvlT+D/XzfrXnA39ffXwBWff68l/Pfw+Iz0p4r/qHwSsPXvvY1v7j1ZuTvF9k/SH4BKvqu/jfeh1sul/YZH0691Wrjbg2/ER21O0JmZYd9Qt9HR8VTIHC75+fLvsjf97NKpOxj+vdb9F+/0Pv5A85XW0wT9e++PV+9+PXwD6Rv69jxR62sDLGY9dXtyMhV8AvQTAlNbdbhe3z8EMm8HssK53TUBLLubmkapo0CwZCYDlEQKwvDtMyFU5Jd4UaOroSFH2gNfY8ilRXpthI8UXqqFfAc295jNxClZp5Gx1YD9Z8ZAyM0Ku3TOLkiLAugPCSpW+k6YZq8wpJUo69QlUQWgd62TcfVSsH+sX3DroE0/kJkGBbUjCJ3H1lBIXEGForOR2hckA8EiqlpOqoCERSm2BT4mowxKZMMCrFyu/4KyxfcEVOf2wIecGjCSR5FUagodVcKgxkwZWrX1Bo8UDvkgs2cIOhfkxFkgT6CIUOOUkDk5iyTPnQG+12qhIXyc8rTJftEGvYk7AgG2vTKrwOLr37tpda08snKJ3H/zH4aJ+RTqpdf6PngK3L/8kXckSNHzBcpvhC91XjuuefaQs/36emnn9aNjY329w6CMMyBii/CDhw4oP7c80qA4Hn4wx/+8F6R9ndFVcSP/Xvf+157rh89elTX19fNK9MTsNbaVNOq0B1QIH7u+vonwOdJf94++uij6tv2FvnJkyflgw8+uOPt32o8LGAkT4RP5K+++moSQjn8pnfexdramsfSG1cQ/jebm5vmaNOrD5+3/Xs1/GYgIHHUfPPq5g6Z3/d0/8l9uZ3hJVlP8PUPnW/jiSee8A+Gff/73/cPat7kq6vrYw2wMUQNBHZWjdepbkxWIg7VPxgDUlwq+Q4FXtkV69WClkBsfRmihahAeCINWalssFDegukdHqlGpoMkn6Jm/wWuExRlBhWkJ8jHOhhEjZpkTohmsXir4JyMYUPClGHGlFhTA1W+nr60maIC1UooVcOXDUKVogEWaqQCA3JFHLIWsiZNs5mTRvZdnuvbqmyWKKizFT5xwb5oXuZBHbQUCwmSaStFStEEGul1r2x2mLLJE5wW4rxCyrB7joFcU9CUwfV1lFxhXlLDkS0sydrxtqJU22JcAql03Q9lNIQw2WADdMxaSrvVCn/fziSJwgyExmmq8YLRS03R4CuU/SjDkGoo1qPoAaVz+KyWTPtxcAyqTyPMFFkuR9HFUA4ePqRnzpzOZ4ZP4L7g+pIE1S/1fPC2jC8i/OtWJFBfTPhk60AJFY/GU7mZo+GVAK+0oOpqE6DyQNSD93P4894XWn4OV1ZWzEGJg4B71F245Ub9PclJ9DnR7yG/Hndr+zePh9KBFWWuJEMJ2go+nIswlaFyVe9g5H4xzD9t+H54pcZviIclXdOvFUvMPq5du2beJwYQaaPJV4ra6mKlrTzHcYyH8wADreCZun/6IGRjahicUhQDo7RiOb82I8/kZmqoLVJdIUkibZhDoYGIKkfF1B8GH0FPjMm8ZM0gqgIT/qtPSEjwTVGNTDQaKtlpauG6VirVGDW/Ia6FPu9oS1TQLscqmelC8ZDRyVUji6WrelvPZUTSTcCROkB64jO9MrEtTDNIBM4G3I5dscjcKUYH/ZEnGlMsfp99sFDrcJUf550lmUpqMmP70XvJzow1ekjG4rFsZVFFae9UK/snkkjSWo0JjiTGrIAMKjTYy2AfcC/gIk+0VG17Y3jCjaiWhKw42mjAdXy9Mlt5kvyr1gOM0VSK12OPFPcwLF+0YapKdblKGZejsEZz+dJlWVmsyPqB9fYMux8TubdSDh8+/KnBeySf+r54RcQnvpuru/47/+z7YtD/Zr8DkOngeXEwwPNzP+cfvzY+5/ki/cqVK0YAeS/34aG1g/fJbfoh8YvPtgzknO3nbDNMgcuDGmx7PEypmlNJsx+7g0g8tHq9MhJerY5NgVJFxjCprCRsGH1BMSmMWJ4WqkCwBFfJUFYhIQQiGRYDYrJCfizqF7Ax69SHTkzs4pBQ1u5sSBe6weJAUi1K3mwWWpIESnTEULiYUE1tBxAQJetF6JJhk9fXlLjEaWiGpM0ApTuK29SFRQZuGNzOvr/0Ls8bU9n3oZc9HEQ1gQakH3R7yZoS2SQOgZLGiU5G1Bwqu1PCwkGG9eC4qXyicNfYLyIorXR7JWYCLIxCGSMC85IAuhbwb9nao4y668V97wruqjF+U5Vm8b1tZtlJSwoqIJju2DJv1s5+5hsqin48XwFJSnF/eZ6DldqeZ960ivKck1i3r25DhX7vnx/+vPy855TvMxcaJMHf6jX+u93w/L3fgwuwzzs/92pwjrxf537OprlpzD4ou2v4B4GVIP8w+n9PPxycNcow3Kh1dFCxKK6UskDwSFGJPysQSAABFMlY1SSeJv00GQxKTYzQ2DQ9qCRb9NMpnxggqABBL6HsArCHibjhz5ZW58q5Trjv2H4yC5LikscPTzWfSEshHkmpCEsJ8dMCkG1cnkddAJMzOJHGVXzOfNH3CDBY+ZsB58SaRxgqO71sxH+YJrYCQ9aYYoj9b0UK+roCLdbcRIidESlUKI+O8L2Yqpv2RXcoaroXWZwATr46+cb0OrQ7eBENjBrLEg60RUbzVp7UkmxlRXCNKqsZ2hmwAKlW+86RgcvdcLmygi5jWSqSpOo045bGRUpDfDBYFeYxhHfo5VUbl3U5rC4WV8RkeyhFjj95HHZyaQXcPlNOQp/HPHbDmMHIHhufpsXfr9US7506g7v5JUDePO0tRwppkfWD65+06lbzPh1MbImA1QJeYRA1UmqRq8+Cyc04ieV8V9NXDpWK5HKQMaJ9J9CMiS3USVxKX/ljMWzhWxVEUoKLypVyprlxN5T24fFfqUgWOHTV8LcfUKiY+MfCYVTIlJG0ILVetgkOSAzSUTBzjjDiKN62VFqZl/4ekZBXBGyQfvpQdKoEZzhhONpJ1SE6NKWmEKWqJP3EqJXJcEDQUph2y3ZQhiJLnsE4ZHqHVUKrHpSXeyCF4X8htqa4p2LGjxYbHOIthbltXwNiFkp6AA25G0amMK1jS0I00cm1KqT8KuAky2XU6VB0AzQr0vXPijvJEVk42jq6szKOVVbWVy9r0c0TJ0+6J1GrKPpniBVWbwG4YsPbnne77evv49ufxzy+8D0zn6m9NdgyoqKGY7+CESetTYlrtxo+hzz26COnHIxsb2zK6vpaTA/ayoy95D62cDpVzscSxQmKQZVaC5bTlZkxlZX9EGWglUJhLpfoEcIfsTR5NaYrduspeJhc2pYZOxLcjKBk9rR/08JCBSoLNfUWfWpVmLzm1rlsb9oN/EcltdM6+AFIMGNFkBZxNfmuwZlgn4BaIybw9wy3LNuMltpTsi64bi+Gs7mjA9N92gttU4R8molZKiocTGURpgQP2eJKAVQHPBVcW810Yvq8FnJyCoAnW2Sc8W1iiqKssAFNoo1lCSRbv85SBsPD6oooKHNRdRnylsCuWV4r6zAtzlpiyChrIGUHGcOGIB7VnjstOi6Xsr6++t4jjzxy5aWvvywbG0Eknbqw+kucB+Dcjrvh1TEd/pl1menD1FKex52NGYzsoeGrF1/FuPTYVx18qDipyP1T/Lv//iEZOdc5QDt69PEfXL32yYWN5ebj64sDKpuULfTWgeXKnxNZTFYFTX9L4gJC3ynHxBxEtaiQ7xCoAZYjOQ9VOlI1fy6rkn4mgkTZ7O1jv9KGXjj5dpgZphiSBRPFO7SKUK8IdCoC+jrRu2CHRrikD+qkZgpgTNZhUBKMlxqHHiKcmK5LmZxF9LVKB2015B8wSKldrjPpeFZ6c5Fh0Q1bIHCu7JDodBKPt5xM/bAK43SN4hZLHDyoOOjCIhDS7diEm7RTIIvRXpLQHfVHo4CZ1YjCylmR6TUyhBI3GFcTBGZ6VN5uzPQzbKHwojfdc7BBtCBQCA6zFV458BhpuNlqf3/yZyXqRMutpS7HUZ556qnfP/XB6dOubjl27IlWUXRFxs1E0HvRmnbQ81lS092e+zKPnx/uO3Iv+SN7iiDh+vU7sRT/rOEn+dOsi8lV2A3DZVaUJjuXgmoT//dXvvKV5ta6G4afL/cGuC8rI2sywO8Pw3Dq+vUbXakbswKT+SljaD6VVkgMTYQiOQEwq8wgksWnJBPLbNoDaUlxdIuHmRX7PBEOK7CH4PuxVkK7b9A7Gt82tK1qNx0fE+wqUvAaP8Oy8EKdaZJezaiySJlv4Ipqar1qIqyItEZGxdqbRl/Zj6B8txIZxY4yEC68vVo0byAYLVH5gDwpE/cqBMO91JDNmuD0YJui9I/vRE9ySloLBknLkq0tZueIES4mWKLmOdFgd3ljt4otNSXbBi2LrE0Zu3WQYRPzTEpC1tojNlYAJlq6pZk975BJvh4vrNDtbZIPIL2v1y9t9nOM4dMyBa5+y41uRRAuq4th+Ita6/j666/Jn//5nzfJ7a0UKfdbmQe7hCS5Tl2lbzW+qC29m6O5d8k87v7wZ7nPPfcyziVnWO8p+mT8zjvv7MrSmpvkuN0t2devv/76jt9z/90L5FYfOHfy8/6om55Rujs9Tj/JfrIZvsTf+UXw7d5rq/UvM+g54mZgZKTTAMelWP7zm8/P/R5ufuS+LV4G/rIJmMi9+TkvGMGKyitCp0+ftk5qHeTg+vDu+srqJ5cuX/XodCllkKYoEANVtU+oyWPYkQIrvVjQWwYTr9BJ3yHIFPSpyu5ELvYlCI0eftYy1ayw5p+rdh5WTJRV6I+Bekq2ZNpf175Lwd3MJT9cuuDFmsxUqkZHGqK4Shke4kYmLOXM2Bf4wOKotMGUShOy3lYStq/IpciWR5rM1kyzHxN4FEtXjRygmkTbhrIR6STLgmBCXJWk7yhTBnEoMLQPX7DJW4S92NQzVyY85bBtEVZIqimClunbxthc2tXTz1cmcDVAVuv9pe1ZyG9U887iKQIZNasirhpKONLqIUpAG2xdrUwedN5LgTseNcztMjQQ2eC1ainFUwNse3tLxnFpv/u7f3Dm3LkwHfuy1u73cvgBunuqV3j98+zPa//uz3d3aaa5JGMn/L/9meDV308z3PLfuUnXT3/609vaczeD82eVz3+7ZTzo6pG/vz+7HTS6ed29nlMWL7zwAtMa2w/8Q8SgJJ+Ave/3oIab3vjk6jel+4DQLthNsNz8ywlZLf4K++/fvRRJF0E/kcyWccTsYMRvbp/M3VluaptLboKbbLntLfXU/iFw8xl3v9tNw4/B98lB2hR8+TXz8+NWyw6u/EP/IIZr43/yk5+0c+7X6IuCOb8+/lDxa3+rwCeS7xx4+XswtO/c2cvXb2xsbDfZgY1tEmpBJ0isgw0ZlahtWwkjMuguZKMFpuG5YObajKrdMokt4XKZy+gyiTajywWW5cbFPvgolHDSOzND2aYMz8nkHCdAU21BkmdO4slkgT9Kz3vDZ3vS21JyN5qBKyxMO/9E4CMfeScpQ1G2udh3UK7Zp0TL7BloTv7smDVUghm+SkIjnACb8GwzYXeC4eJCFbjAmvVrR8jUngeksSS41E4shit7VlBk0hWDNLsUbjtQWpkQPpAuEAodWgAgSyBc+R34GSTXMj1LSRci1UZs0uqB3UvjCFXujk7gIom8kgcF6GksxCFiiUEC9fTpc6M//1zyfvbc2V21yPTnqz+/mKfi++YLSn/2+vPbz6t/rqf+Gj5XOb/lZiM1f+57XIc/E79MSJw/mzi/+PzgiyevMPv2fQL258vdCOG73eHH7s/yBzVoMe/n9X6AtIXntNCX3y+6T9J+Q/hFcSDyIMGI74fvH0lXbJX4zeI3kt88bOwTmEw/cH4z++v9BvXX+O/8ZvYJzG/gW3nt35SfsucGwaQfm3/Q/Jhvw773rgy/n24n+dKvmz8g6PnCQZOkr33ta+ofjqtXr5qDlm9+85vy9tvvyeby2rUTJ5+R7XEZof9t2gpXqh7LwsCUtDfLUkSs6q0ZcYbepRjSWcN0u9uhoTJfrDTWItJBQCMJZ6zGRABcSD2lJAWT04sSQUQtAX6iPOpIfStYrFtnjJY0HyFFFhOipUFI+oq0xsYA7SgM2yNZOPav/YhlBcbAQReLH4WfPSVAwt0gD6QbtXavlJpm7Gk3lr/rZipKbizCVSw7TkZ5rabXC7N0Gg+ZyhvJDVp3sZ8AHC96wP8VqXpNS5wXMozZNVNz0E2LpP9skYB/kgW2Cf5CXaa7qXQmT6Exe0M4bSd8Z3oas0zlOWTEWN81XoAd1Ke8OrGXCpa2Eq9IA+Pl2vHjx8Zf+qVfas+D8Sfjfc/V+rwx/Xz7CfXJ3xfBx48fbz9nFhZjL/z3/tz3zzwHn/m+rVsFdn7W8HmA8wsnXm7f5z+XPT9IMOLv7cfk1IQHYXLpz+77mVy8oOsdtedEqQLr9Ac5eDPeXGKk+dVUUXKrm9Av4BRZ83XLxjS/LVvbXTU+7YPHFEw/Vrav7veNdbvDr5mnUDIgiiCTx+UPpnPnzplfP29HBUhdkcuXL8kjjx98pejwN8dlldXVFX8os7Lfw1uNBtrdtr2vkUM+SeeyqHJwOjCSOcATLH26kz6PC1NNGI+PGBsuoAW2mF2jUeBgFShB2B4IaBK26p2yAJMrhYIDe40WA9bRNDPR8DiZHCV5CJOyTUEWi0H+rAzgqaCNRoJcgg+2J9KKTQFPer8nJ9LJXJFnMRN1+zkwuokGb5PcnbB/b0WIgm1X61bp0ZZhwkwwcmLut6wTtItdkDzXzxj9TkgRoZetkWIqTZ3SJUys+VChS2caobw5W0Em8JApRhu8Em24vEFQVeJZ6F50Sjv8CgucwtKc9aoT2KsEYQl4Go51PLe91K3NTTn5/Ml/cebc+VNe7X30kUfbJLvbwIh/vqfPMP+3Lzb8+cwbZ0qu5fN7OjF/1vP/8wYzvabqomkMyG5obfni2M+Tg7T9PmaHr308CMa8hfXtb3+79VX3wvAVkPd+vbUz/RCyXeGgysuX3/3ud9Ufsn/0R/+fXLt2VX7h5Zf/55XVtQ9v+GpqGNK/YZqXxxRe4fKXESKVVEok1GJ6Nlp9hnNZk0KUpIwm/yKX/CBiTs3ckSrSJaGZDJ8tHOseanymFsIfTSgk2vmvE3VLvILJaWUiGso2FHoynMuV1msxDRaURyaWZYbCEoTME0qNWkIj7f6x0/p/vkcnat7UJ5I8/xPrVYE4mXwZes4xAJh01JqtnCxUVTBwR7lpZ3sfI5KAQF8uihTiSQ8JF4dRysQ0NERVlF3anF/IHxV2f1zOnKShQvNXZQVEQ1djk0m0VWrYqOpJRxWRSAWFJSius6RGIz4tSXFCVajZ8zfcsrW1Na4fWvvvROz8j3/8Y3n7nbdvmZz7oId/hh82R+nbGV4Fdr7Gfj9PMxjZx4OrBfZSvUW1V4bvr7cIvd1EZQ75It5KdKD1wQcfmAOWIB6vy6NHj/9FkfLRxuZGI7AWhQFFzvs5kZqmNWiMLD0oV+ZYCteYkrNvIn3u8l9H7WXaQEG0iXLC6LZp2TsBdxoJ9GSW1Mn2I2MvfMQLvV2jLlLoGc7aSobEZuUjla8KbqnB76t1ODSOPtLmkJ0P0FNzoUk0QUYKEl0MzvqpdcZ8TqMMQfmkFSxqUjjZa2H+SrHs4EyLDDHV96uSHZ+YxGu+H48Q0txiwAxTg5c4/FEmnit50SfXN7tZWeYKjS72rHfD6Ea/k4tchbGEUnvNZfpYJTwKeMsCWweX3awf2TwlsSfPzDDdEBVHWfIL2NOqOUWdzL29XG79we/836+dO3O+rf59MtttVRG5zWrGPPbvmMHIQzC4+njQbbcvO8gRmmYFcRw7dkz9QUtisZdU//D/+UM5e+qjjxelyLKOzkQV0j3SugLSi5DRVmbmkXcAZ+/IniNLFVqRvi9iO5w6UG2BRWbp9hZZUYmpvKQraCEZQGJq0twLFG2UwCKq+AW9m5K5vWwYBRmjwH08/EE4/wcDMpbMsZQvEHuQ7BEFEMp/d6bdGVf7meMXJRUwRsClqWZM7J8s1TshNFkjGVkXZvgEdaGbzZZNqqy7UkigxdGM423Xj1JeqqVU6UCarFZJkTBORtUOGIEtoEzp71spxCa4pHwnyzENDIy89JaVCk0LXQilW1spEGSV1B+h3qNRewGWwA2lONZ0h0NbS62WbIsFmmwbrhMSrsiiLHR7a1seeeTou9c+ubHpn/fd7OcxV0TmMR0zGJnHrh43P7AcdHjr6dKlS57Om20cr4689fbb8ugTj/1TVzvfuHFdyqJUqFSJJ4yOD0kBUACT0qbqzCOzvnzu/iDBP2zIowq5oEEDaZNTbTNQ7TYUYAQoHTnCyAP0SbOx0UmQQBsYpGZUTSSzKTQncJqo8cNeoAnag8+z0YLyt6QYQ4JxoljI16CIQu7SyA3U3FginDgDxWAUarlyZ30H7Iq0K6FVXGnh+zXMuYQUFcuJPYDMpG4R4TjWHHBhxoG+TxMYBT+FLbVeg2HBio23SgV0NNsgnLVsopGwEgTWLCpALBSFmF7+sMmhNqgVoTNJaE7WB6Egmi3weS24OH6vFNrOFhmqp+rQNC9BWMqzgZZKKnujRFctdVdgl5TsOkJ3nM0fj0CwIPePJ5599r9+/NgTzbb4YUq6ncfeHjvACJNrd9OYprZ+3v4xcno6bpXMu5/Gp52f6c9v5dexFwf9YfyL6b1TyfCRI0flyePP/B/j9njuxtVr3tapWnQEkTGTY2Jat6SEkini81q13paIPP4mFTGu8mnN3gPrOrNQktbRGQvhDhqMg6pTpwolj5Mb0EkzyArYKVFyySV+0ZzRVSH/aB6oYgy+IwEDe1ISuIQeJTo0Zl77B/HCIshN6e6l9BwJYgO4nZwUIxrfbTVKVnJajQRu+Ihj8WpMIfED2MUMcIlmZuhqWOb1qMKxYyJDTsRHkqpp1EKKZrGnE4aTjbKjY8OiTIn9CPgyNH0LBcJB7dD2k9KKG6Ub3xsArZZCYBTVpihcVBCTQ5arTPcHQMR/FQC1ZPmWZKUYuc3WC0NM1mEBCG9rUAQJe4dRm1lZrMjWxqZs3djcOrL+yO8cPXK0uirk04wcd+OYPr9v9fzi8+3Tnmm3ev5/3vis+WWu3NzfUabxxCdOnFDyCvxnt7AJ7h3U2xtf6rX+/mQSu2fIU089pfxw+e/8a7r/zz77rB49erS3nOFBwmf88ePH1eVcZGnfRs/yXjc57+j8PPnkk3l+eF745S2P+9CjvatvwBye6f1JrxjK/dxfwL+cDPfX/tqvyQfvf3jxgw8+2AivhVIWixUNs9DIhl24MxT6Pt37ivNDUXZQFDpZxtVDMKtujW4R/h+8xJDLxPQ4lGLkKsL4u013aV8W1NUSbpvtJYb2SyvPaHi8x3Y9tx8Vkxp/2K5fKcI1d+p1oO0J9kKJ4P6MT2GIvVA9TBEoqzHKybP3g3pUcJRbUueqUgbBxC5VAyxF8QeU0E6tbb2V5kJbgRFKLP/JdTCyJgCUKH8uQCmdQ4q96jTY6S3nLRslgcSgNAr7W+nnnjzZkhpjDUOxwpB/GuuyrVR4fqxSCt7ukTBSi8ZJVEySNjI5vjHeQ8P7rdXcRnq9U3zFw2kYz6JLN5SC7ef5Ca50DzukeTAJJ6VoHVYH2di6ITLomX/5L/7lxQvnL8htgJH7+nyjOo5tZH8+HzlypB0rn1n+bJs+3/w7nwt8NvD5cPLkyR3P/88b/rqbn5/+nfPGLVpcu+r5vwvHHe1/k/YSAX7yySc2lVXdAhneKVT80q/nfjjidV+JadnR/+36cE6yXrqne9908OZyHbn/nhPZ/dj/e739m88Pr9+t/u4+jLv6Jl79cPItTY54fwraNXRt5HCzpDffemvjm996+R/VcfzPrl39ZHHo0OGxjtuealrdIr75s4ftRO+/0PCsFdk1zaQiVqYbTdGchE2IEPewrWPCJoCRYlpJcEzuYdtodGD6lJ2czBrm8fGbscpIRkcuzkEVCeRijFIxTIoikyIB4vakyz6sMhi/9lpOK2JodidsEpUbhY7O7+zHqFFD4krdag8VBAEYDmEUn2LXUaGyKTwgOyQ6IkZB0CRGOakjvDQBHsHLAculUMur5MKgyZFxeJoEH2CBGpl/taCd4vWldnMYou9M2WkKUCbmhmq8Byycb0E1ocdIIC/2XwhtDHUSI/skuiuZxEP9dQv6QfEG+cyodKL8VoL+W2pczYZYVtYWdTlur166fFEOHDz0Dz849cH561evy7D40nyR+/p8cxDgEn1/dvlz2U0ox3E0goBplVdCZbfj+eavm8pyL168aF9GjjutivjrffteafX38LmFYGlSbdl1z/9dNu5o/xd8uAv67jeXyR7kmJbOfL98/6ZImjbovGl8MroZjEyP48qVK1GeHYZ90bq4+fy4JJarhJuPbS8eL68vAej0/hQcE9s0vkpyye9iWNSvvvi1//K11175Dy5tX3z28OHD47BYLOpye4j1cq6sY9byGnuhZyjYGAprD+PM1+BApQumBrejzepYtistzQU25pbe38F2nfy3VNqRVJEBXaLw0mgVjRpMy4x2s0h5C9IiLbmyH2RxTMZc4eR1iFBmYppkA2Otp82B4SPeKhY1lENgtMYuUrJDXwxLZ5Zu0h56Hy29eNRqCtbtWzR5EmThTJCBMB2PImmlSV2rOHjFKBzCqqYuJ94XdQ3rVRS63EbzIi5MKKSVPOLWXIFVSwq+4/oaqDQiGeNXx6CaTPKEkjJamoFZ2bXPQgAAIABJREFUKGi8noZsPEkgUoBwK7XduW1hPw3gzuteSq8XetcJj0mzAYh7J7s81kpCVnQYFupAxBOr33/7gz/YuL6Rn5/dPFzh4wsNPztu0Hj9+nVjVeTmVgyfb9OK9tSTxL8czNA364uM6fPTv/vzxcHMzSBoHvdnLKaraN4Eu2WwHC+T6sZ08Cbkl09In5VA6b/f7R/QLzumpj9f1oFwt4/ptZWb7k+/lpT1Tu8L//Xv/e7vX3z6xJM/GdZWn71+48ZiZW19VBmH5tTdls2FJQZMNSSQaAISJaMzfd99ZgylRDWhqbfKJLnf2k8rKYpoolSDzSq8xLJKoph2oz4PDAD7L43aXSOM1ArH8hIzacpKUb1Xupq17dfQDCfjk3TaEJwWFG8ULyidMolU2PT14H3kx1tY4UAwCukxuR/YfkV1AwUZi2Ov6IywRhFwiOTROIABabptsqVvfre198z9qELFPI5yVkG3LS+Fag/eDaxFYo93QFBOoiF8a6NZHdqVLM2mA5YvQzBpSpPBsIIDj12G/yI9F8UtP4gBd4OlY7/ZDnjI4OGJn1mFVzBOi7f2rOCuqMpOYaVQhyqrhj/9vA4qNm6Pi0sXL8mTTx7//QsfX/qZteDMNbR03MhruSuVdFMjRgclbvd+MwCZVj7u9Pl/q3Hz85OVEP8+k3/v79gdUbSfMhz17pa03HnsntEeGGNt4U1Xr13dIQGmK++3f/Fbf/f61U9++cqVS8eOHX96W6M358/v0h3JhRNG5pPEg7BkiyGmbxhuN3RSOokEilEDwEErpE/WZGpEb6YgkI0Tsvf6hd0ckFUURE9L9JL9BtJvjWzS4DOUpn9p3vPp1ZlJ+2CXCksNQhGMUWlqGSabYTlMtxXOkrX1HrTrm02mWCyOasLP0CrJkRUajgTd1NqED51zIRzEVM9zFzil9iT95kAyhNdr1lnYxGjgKObtTg91FBEnpCT7FHIbCGqhAioZ7a/Jj5lY5aIHA1iTti1wjQWsqort9xpQEFS1lb4ozyVCo+sq7rkmmontgjdkmvUowr8UQKGR1fbX585hMdTLly/raEt59JFj/+2Rw2fPHjhwUQ4eOtTey92JvWK822X9XiVxEOAGjdxX/8i6z9BuCvmbx70bu3qmd9MrN7jyG/TLlN/msb+Hgw/n/3hZtgxFltu91dhSeYvJX/zZX3z/+edO/uzgkUO/Pi63h8Vi2NraXMbCKdJeOBOGt8QAMsfIzDbLubnN2aWpesmmVPbwjdEwqKBHYv2kOsXNwCNVWZOw/pr2g4L1YGXFgIX6pK34lIiZDe2iQgEuaJbRfmi1CKTJRN8ldDnV+n6h4hNtjhKxbpUJsjRcj5mzIJImNMbmFQpE6nWGayTLVBYKkurCMgxFIVHqQFBLsyRDa4eBPN1vFi0utL9EdDQ1+q6jLaTd9TRoyGl1m3brgWm0qW5r2KskXQgNHyNII2vFi3AVoiRNHRIjhMFbmTjFwLSl0oStxyWyNaZk7IBmk0yhypBFsHZ4uJMQPHZ5QnLjNaTWIhIrQym1Vl1cvnhR1tdXf/Ljn/zl/3v6w9OyWFlpCzm/2f1zsleenb648K/p8CBQz6qZn//7f+wWMJKKtukwRE070clTe/dbi2UetzfY4/X74lYqIQcn586ck29/5+W/txzr/3Lp8qXDx48/uaVlu9QoOYytF2BZPA9ipk7r+kg9CWZGadyDcMVgrEzac+BtK8mppOyQz4llvEnOkZpEylZIJ6MEG0jjLqrXYPiBV6cCGMQ7nQTMAj8VUCCV2EINYmYqX5UxOJjJ0aEnIQObQA+mkHI7Mg6lx/ZG4C8KOYgJLOF/HnzgnrVj5G2ARsLaCOmixrT8FpuL4gRPtiVI8csxUuJMnU44qcU1a1WSkpJeQbWoTkkzfMOoqAC31argNBtOGuBN+79gOLfyxcBUH+Y4gzYLwBCnYqdTWsBMoDdiuSzIKQnH3Ftc4TxC8GOUp7C0luzCPAbB9+KdN9/7rY8+ONO8RfxzwVbHlBO4i8ctn/8+/Pnvn3F//s8cjv09dgsY+cy7zMuMTnCay3XzUIQA+oPJK2Y3AxEy4z1o79RHp35nbWX4Z4cOH/z3N27cWFs5sF43N7fYPWm4IpbT4JEYJgVYqheaOOT0rZryBp+ZI/GXoKI0Hmw1kS6ykM64NNhspW6lolKPHkNDBkNPy/c52kA8jS3FJCeVk1JJgc+Eh9KrH7V1UAboWOqOXNfQoZC7AfN6YVcnibfxvpgESljMVoO0pgbtllSbxvUoJXERgvuAs8Bt1QmPIjQ5/DXkzGxIMSs3yiV5jJ3lGf4vBfkvHRRoJvXDUMQy/Z+sDWPVgw018mtj9ymXGhmBhwBD12A5a1Xpdl802BygvzCSpuJ4AAibWMnIvg1XulY7SfINm2e4bZI/GbAvWDIFoM7LL0uxur5YLJdbmysXL5yT9YPr/+vVTzb+CS/8XnNa/rznv1dAXbq/R4DVPG5z7AlCxm4j1s7jwQ/6jdx8X3j1zO+XZ545Ie+8/Y4cO/nYf6LF/tWLly69/PTBZ7zbojaG5sKoaJhKKIN4EBIT0/AKqbGat1jctpV7a/LXBmawbLdUXfSSSpAQowZA6aww6DaATipkLHsNiGHRiSCnMUONPFDUWKgQ0TB8b00P5L3FnA69EFBGerchBaaVNJi9zwTZjAjumT6Uc5Cywgm8O5NVYZpsm6GDglr731vm44M8y5SgmtZxVSiJDkDXfPU1ZSmaECoA2OCYrLDt0Zi+vJ7kyliPuzNWgUC1BQnWd2iMilgY6nf3e43z1zpSLYFPm2KGdrAV9JchSby1z6eFtmTkBmWEIgRMAT8t8xLZPmtIKyxcmy9tp+5bDURilOxY0Wob2zf8nG+9+cqbv3Xt6tV9O1PPz/+HY8x28PPYU2NqiDQ1veMXA/VeeeVncvbcWfmT7//w7NZ2/edmS9na2lgsFqVaGm5ZzAqFbY/4RmFodS8NzJI9pgSm7bAhj8TbwAdEEtx4zEiWhYM2tJcc2BmhAoS2JmG9JnD1sJra2oqUOsbXgdwRXu+xyWK0Lmm/h05f2FKQ3gYKuQttVIxObax0TNw90SuKMhJ93osh6kfZP7Eg+4are586GGXLn4LnYdNzbtLJLxkh0zgyZJpQaM0XgUua9u3uvEFj9iykpF+uJCs1Qv0nzq3J7QADKAXEfAVOYZyA5Jsq0JufATql+vkpRteUQB3EeoJLUDKsJ2TcQs4Q0hM1kvI0rOVoD1vDBg18pgNrq3VrOa6dO/+xHD5y6L/Y2tz64az8mMdeHzMYmceeG7eyir75y1s5Xj1ZLA7I8See+XuH1g/86Nz58zKsrurq6go81dGwJ4VB6a3FnH0AEIagtSmkcMUfnmap/G1/PrK90ZowFZbjuVA3MCWaPWt6okctA7NjickW0XY7ooURtIJifq9YVKhKFEhFtYtLNRPwse5uVREQQyAUojEaSKStyqKQ/MZMG9n6Uhgrx9m5pcjQNJZe8rBejeaK0E+9ebfQmJ8xtVq1kLiDdllhkSac5Yvw/ZVRxnH+XBcVgKpXcAQFlxLHUCzKK1A64fgxKnsntQt6ClkdqPSQB4I/KyYp9G5/XDuxB9TlijpQIFz0nQr/qgSKHFAIqTyVCNtBo9C6T0wjI9MUtuGjYRjq6sqabNzYcuLI6Z/8+K/+hwsXL80PsXns+THrZuexZwZLtbSE/rzSrTPxf/VXT8rp02fOl2H87a269Y+uXb2xOHLw4Li9da00DoAiANUnn4KE/OjVaBi6U12D4gedJVKgikTeRgUI2TDC2YBmMNGHPhP1D9h3GrQ1Jf231JK6SPGNdDuzTgQ1cFAkjSyAJSwJrVUhR40/1V4XqcJei0ephAJXwXdlt0moZW4rdrQnSqb9NkhWSVuls0rb8xKgoWf3onYAHxIih2lCDY4Y0TpSApDFhaHslawLITjxXRwDL5SB500Jq4Ink/JqYb5LHXi8PY44XgIsxW5NtMXIA4m3bVhUswpmClEvi2nu0VYN/vbtCgYJpWR0IP3Zelxww3uwUu1uduFiAsVwDcPbRnUuKyty6fKVlc1r1+oLz371b3/wzul3H330UfGYC/fc8a95zGMvjhmMzGNPjakD7+cNL12fPXtWfvCDH8iBg6v/2zdefvFPT73/3i8vnn9hWDuwLtdv3HA8EoEsqG6U5BlEeT6ARUWIjHQ/74w2oynXDkEvKxLwcI8ZlhTYSKU1vF9m5/UySAAb/mxC0SUUCX5GShCSojJJwZFAQBoVFpqsKzLys4MjlswKWJdIQq4kRDS1kTUfkPDRp58KsvS7yDVz78A3DbKGv2cNLOa4ZES2XNsf0jh7gQOHM3HabdtjYk2E/bLPo7A6LeyjlUluHq4VL0Gaw/PEGV5PB/zs//DQDUJrkIFqS9eb7GXnzlr42xEt8fwHqnUN11gohpqenbijWtEp7unCy15ydyTqOyZrK2t1FC1nPz4lpdZ//Npr1/73X/mVXxVX1Dhp1b8YneDDrdZPnTolb7755vyQm8euHzMYmceeG1+UzOYcEreQ3t7eku3LW1dff/Wdf+crL5z4JxcuXPjFp558Wg6sr9vG5maZzOBJlpCY6MyYiK99vofHZlQ91MDRKEZ6Qs3ct64C5noalICYKrHg76kysrNwEIxLtVzCa+0O7CnEQLCfwMsdflyasTSkIqCIkk0ezXdmtcdoh49FOxsO7QBL+ra315BnQ8v40PZYSlpbW6oZpYd9h9D+A8hp0A7ZOLzN0aJhJIP1EFronBA0uASqGlSdBnrVk6NDA33ptGRUaUKLFB0y0FgAyRjLF8wN+tk1R1hhci/FQOALhbupJUqFM00R6SawBUZpFbi0IxXYkaSCm24sFrgKxZRmwOvbH21ldbXKUPTU++/KwbW1D95+873f+uD9UxmR4UDk5nA3Wq1/UfA+j3k8yDGDkXnsmeEPVCeuftEkUv9bf43/vXNIbmxuvfPUs8/9u1evXPmdc2fOPn/ixDM6DqON4xL5LG3hi2ID/TILV+FTwNJgQAnZA+aSJnipO0sZMdkMjYKIigiqC8IIkoo3KvTAEP5HgwWVcfTFJhMX3coRAVsSp1AFXGizbuxdJI5BIA8LF9bZsmH50VQibVMF1M+wfKVWV2iMBt9VFU7INUsFEufHoEsFr0VgP1JYUEpwFFgicpXJ7tDc5bTsplQ3pE1GqbT/C9zOZnha6do2goo6QAKdBYuJswUd5SYOMIaqSPS8QsDLwCHuU7ZdcisTnnKUokD/ibSBaOpNXWKI43SC3iZFm8Zuadl9sliorqwt9L13PixXL1+t3/jGN/7Ox4ev/FTklLzxxhvzA2we+2LMYGQee2Y4qHBXXvcd+CLDV4zu3Ejfhe3NLfnRn/3otZdeevHvXr1x+b8/d2F19fHHHq/1equhu81EqZWND42cmIrZQ8kCwbQr3RjLhMzG5nbOUntvO3D6VRBTYFuildxHy4AbZvUZ3eiFVQp2dbIVkLqNAB2NCVpkAmjCIzCnzvAoQT2Asy791drM6OaqIy1ip3G9vscjwnwpbUX5RGuWHILyUsJCoxVdqpJHwlzg8GuJikwArSp5gpX0X7ZuBM0VGN4DICXlFB6mhQEvA4ijgjg7euEaBblxkkthe4pdk8wcTBvYoOYaOMFxmCF9QbkGzRaz7K0JgwLSPhfpg4gWUHaQ2IsLEotMeTRpHxfiG5OhFF1bXddPLl/Rq59ckZMnnv2P33j9rX/qf3fy5En56KOP5qrHPPbFmMHIPPbMcDDiBnhfFIzcPPyh7c6sVy5e/ocvvfzVf+vKpQv/5oGDB8v6wbXl5o0bnkMXDhBGj4eQj/Ywe3hjBdyIeW6If7aJpsRqHEvb4Beky5ZkhT59R4pmb4aGpxMuglaaVvRAYNZTGtOA1hgBimKJzamtlQ0KxBrd2bODGfAQcHyYsysEvZoLd5ZNomWAhDcWadquF6P0hCE1yRsFXqmo0pAcw5JATxkO9UvVir4UXcuYmGNh6Q6YRxCnqfRJ83mlTUgTCGeCP08rel6hGI6+CMilhZoVduSw4Qqf94ZztHN1KkALW2TkpExs8aD+jetXsq4jbIX1ColYln+iTGJLKUNdDKWsLxZy/erVxYWPP5YTJ578++++8+4/ePWV15rhn8vYncw9W6XPYz+MGYzMY1ePac/bCaluC327ngretvGH95Urn9hLX/+Fv7Oxef2rp0+d/s6LL35F1tZW6ubW2IJoFALLmPm6j2dyS7IREd+mxuolFSldg5HyVqMrqNBWTcjp0E6h4Poa2lgQPKJDwIJBxwKMnuc0rkbO7WSWLHQjbRPrDnCE/yiRTkOsE9WAsCLJHQwVj8AQH12bpINMwwclTxBjeBCz23mxEO9yo4EgClUs2ECJw0KsDuxelPZxZHq03lIRpPSSjAopFAmwqd9u79P6WAoxdwU3h/IkcG7CRRVJuZWWaUQarKh07i6QYEXdg5DG0C0Lp9iSl1WZSaP0ie/9wWKu8zq0vla3NzZXz545I+uHV//grbfe+e03Xns7T69/DvZTSvc8Hu4xg5F57NrhbqrTSPFr167J0aNHxaWMtzt8W7/+678u3/72t9//8KP3/tbH58/889OnTz9x4pkT40rZtq3NLaMhBBoEfb2cAAVy14oYkwy8TXFmUBlrinLb3iaXsVXtC0sWkhOtJdigqSuxEf4snd8BH/BHeH9FQSbmwYJGALXJksQUEmUxbycjJnxmK0zmY/+F7BjrulS2cCBhVRaCBIUSVAQiWm+Hwqf7urRzXCxjWCqN3AwWbtZDgr1/NLoLKg81gv7i8AsOJasvRhc0FljgRG88ZBJ20fvCz0tPyyWplgrvgqpQdukaDhqwJ1WyaYWryHQZi65O/FUjm5Sexpvsn/hnRSewNfVUF+sHDjQay4cfnZbtcfnxqbfO/Kfvv/tRy9v3JN5pPtE85rEfxgxG5rFrh1cyvCXDTAoCk9tdDfp2/PW/9mu/NvzZn/3Z+Kff/5M//frLX/2Pisr/dPr0qUNPPHlc1ldW6+bWdgFDc8pIzIJ6Ftg1WZV087LkPPTgOahZDAQQsEcRfDYJ1cu1f9GS9X/WgErWSiytxckEoVBE6KcRhAXsWEzRoMK0nRva5F8QXuOcC2GDpE+Qmt0DS3c17RocS3cRoqsJwYO/Z2hgD2HJ6H+Fo2y6a4TnnGZrqJ3Tpgdu3BoWjmq6rfTKVBZzwv6jQSqVOHeNgkpuT5m0gMBrSZosZTNT7Ka0YG3+MLSkB2CssuOYk/ZBv7kKYmxyYXKLcYIqPF8LKyzgyqgeOLBu7qHy4akzZXu5fPOD90/92+fOffwj3se1zm6r89h/YwYj89iV49ChQy06fHNzc4dc8U6GV1q8tH3t2jV7/PHHh7PnPh7PfvzxP/7rv/mvH98eN3/747PnDhx/4risLFbq1va2V9RH5XK9suugbT1PumiFval0yIJ4VizTJ1wPoaCiHQNTYcCZqMjXJ3fDLKeo1MWS2BpzZBebwJhMSdqEtSom/Wl4Xk9DMXq4TyzsFdyQGiSLyA7sCT4wMe+VEH/jCIjpYh44q8ArPZOAp2enT/eTVpZMyi3W5biSxmdoQjFiOa6FwRyupDUdyCNU+sYR0LB9kjYcFaXQEGnE4qGGIdRThzVLjUJN7qZ2FbEyFjGwU4mgIsiBq+GQQ2vUnMusEq+Y6M3noR34MCxsXJq8/+E7ZRyX148fe+Zvv/Ha2z9yYO5fIjK3ZuaxL8cMRuaxK4eDkQMHDtzVXeND/Ac/+EE9e/Zs8ZbPOFb5iz//0T/4zi99+8DStv7+xxcvrj7x+GN1sRhsuRwb2aIoGzXMYUFTYWLUpYiPTxSiU+ELyyrdWEsaqgn7Vyn9dZyfArAUiFBsWhSqlG0oSxIxSYN7USHILSWrJSLInuWanAUB9AWIt0ARnbJto+PU3q92QBHq5OanRgQiOBs6MTRpfI5I8yf6wr+mDme9z6AoflQwekWzdZL1GbitgXIDlzOesiJK+/ZWgZq8TQG1plolY0Un3nXgfBiARuvLlArLkmQHt1GNCc7stQG8VPi6oA3VQ2lYjUl2TWe4Gv36/RXDUMdx1FMffVS2Njevnjp19t97982Pfn9YFDl8+HBTh8mkfTmDknnspzFn08xjVw6X43oV425+sd3j3JPz589XVyT8jb/x12W5XeVP/vBP/6vVYeW/scG2r7myxs0p4KFBwiGrBGlYRWBRdvBaEyKwk8Ek2NYc6OzTwBeBWdK3rH0NmpG3KcEp2R3JFbrKRHwSzNlguUbmbfvTkVn8MsE5mbuj3DFwX0xSW8NOCSmwzXq1Sk1Fa8a4ZNPKWrp+xODAe8ymMKgdfa0x3Vs4pGVRIHBGUCA6IjKeGPi5p3tZCnbRFkn3/YBkFVWQWkNcaySUVgqXO81U0R1BZ62HEPZ4Q1S3pKYMJ0IDajJ4wEYGUgM4lR4MEGiK2TN5qWs4vUX1pAxFxnHZUMyHH5z6D8+cPvt/uqmZV0RuBh5eLSQ4mcc89sOYKyPz2HXDH7yPPfZYky7WWu/67jkB1rf/wgsvlHEcbXNzw27cuDE+duSx//zGeONfu3r58i8feMLzbwapFgBGIdNIpQUbCSz8K5me6LZwec7U3pZGH3NYrrKtlggvSXN3LKFrMmEx+QV7tKCs0c4J/NDciwJdIpREanqfW2hREVaTtq4tXzZsylAvCLOPQlIs5/4EMXTOKIb0nLAejX4VgY1MSxZIpJ2G2AWnFv+VTF7JzUVnKLkVys4Wizs5GxczYpPuZNq6U+m+j6JH1WSNJMhSWJ3C5CPUQWSDFG1peQrYSH4K8GgayOD6ssaS+LJoP3XcM+3NNaYOpKuaO8VHDc3jdaTKcO3qNTl85PCf12q/I+A5OSDxz8GUtOpfXjmcqyPz2C9jBiPz2HXDZ2jnizgYuZerv08++cT868bGDVmsrMj60YNnNy9vXIy8Ek8oWzYoEam7O9SrlS4VRi9QiiOy8N4JkYI1cjiv6iRRNwPg2LlBKUI7xGnc05bO39oCI3P2JwQGApnwVutOF7CyT5PUSrZrTeMt0mG7C8jEKAPhwohUaSULutDXfAdIWiDgCRyVkzvZnAyiHfL8hYMHPNCSDFPgdYJgmtD6GsUwrO0Yo/8U/64wRFOlFoiyGc7+JhOtdFq4oGpDBUzb/2iEGSL3dOqR33zkS5VuGALjkomviJCO0r3NarenV5SvcFdVoLAO8ETLIMvt5fUylKMictHBCCt60+HeIrfrtzOPeezGsQOM+KeS5T83mCJhah7zuN/D70O/B+/Vys+361WRM2fPtHn/wIF12drcOrS1uX1QysL791br0tLYA8WFwtTWmHlqIxPUKMUX8BVYFynQrbYSRoEKFU4aAhesbjoisDir8BUJR4pkrrIFIHQSEfqwd1NPTn+WXmDV4KURWfYlrd2D8BByIRYTjE4eEo5pxSKCtrJIMKW8KiLvYfraTyxc1jSBS8p+k7YTNmBFejck0U90XgJ+DJiljbUGck+7RbwBABkrLwHdpAcKC5xIitIc1VADCYgnlfxXg7F+I67C2K6ymUR1c7a6InemKiXAbOtkoA+gZsW5LcImXLwXg3EAZ/wYhoXqqqfyXrn6/PXr148IuFNTeft0sFryeZ8R/yx5a3KWAc9jN4+Frz4FTwkv+zna9oAlVzFcv359vnjzuO/DH5oXL15slZHbNTj7vOEPaL/PP/zgw3zY28Jse1wu6rJmTNyOQjwIiaXzIqHIiLp/BS21t1tAKaEkNzkYMbU1SkNpXIsWsOszqUaRYeDMFYH88SfSXUti2T7xeicVpGoYnAWNRNtUOI507gpXEet6Gi2o5Fj3H6GKNr1FY8416pWDkWKc5UVrcWlP2muopIEtLTio6s0SRWGNImTGQqoJo4VzH7JRQgKOwqFkmubfaKwV0EGR1mMyjctphBZatha0TTrlpZ0bKylDLt3XPfCJMSq52ZaFiFuEpu74N+pEitiiQB6lWHJPGCxskcBYaLmGooqzaxu4rWt+D7z44ovy1FNPy9bW5h2Bcgf1/lz/q7/6q7v4CZrHPO7uWHg/UvBwvnDhgpw+ffqWZcF5zON+DV/x/exnP7uv57s66DE5MC7roi9zawHjYxou0+r4Y0TA0XydnhWdScKKAz3OQuypjSQQBM5wkYfctCScaM4ToZfQWsYwyqKch1wQzHQj2ZzagUPYW4C0gdJ/a3xgbR52ZBFU02Jdmii4+7IaZuKQrfr0WFBmsaj2oFZRI3olwoHbL5p4pYGE5rfeOBEqKYhJ9kWJkk0IaQtt6sHJie5O2/9RgkOSUYWUIDdJTW2/l+TdCk+RESrUDNsNBqlO7EQsNEU0PZnk4xEzQnyDmtEkPLkVi3wXKgVQ1mVGvQ1XXS0cp6Vij9CAUp5fYBU/yOg24YLVakcOH5ZvvPQNuXb9mly7tn1HVWoH3a4ce+mll1qcwnT4ZSDoP3v27J1/kOYxj9sci3feeWc+d/N46EebHpbLIzKOK2293qQdwmw1dBZiNqzGuNusSnTpp6bWVUixbDkpTfnZZ+SY8hTZca0ugFg7uIy16b5F5SiNWMlYqTXTXcMT3RiXJ6G1tfxdY0QUQy0AUTZsxyh1uAEbKN2hLEVJW8nUQBy/1PByrZS1ZN2GK/yAMUQQlicwGZ41Nh5BNumAz3c3Q0AgIQZBG43dlMWgRgMFhOqpPb07kwHDnhrUCLshSrYdNFOwONJrhde8WY0oKcaEO0k8YcMJF7oqggyt/9pSXJ1mr+FP0v4XOXwRD2xqi9bcEllZXajzmD786CM5ePBAk5+b3ckC0eTqJ1flyJEj8ugjj05+GvysxWKQt99++zO3MI953OuxJ0gh/oGZWePzuJdjGLweUNfFbCWjZr0gEgX/Si5mZbtGVemP1VoikmprAAAgAElEQVQjJK2mGlRb/yJsxou7nLI4MkR9ArN0gwkFPmIpbKE5emSzaSszRNvExoLta7hy+cursXhDnQnSWSRUNsFvsclE2QWssChFYGxQVpQZfMWZH6HdCUQFdELkEPoYz1JhrSXDarS0nxVjWq+wGdRtvsLV3oKZ666jlq7wcHwLLoi/O7S6wSKRwjk+EnGt1FJrQaMFtJiY9dFXMoiIWpJhK1mogjES3N8C2DBSbRyG+iFU4p2H6DxJ97s4xQMrMQZ9MEjDjTjChGYj16ckvRks4nZ2SrjPR6tvsbW9rW+8+ZqcPHGygZG7Mq7dtBEVWVks5Ny5j3+uYjKPedzvsSfAiLeNvI2U3tl3OHwbU0fDh2XsBUDnqzS/1p92ne9FJkcEjomUUdYaxggrUyg6ZBi6tjTrIJZVhZYoy9j5oC8EUKikJZSY13yjY2hZMrpEYnIyGHlADIJUOqUpqtK3PHLqopCg0GL4PFrQLQk8Y1CvdsFqfBek0I1s+4BhEbN5QyiVjAok2/r8HZ5nBYTdaq1zVC0D8WNKDZPcqiOLGiX+JN6+BBdGa+VbWsNwKCW1ooZDmhEdLK1V2WWJdy5h7uFMC/qUaLdsVRnGQVldIreGwTfRW/MLG7omTfKxv3pQZRcuwpDbuRjbtdIMzylQUUVAsrQulZCqan78Dc1qZvyIUYvTTHFLcHhAJi5R9WrFJUcsERpUxrFoWVSTYWVltVy5dEXeefcdgf77rg9/5zpWWS53t728H7+3knwemBel+3fsidnYuSwffvihPP/8823ioPug35xbW1tfamLyv11fX28E3TNnztzT/d4tg+Drbtmq38sR7pIin/70VVlfXxNJB7A7Hy323kyWoz0+mhwscP60LBCEIAWzNOmrRh+JjFZL2xF6hnR7rf7vQv8tC5Jss0wtkRbTfhJUzijIxGxXC1iRXagbMo7Gf1V0TqwTMzTPT4u8Cy0sHTYYSJdOoHGIlXwHus8XbqTN2VHaUa7eBVYiqrTwUviuA8lor3B0gi2iWVIOY2CmIHGn8XpLSafZ6JKF/36cp2SvTEzo4OuOsDxeEi+i1CCHyqRjRBVuVIfGpuCOk10nqTut5lO6J5tOLrdChRvYUtk3qpkYxHKHpCy49iJIQJ4BeBbE4NogEc+vv+0KQe5QBt72d304fq3j7ucHOpmd3kD+3J4mec9j/4w9AUb8pnv//ffbjehAggoLR8xfJlLet+MR8v799ddfb8Su/T4Ivhy0ffTRR7v+aJuMVD77em5ubTWFQK1352HEpLrRlmPrnDhoq3XAQldo65WERSFPQdKsPZittQQlpHZ+AAiWqJyUxnsNTuxgYVdCxolaHYexzb4tNXiwFINU4O+YzS1MQyQUoemBQpZmK8JUEDh1oDS2Zc4MmsUI+qvGI91Vol7LGdsfjMqmRWXDoiGgEZavE/5D8fNmVsaitcOgjhl6oJ5/Hxib03TFlj2ZNpYyDmHhHuRe2O43F9kQoWCPpO1rJOaG/wknpyGhlIffAgK2ckwgvaGdn2aOZm36b04xtUp3P6PpG8ESzf9bawh+c1lzIZKD7Ni7VRUklZIGb+kA6/cULFS02pAknahBeeWmLOvoQXjrrdak966aqUlD3v0Tuj+73njjDfnWt76VZFuCEV9kzRWT/TH2VJ/iVmxvvzGffvrpZgL0eSMmsPrQARH//tOf/nTfSLWX28v2EG8PpTtcMrZ5wGfudVARfMYZ6LIJQw5U55PqUBnqX0CVxJzS5pmaUXDS4+InybV8QU0FLeZCYTelTa8ROd9ASKVsl3TSym2XnDxDYoKSChzCCmxZ0+xsArywiM8guxCWVEmQpaTAZOBt1g3G6AkJlSw8mk7elPyvlB6T2jkp3mjqd1JKJLrjB8oTDnNbycIU91on75su8dMzH6PGISSRFBZj8CPrdmqJMdQ65oh6hWo/NnB7GEus3IcgodSieS1V6b8reU9kojErKMAyljvX0Hj67d/1gWNbLrfvxdbvyfDP+k9+8pO2mKQrs1d6T548KQcPHmyAZR57e+x50oSv9v2D5YDkZkmyV0785vXv/sVJ+WEBIgRf+wmIcBxcP+i22XcsQ2+S9vMXZHt7y+sd6/mZQBmi9AR95vdGC4cl/G50hckL8o1qOdHG36LWwJWxaUcnFuISKZzCUD6I8H9Ew5ZWya8gg+jkL0x6psokWiYQQI39a70O7l8KVyf25EjK16wsFLYrnGQiOhrqQa24H9tpcKe31cJ+A9l1zZArCiheYSqEchrGcYruBaFawwSF7i4qJIrGSStGxiiqNMjno1AF1Yi0/4h9oA2+IgUmyBswzNUgcjBlh202jlZ6Ae01UQHCfzPGJkopiTvjGhIgJVhRrSxdaZ7jia+LV27Cyhf75WB3ubVEevLdByT+/mNLsL77UQv3enh1nMPzq9599135xje+kRXveezdsS8YnM4n8Unlueee22Ef7hPwK6+8ElLBUtqN/LAAES9n+tePf/zjfWle5z3kZ55+RlwCeSdjGBZy9MhR+fDDD2S5vbVWwqc0JsMyeuU858YsNwictiqCYtlqMNtRqYn1c6EuhJ0WZsP2kgozT6AW1ogA1kABJSJTJD3cLbxZ4wVKWQaAArmYDTTVKomOrO8XYm/QYZr4f0l2ULKxgpKD9iqR9JAZg8YYAEHSli0rJNmDmbimStfxpiUZou6ytxNs0V7CwGzPylCUVap0Ai5lwdkwMdB9/T0HMErplZJZPdwxHCxs0Xplp6JiAUKxKW1VO3rpb5u1JlbRKspazSbNIVy03LLvJ1nfGuIokA7USLGLomVtkGF9uOtoxAP5tm7sj0qCL0beeuut5qHiVeC7OeYgwvs79o2c5L333vs5a2S/UfezZI0scwdYU5WJV0T8596Ounr16gPfz3sxHFiurK7IWMcvtCLye2EaNiY4V+O4lK997WsNsG3c2DhYRBYFet4emmu5aI4iwoCpbJRehDc4vE8nM3JEkRIDr45sLtAQRCcLb8yacETvTR6QattMGjGv0te14bKBakdaoGXbYeJpj0y5tgdjZchKTII9ZiUPexKzAy+QtDVXRhLjmFWykZUcme7TTrAlZWJQprmpqPeM2QibVirYMPJcwYztCy6OZTunn3CAm0b6zeTjeDawo4Uf1wSPhlPWK1OJzVC0Ck4QvdtDCp2xzG2DJWm1eBdYv0z2n65pTFa0MSpBOOZWLdoeZbFShn/l3/jFxes/fFMufXRJVtdX79onyPfXeRb7BYwIcnqcU/LNb37zrigkuZibzT/v79hX2lYv2T1MRCayzA8fPtwmUyZ5sjWzn4O0zp0710qz3i/+Ig8NN3xykDYFLnzonD9/vp0rLV953MzWmqqjVTTKjj7/hOCQXZBJ59+os9npTdGnqKhaaBIiyWsgHaUYqym8jTlzp5ZHLbNhelwe/yLdRDC/FemAJcL2g+AaRRyCh5T25O5WiogJmzQjcjVbHtp5GQzuZVwvVC2AMJx4Las2tdvGdqgjSdSQzMGrpbvSoy5UWYKpHdSJyQ4ORgUAKwkUURHBcRFgpad+J5W0P4b6NrOKeQWTc5NgAqmDwT6GNhhME1ZzjGySMLAnL7b9thR44Ucpy/9u6c2wYSjfOH7ywPm1M3Jh87wMKwCraGXdyXB1zsaNTdne2Dt8kS8yfEHmnJI7rWbwGepZPi6auBep4fO49dh3RhsPU9/QqwOvvvqqvPzyy21S9lWBf3g8g8I/TPt5+HF6NeyLjmPHnmigbXu7A5dWwR8WDdhsbm7IoOXJ5TgeCEMLJovE3yYFsXJyFmFDo9B4vAiUGspEm75S7uISYYOl7OhVsJyiQYINf4oo27NLIBEEQ25BlPRrbptdB0CHXqUgVbWzGZKgGYWOkQYjbSupZSKp1qAu4fFp33ElspiCNXRSCvN3tXeJ2HmRXshI8mhG9Fck4JVgBZfJ31JPo5KxdiGzIagCsmC6T1Z78LMSznN5gM3eg1dwRzVMAFho2NKvefzKQB8O3oz73rkSqE64IEnU7ea8cQTFehVpUqkq4OHUUWTr4vZ63UDVp+X8dS7JnYyxVLl+9fPJ/ntxOIfkTgaBiEekuCPtzEG5v2OO5d3jwz8wDki+973vtQfXX/7lX84Bh7cYH398vlVAPu350uTPm9tPjKMtkJRWQYMECRIETUpiyxBTGDdgfcIv6bbeJ7Kpr0dqflkZGSccCHZaWDmhukM6kCmxDtcu/d0JeorswAVsEeRqvQAVlU51mdBGDFNw7l1QNBrr0QKoaOfGZCPCwKFpsyo8vAAYEmehKpEVGWOsbu1AD7+ni6mwlWN9n8oUwsAUliWgism9JOekV3AMvvZZT9Lpz5W0kR1OJhVID364YO5obzHBC4axigRf5LgYnHC18rKTBAvQFRRg1/H2goqNshxkdSxCibYshkGufnJNtiYEznnc2XCeIdU5DIr1hckMRB7MmMHIPhj+wSFRd3N+WH3q2LnqjdGUHaouHdQrV6+ePHL0qKysus9ISEFj7UzvM0xCbTVeya00uqZa5sIwtRdm466DMVqqTt+fU6FockIScWROrdGEVJSIx1KNE3NoSEemHNWcUBvXNSiwbZuZTpN70KQ24WzardopIUanJEophdP8mBUHvk28Vw/rZbUjPFSSuTrpY5FzomF2xj/qmCobJuxKdTqOsYAkYcga+TyCukWQd23ih2bhYTbNwcMu0Ug/SxOWmBHEWpSCWpxgS1YOropp309oqaXsvLnY8yHLJTpfjAPKk2f4CLcLtVgdpN4QWW6WQYBGfN+3t7ZnIHKXhz8rvdXtsmAHJg5EXAwxA5EHM2Ywsk/GF/FZmYf02Q6jwjPE7S63lluHdeGtmUEYMJL1DE+Cd8us2mrdmGNzboNGVpl7DypEsE0Zl8Y2Q0pZVSYEj2iYhEN5MZRA4J5qqXhVurOGWJah/YiKRRYt6jCFcx1ls5LkUypjWAfYYdcSKlMG2lpnxGYbtAAvxS40yIWWiSWCguW6BVCoJWTNyIMxmt7rND3QEPiT9idFkloD1W/zPalwvC8M8A8/DyuZzJcWsIqgnY4gqMmOkk5J6kz66YN5mrSgRrWpzPoL39y2jYEFsThBVREL1KxVcW5Kg4Fx1Xp9DGcVnalKWrBKLWUoHtFTzdaIwHQosjFXO+/6cCDiX/PYHWMGI/N46Ee0ATyDbtSYIDD7OXekcCFurLK3Bn6bd6rSsKoyBFcx9cQ5tcY3HIEImtmnxMxXJuTVMC2vGtG99B9hk8bCAQ3J/lN/kIQWatNJ0bQzKECLMLR1YnAClpwMQ0o8CWGBDkQz+C02RzJf2VFg0l4Kyr1Lfkw7oSSUCGOKtf8XEVMwaitkNDRV6z0v/JUg5I7EX9qI5E6L0P4jyyW9U0QQojpJ9af1Puk38BFp5aTS1T59Q0qYZgj/o3vrpLATbaV2Vmuev7gcQ2bneH8AQCQ7SqWZ4EnZXm+WuEWbB85s6jWP/T5mMDKPeQhIl2NtoWleGQndStA6GZuPmT+Ii13xWsm5aLQKzxOJdFnKTmk72oL6jbRXC9VJtD4s/FNj9se62eA1AoTAngi6AV4eGHe2kUDkwLdmPB8dFMySNekomDI9dQ5LeDqhT3Y3yR0CG9he3ZkQbjMimG2oyexaybENnEFAQq5KfyGbPSSkClQq8dfYeaANs6SbRK8f18d6NygEJ3H8cX7IEwlUhNAd9rraxolfeHiEVizkZOeoCAzZupQ62jGUN2lCtYpKjCb44GsY8dvi80zzzJiWFptnMm7Xx53I6lvbuDFXPeex/8fs6jKPeUhwRmysKyvDAioRGEzUoGgwf78IUtVod1URWwIuIrwvmnOrsg3UYuuzYxK26xMv9FZwaCH2kUgPo1W8UwumaZv1SH4YdtXAFigjsFUT2g7kB8OIpKKp4ysPw3p9Qm619neo1/RyR+fNmqUWxgFJKHxCp1uV/quWFBD6aaQxGm1WLcJlgp8B33rB21ZLAodOd48n0GFcZ+NS2KITUATRscA+jQrgwF3FcC4MXJ+20dhzT60t1mXS4XKGF+T56/k63RQNkingPyA+K6DBGitKRtzD5hH8exXop5L4HO9TQMAZl+OxWuta8wVxbe885rHPx1wZmcdDN9yLgFb5kdExtnV0GRYDwIJBrUnBhxTSSzGdpM24w4pC63d4W0TFA0UOLLRvkvbGNotCnYJGkHV+ZzhWQHdiUKUg9TZsPUP5St8Stgug32EvIVgl2aWgz0jbt6FyPa7EPj2ztwW37fDvIMvDhccRhRs4rAXsZuUBZaKeXpxyH2XlJN60MuFGcP4CquV7lh3JOXxV/w8L69ps9CgRy2CpfcE5pZ+H5HXS3sVRzR5QsntwshThhMoiSeAwYXlGgU15cVFzqgAcQyiRVCa5vTyKMLgvQXougCq4hRq/p46PmtUD1erm+oE12dre3JP27fOYxxcdMxiZx0M3HIQcPXo0cuphavTiiy8OZVFXNrc35ZAcsXTXZOIKbdYtXduzLRKr5ZpuElyfpziXXvAxL9HDpBFEIm8lA9E5XxYr0axo2w6Egymfy/50MCMBA6wVooagPWgQV5T7F5IOJrsoQA/lscQDqrRsJ6QIRknJ1gQn32LdnbYLiDSdvLpPSmpekYhbICwx9a5Y66kQrZjk/mkvWSSYa3Ax+R0JRwr5pDX88lOq27GDZg6NggmkkXnTflUBzsKAt1imE6fbG4EHYv4sq10mEwPWEHeTiNt2Jn6Qzi5Q1SQZiUAlWnwOlrdHe2Ic6zrJzmvra3L92v6PspjHwzvmNs08Hrpx6NChdsg+X7pz47gc5YUXXlg5cODgyrYHlEkafQhMRLG2LxoOmFFlV0yrZHt2Iw82GdIiFVNOBcW0hAq4TCinQr/xnHRjQmMjxDppNXLx6XcG7oZK8i8ARCCxbU5cycyYGnhOrcLS0WTEryaht2kprxMiaFrgR4tJLUBbQSS+5hkYyRnFC7G6b9FwQh2KDP7SYmhfETIQ6BhDdLqYVlAJmcTcNMswTT4otk+MF5hBidkM6KJEc8Xt4/21hVqkGrRcwsosqki0oHiNssfUYoXRF2p0YZJSuRsR/mtxiq2C+kpqDlVHTX6tKpvby0ccjPiP3KjPeUwuP53HPPbrmCsj83iohtvCu4U+LeTdtfb/Z+9tm+u6jnSx1WsfAHwTqTdKMiVbli3L9tiT2HM9dSupqblTmXs/Jh/zA1OVv5BKKt9vVT7kjseTGXs0Y9mWLVmSJVEiCRDAOXt1qrufp9cCzBdApEiC3GsGJgTg7LP22vvs7tX9vFiY397ZmdqsTmWYVGQOcosH4BnoyUqAKIx3G5Wu2FmQXjKglb+rlfSiABAhhGCaKmhUDej8ny0cfK+Or6yux+ooDc3iAV8XyNhQCRFIyqcCig5FBwA7SR9x0bRGzz12QDADk7eAk+xQ1YnjVvecCf/hNK3Nvb0QLVtlcBIm+FZxcABz4r2yodTtZvzndXTuxeFr5HQKIfZaalYkGlsvhOPYPDs5SGaqm0C0NQVfYUKsxl5RGO4mhFVAcSo95SO8lyUWbUcQN7bUDW0hY4k3aKl0SCw7RL0LBy9oZ9OsVlulrQ9fbvN83u7TeXfu67iMZTylY6mMLOOZGZaIXL16NV2c7QH/8ssvy/kLF0qb5zJvNmVlNnlulOolAihYMMRSaVOZUUSzpHELjN97QJ01OcOFoBEBN2Mu2FE3giTJtQ0mTIEzrHdsGoCPQTWWit4ECg/a/XNgKYuKxRzABTJwWN1hq6l1M9ySTYysvUilKR6zCDRPOn6UEVq4zU88zHwkNaHKaWZXkXWEJCnoNqOQCJI474JUaI1IoUas65Tg1Cu1ZJUVEKqiasrx1zaFAmqSZWqmcpnWkZRLxlQii0F8GWXiea5AxFIAhovZQAmvbIgNzomD9lsUQEol8jjTWPuJgajbZv3iZnNwrpCZ1NqSjCzjqR5LZWQZz8ywJ74Z4s1z9CLsvw8ODrwBsl4frjZNZdpawSQkOwXU5CQ2YSiAkCtR2NhJ2bHwWWtaXcI0dEQahcSqgqlxVGGC+h0AXhaomeCNNSkmpLZoy/TDEqLKWI+6AN11GKehTlqg1gUDmXDJn2karDh1AZ0W2qJ068fengG9RFLiriwF0F+FM3FzGbCOImXjR5AYNYq2+BpUwF/a4JBcQ00N1KD4/ybdP1D66rdejSowk2vEtmioqJJuGyom4nUSzXQIkFuhSisQPz37UnZ3hioQL1TLPKKLuwoQKjwh0rSh4pvlqcJ2UGQrTtOaprKeN1fmpjvL02kZz8pYkpFlPDPjxo0bf3aqVi3Z2d4qRdbnymRMjAq5CGFZvqF/opDDKqwlKHU0Bd4oFTWGCgO1WYUypaWVbPPQ6S3Ck7DZo9BuDwqsoALQRdLB42mBag3DPPs/dIuUPJvIpQorCF1lnphLofwpqgKePqiDHsAEKkNJxVmqQ1SOU0q9r1p6s6pEHjQh6WiBgYmzpY6HsolUQX5tAJrQuq8b+Sc4ZkyxkFU4+JiMo6gB4a8aVNlruiNDvc1/XgcjuxCtYwmjZJNp6hmgW/1OwopY9RWuSAkblzWAMzl/SRSvOHiYLbXqnGxiWNkAc6JU2vXYUkzilONt072ZppqMr2Us42keS5tmGc/ssFbNG6+/UaxNc7A5eE5q2YIqezAyfQvvmE/pTAkojjaKfoUGGSxvA8aqbC3UQs8RTWhAYDxU05Re4B8vZkRHg/tBZivpOclsYT4jcGFL+1+FIBqN5QarvTiVQjUTb0dUcngofUZqDbC3fH9Y/mUjR1GHqNjWe79EhAKtLPXEf2g9hhctPYojwFOLVHudoiSLtfUOFiaTra2SSvJCuEsUpGTwflEuSCrBM8/oOJChZVP6AvvVmA1JojUTFiZpaHWBW1XZCJP0H6ol+zS4nYK5pF1vLVZx0DzzVMWBqpbmHRwceFFrZ2f7ga3xl7GMJ30sd/gynunxwYcflN3dXfsoXJYiqxUBpY2BvWazXyX5D9Lc+UUAlQjLGG7wGwm2jIUAoiYIAclDYFsrAZzumu+HraFFFgLyBI6W7BEk9EKjQsIWAdQ/00k3fW5J9KlhaUPDvsqyyWBTXEi3EUJcs1ahFE1ROPkGb6YKEgdjIyNja6hgROmEHB6vIFSvmCTRVyUp1LGaoPxw2VsN+XetUOivmZ6lyjzLRjlVO8fKNhKqPEDlxDloz/bwRkLOTkyU5nxxwFYB6W2A/uAa1+DASE9s8I7M4nD9RInf0cxm6YUY9w614QLBUx0XtFWkTpZU1boqW1tnRvhMTvA3y1jW/8/Gk5KMLDfwMh75MFCgtW729vaMq3JRXKR0Mkl3VQIkUpprAHj2Tb3raEygVrjd+wiCZA7QSb/S2SeS/zu5kR3iYiOjVVI/vqZbcLe7rwm0TH6ujx7xaka+ZBqjeIGAG7JrVi0RWqkg08m9euA7JmArlJpfaApJ+P0a+ygSm6oJr+CkJDo5yYvt8mtMDshmRfskkoMEznbLOhY3ZHDlCwmWVO5wz6BKhRLaCFnbw9OxJrQFlATQ+Lfsk7FiFM6CLhNrCdZU2VkBrpXA2hI9mEpoMDImglhDrcRddyWKLYHRaV5IiTqNSuamvF4hbiZS/+7v/tO573zn2/7fZwi8uqBsH+84s+v/pGBGlht4GY98WIR67rnLxfxA9nZvvyoq56xELsSiuntIsEYG8zvsoQE2nRpt4iPRCNxkyIKY0FiyQuiTGyWGNhM/ge1wGzKWAkc9AYJUKTneUoattxl6X2SEhuAX2MfXIjTTB7OkA0qYBAyA0ApX3qZJ/aAUSYqVFiFuFCwTBRW6ZldEkgqL6SnXh4ofwK80dCxqsnI0U5oBEZq8FGXnBhzrFILpaGLUIgLHw6IUKj10xaGIe06FS1ayPtIrL1pzAkL9WfSb5u5sCKcgQoZVKOxi2U3FPGoa+rTkcteSAjFlntUxIm+99erWjS8/Lb97/3fEjBy94stYxlM0ljbNMp7ZYenBt771zXL+/Pnyxeeff7eoXtrZ2kI6EImExeOZVE4FE5daE4UOJGzeUFqr1yAitgIQ4SjWhhDdUtPDWMAh2tEQZ2Mf3237ZxZpYosPMQz66dp7dRveltkNaR523BDiaB2wIfhemtvfhB5bi1IDSwA4T20NkiANycmRjKfMNj9BBSQzGzuXRksYgE55/grpL6yftpJaJzbXxvJOmAC1TJxIbmrZDLM/nVnuAZOpAOAj+FEDuCMo1CQfRRrW4v1h9TMHk1pIkQkn3zn1eIF98es5p35KYxJHeTXoviUBODK1bGFFU4lsHsljN5z/3Nalzesyz9P+4aGWl156ybVx+oVZxjKevrEkI8t4lod+9tlnZW9v13RGrjbVneo0FsibaqBDu9IncRol/qeB4UBtERq9geOpGdM1mSwJDuh9myCuVGX89eAs3OYjwArYH66zMWcvZ0gcwJTxHGNOM5VCCY6kBpcIwE2ySjBReYvNDVUYBEK6o/FdJFsoPOVeA2AzxpMbt/cRGNP1oI/lwgGVUvIOzmwZpwNP0tgQ8Ym3AXLTtJeYKkVf/F3LcD2SOpuUYaxGb/8k+jg9DwurW90fEDAU6UvdlHmZAJ+raJDNwbLB2gnymsCEaJmZtibSFwAX1K88l5RaptWW/93urYNq2nyXL18xu4Jy5cqV5WG1jKd2LNTeZTyzwwLHF19cN+yI1QOeCxplKUd6JraFNuGKqlDtiH9bQ00+5E2F5JOsYKAa0EbhMJbkUQnQwC6maqlXOEoY3wU2pJJDnOSTHnGFP3bzmaIdl5G8Yf9efQ4hD1Z7klNIEaLfLRsjJSohWiEJK2nFknlWo3OMZxvs43QwrM1ippExsKRCjAZkN1ot0ikzpEp3/Atp1NQgSWmXoA63MpXsgGB28Z/QeWn5i8DEJJL4iKEXCkEAACAASURBVBxuKrpEO6dira1SUkHL1oSylpIyuRpwkaBKkUTF3ye8AzhYx/6A+MNfKdlL2YaiVm7R7a2V2wndvPnluZ3t7XLl2utl7/Ze+d73vlc++eSTsr+/f6KPrDFwPv/883J4eLg85JbxxI8lGVnGMzumVS0Hh4dlNU3TZt68LFNNRStYsdCct4H1ELGjKjsxDoTQAFcglrqOOtVEKZYaRQuwhRkTqXkVAS1QqgrQaBkqCTDnLbTUS5sXvJ/Fv1YRkAlARaDtrBWBMpf2nwP7QeM9ojBqjYRpDhc385bVRkUVMoZQeWiZBUTmAspqaabY0vAjHJ4gTTgjU+OEvQ00r7RXKpBqkXTbkSaNsNyUvfdFq6wChahLkq+jBkHp15h/63mGJrZYkx7cKtotzDALfZRdekTmdDUUXkEJrTx1nZBooYWlQPRoBBL/g3BaWBwFdMVWWQg9BsFpRy/ur3fL/sF+Wa0mtzB47bXX6Ix4z+Hmejs75ec///mSjCzjTIwlGVnGMzkcqGpRd+PYi7rerJ+XCkJJ8y1qOOy73ypItonhiICcmNb4L3As2MZRVCwiwFaU+1MiPPCavjmG1VpPVDRQHhYVXX9UQCBVqo/W2GyHghc7Img5QMdk8KGjjv1QdRiAmZFYVKlZSYjmCrUxcCaNZyodGSIUiSW/Oa1z0X5C6tClPPL8CjGjShM7iROpqE6QOtug6hqO+yFm5oAM9Gjwft4kakLZkSQaFZwjgcK4IK7CCma28O06KanS3xdasTX07OjDHGTeZPCGAptyIjjHeDe7RmEs0FPEqHWlnQAy3Y5nsYpGlckqGy9ZReTTjz4vr772qisHG/Pr/kPdc+nwcA3a+jKW8eSPJRlZxjM3LHZYS8bbEQ4R0Xp4eHi+lqmsptVsXvJUotAB30FDszRnjTDmaIkWkiQecqmFRWADcon0aaGgKLzPWCxQTeJMKX3vzHICKvoQ+sQOXtjBGQAqHUQrIPPEyWgAxMLgTob4OHB6B/UPwMla/kHiTVigyHNhpKb4CNpEOsi9sdThcRtcaQZ1YZ8qxO07BFVp2B8lh6YkDU9gFsEdh4ptmGtgYUS6gW+VFv4+MEbW4cK6ACwQG7ncacYT1GQwc1LltZ97HBQWfbiSDWY5rLHVXqJJCK6gVlOQqBZNJnep05Zri6wP2rVapunGrRvz/MfTKbBaMnL9c29BLg+4ZZyJsSQjy3gqh+0uPeG4C/dA9aiP3Wa9OV9ip2pwkJUg4JfYQYNWAgQlTVeJt0jAAKiiFU53Kn0D3SREUT0Bqn4QD64usKXCngSc8uHl0iXbHa1CsYvkzMb2uw5+KkBBgrXaOa9CTi5BpGWEgaSCWkn1M/jdB+VUQEWBKW7IktBIRgKk2o1lG41oMpHpgA+keZF8NaQi4JwQdwp8jkqrUmsY3Cg0681kUM3J0Hx54IwrNaM6MpIalYYmeIvChAJQHAA7VIgnKb1kMaI6omFSWc0Z5cpwRsJ2GhtGDf2e6kmu5NoqT2twy8v+VPxEiAOyS12lbjabVzbz5uJqWt04jQJrnWo52D9YEpFlnKmxJCPLeCqHBZV7+Xko0wmXQfX6/kTkKRoGQhe1LlwRGh/N995VuxQZByN+x50MzNYiw++CMkO9+NRhL4lEbWHbG46uQsAoqTklnXytElMz3mEyMNBT6pvCrT+F3DAt6ba3gzOuOnrBFdBJ94n4jkIHTHaUfSdVWuJXam1Ib+QkJGMg/qC3A+V8pIBlXDmqqmV5Cu0T0oLiWsRrieuQqKtUonrYevH1qdlKUrjweL3EW14qgAFpipUpcSY6FIcquEHedtOEkETSlybGqrVy/gIsrQ4OeYWJrYpkp6agrOIp04xMubX11SJ6sbV2Y70+Oe6jzlPZv30ykOsylvGkjCUZWcZTOU6mWKnFXHqjijKlGJeGSWxNRSpUAMiUgNJHSogyoBfr80Naq2cdZXTUQwQ9YtTa+wvB1XFQbPO3a4x2UW/oampemmhkwTRWQaJSI41mv9lPIfa2Qvare/5p95pFzQUH0a6aTlqwQzR5SiXTK4V4PV11JTMfFF4gntYbNu4Wh54OSbcwlJMQW6tKaRNhHctRMjWpyiVRHYzkLfCnUkGhgUp9iLexjhSgoGS2gBCcCWMWusaWGa5/o8UfJtyy5UJL3oLmWOBwqKVmKrcaIqxs98Sx9Wg+6xxlVWlzqwawnTfzBW1tywCoCwh1GU/7WHRGlvFMj53z2+V//J//ZnXl1ZfKwe21JRMTNMlzZ5tmcwSmEqLhImGFhiIIZeFrA9VPxuxBwLVFVNSqIWWuSa4tZLg0HFGzoCCZ0rBqUEoa8knh8QejPbj32anUEVeiGZWBt0icCGZAh1oKnQ6/U8bSodeD4N11R/Bjhm7CSKJak0gK9oh8lqQUQ5wtyhKSfNlKSf2Ue+mMFIrH53RYfRmywfCSYXKE84cGSa1d7j+pU4pZEevRv+mrIXDdGewIPYNpva4SJStiizSTKHS+nDGebGi24MIrr0zbq7LZrF/Zu7V38Vn/jC7j2RhLZWQZZ3qYemo5cSWkD6uG3L59u6zqVvnWC9/a+c0nv1410G0b2RfKlKRrXBAKEf9dnbTSOoZykBpD+BXtZA566DYSfSU1SgpcTVSOQR+7rask/NEOOJOLQuIrDfRLV7NIsEvB5r10CsjQpenxvKuuxnyozz5JQEYaAKIM+OAtUxhuaMWkt2BvV6F1gd8XgjwTqFqmSp0OWOzRlQ4ZEls4Xb5NWJRSdrNYqRK0niylmLu9b9J969jMCm2RweM4W1uaCiXKRK8XvEDXbZr+xdKTIf5NS/H5LjUDX6EquD4abr6s1tSptp2drXr74PDqZm4XlifUMp6FsSQjyziz44033igvv/yyA/VOk4xY1NqsN2V/d78crA/KzT9+eqls2vbWuW2PdZEClKC3suGgNNFvDvRQOK01ZeOGBF8GaMlEIlzm48AEN3RxCzJyCCItjFYAgnbZLeG2G1EXvZFg6M4oM2TFwYENkU0QAaHhJzMN/i9K/z/t75/CKNKVPPgrzfoA/guvzWSNhwHftwEJnBURgGTRI5KgMZsZX08zCMNQNrJI9iFzhmK2sVYyFCwEqVGifLVncf36Y40DY0yGTR1THG/kVKB1ek5K5kscn+LzdWBKeZuJBjvseB15+xR2G2fkfTlyq7dWU9vZ3qm7N3Zf3GzW5w2Qupqmu97Ldv+v15vlQbaMMz2WZGQZZ3Jcu3atvP766+XWrVunnr7JqVuJ/D/87V+Xf//Vv5abu1++vG7rramecyTDTO3xeqRGgCHo9YdweZA2ejsBUEmiLjPspFtsy1I94AmdGBPtA+3JR/YTALtQSFqQOItSQQN40g4/VbaQkluMgBxJAB18Q7yNxR6iYCpl8HtiYTNo1GSjlDpoOxJQ1pK+LUkZprC66JBUhZaIEJfhS9Cg0aGsphxJKilzX5N5gh+LDGqvqLFgylIGAZgQ0GWyQA5xSM4HuVZ6jYZXT+A+Q0oUcbi8CzTTjsh0ZtaYtKQqbIKJ0xK4o2zp71d66lWOvqrqJKvS1pudzeF62953umMyEm2m/f2D5SG2jDM/lmRkGWduXLx40asiBwcHrqdw2nG4Pixvf//tWt8u7ZNf/Km8uLlybS4H55w+KQ4ZmELclCmIEsMYYQjiVODVptCXhzJnaEBqo3FrHDUUB0KEBnjEe8eGTJ2yW0gRaVnKH6AcPhrSBIBRtCcb8PXl66jGSkqQJTnsyri2iiE84cGvQ2ik4Q1kRYkfYTsGWVKYALuwSuObdNWSQuJKqnX0gFvJL8lCALAhDZxkSIKhG1UT9EqIaNf6QH6Fc1LAWIc5BQGZq6R6tMcCzZRaQI4uw5ninXgthIgb1zcRKtlnOy9LYnHckgU1/pmSIp0XU2GfyJyqw2c9pzGdkU0r5eBwroalaUyQh2HndnjYXAxtGcs462NJRpZx5saFCxcc8/FVH8Kr7VX5+KOP27v/+7vl9md7RV5953t1Uy9NUmOTnkqhsF4RhqQGgZHqsbQ1im5xk84tr0hW8cMmDZt5HRogJYXSpecIHZ0CFY+woEPMdPdcD2u0qMmCBtzgIgxXuuiA7oqQmXLk4LJaSjC1vsUfjho6be2I8nxu6eOINVsywH2UJMWOJyJUiUOlAaIclRweNkAoFtKJ0NFBGRxdWD1hbwruPv5dSO136O7YOSJdZ0LvqEkyh7r0mK9OGyTnmEvVDmCm+7JW2vgQK5TtIDa6MDmXlEWny0nEYCUViJ6IJOumt7ucfDzFXbPaqjXefu7iexiWOy+JyDKelrEkI8t4Ysb29rZ/mQfHvfw3Ll++/EBUR4t7N2/eLBd3L1qZe7V3sPf2JHXHmhg6zyEz4kEoiKomGRrxA+EmsgOtA2gUkheACrCi0IiyYH4TI6IqoavalbAwv0LTuGjdMKr6f0OkoyrEV73vUY8c3f+2KZTjSSmG5Ho0VJxPOwWqgY2K/tssvYTzjOJMJ6BJogbQVAYikFCShRDalqgK6QY9mGR1Rm/LokJ2s9Bfklw2Tx3gJjgUD5K301ElvdPC8kIHn6YEioKo5CoqmclodFOCWkxXPwfQkmiNxCNySzCKQ3El/Qh7fSy083GgoFmPMN4WqFbNVhYsjcj08cPMTVvdWkn52c/e2f7Nrz8oX3y5V7a2do5goywhX69v9iRxGcs4w+NpS0aSebeMszdefPHF8qMf/cj9NJorld49IbGExYzATjvsYW6JzDvvvCPfeO2a/p//1/+xunXz5tXLl66E15r73EVVIczLIrBLbvO5746kpAFsyj12EilG9gopOZ1zAiJGTW98kQFA2akqwoJEZ3ogKLqPi8NROT+fWlj91VT86uwd4isEGqTErWqhrw3TCmEpRejcq6DfdlgGRb5IZ0kALhm0leUJ1guEImXwHEyP/qxmsF6UL/CmlwCLEcetghRHQ/VEezJRsvMlKYorbKt5N6omiReNGeqmakH7pc9/ps5KavenhQ5nqrT6a5huuvHVvM4NTyRCRaRXRXD/REUrbf/CqiD6fNOqvHjt2vTRn26WL748LNO0NfC6tEzTqoicHjO1jGU8ieNpS0aWROQMD7NHNwzI1atXPdm423hQmWsrbX/00Ufl5s1bZXf31urChdUrLny25cKd6kUFV/lA4ZxgCIEhDZoMaYwHQCOBmYEZEaqRoDQfomnkrErsnd2DD+RSD58B4UDzI2ViycAdjl9ig127RioaQAjQKNsI+KbJ6BhpHZkXtaS7TNDZgIA5ovWcMNVC6VRxOXa6CXvQZjFIC9AxeGulcZ0S0SHsWhVAdsf1S8iHvUOFCm2vYUjSeNgdkTILbW2qYgoS+V6lkZ9Aig0eddEWUiXcOH1hYOxHa8KqMxVeszrTuqnegKiJ9QmxtnhBTRugsPTl+sBViIqyIgSuKicokztINynr3cMd4yZ/61tvls8//5PcurWrW1tbMee24EWW8fSMpU2zjCdm2MP1D3/4Q1mv116C/jq9NT777HM1nZHDg9vTSy8878lInabm3YPESM6DpR1M7bzF0NgEaNgrV2pjTAjOc2GDI0xvafsiQpcYi7nO9WDBPnjCFXScprCej75SU5ItoIgOqVLfVYurxkaMVaqDeZSfvUxSKcDuHaEkFtv7T0gMCMJoVMPQCMtusyNoI8CbzvzzY2+P6Yo1JgY0DPpWcJgJRg5EXlu0LkJZvmqrwhxMS1dZ05S1hVZZWN1odnzQ1GnuLpOqttC1D9H4qk3nZppmEm2hAkxqaMGFO1CcUa3wyok8Bw0gadJaDUJTzTvR21UK270GJZc6ehAW5lNJg462lhWkWqqwFrwiayKOp/EXmh68VUf8XTd6eb1/WM5dvlheeOHFcv78BWfWWELyxRdfLMnIMp6asSiwLuOJG3zAnlbI7CTDn/etlW9+84363HPPlcP1phxsNtO02iowpVFAM7j1JmszWweWGlQzbCtqrJvaSG5x3xqLjXOpZS7gmESJxXfkNQXCoJo6BUIiYKaWVzTwMaJBVDyWZjcD0APxozQBV9f84GxWWjW112hNPymN8mPHXqNl4edAL2FRtFOiY4BHgoQPsYQWG+2FzbuOtYnQFKuxPmOwrgbIaEH2dSFSITMFKvAVqwpT3FBrr0nlgfCH/dZypTofMcxV9+AFy3hSAShU4XqcnRYNa1yonEDjJSGgcCaczLA/hV0D3yLuwhvYjilWGKkR8K2R9Mwl/ALtL1qgbM3WLxwEUQHSSnBL0wo3H09dnPAc/sVshEmAmXx5N7qyKz9NZa3l9Rs3b5Vf/vKX5a23viOvvfaatyft3j137tzy8FrGUzOWysgynrhhOz5jzHwduz4CQ9977z2tdfKHemtap+oaHDo37wy4PEaUHGLHnPqeA32VtFFiTT2U+Q6+skxPvixoLzMpu715otYWaq4XkWhYQQ8IYl/NKy4K+AoKKwFLCKFRJwiXkiqe6BdUT2QaJdhSdj2KEJZphN/9DHiO9F8XRlptvX1SnU2UeM2AwLYmIUFa2TICZsSrGu4/B9KuQpoFMm+FCqhYInujCsV0hf9dSrQLMTFD46uIK/dbfcovFdM8F9xHZ0ha0HfKVKFzyn4KOj+eVkRFK2XfGktL4WPYrXUqWLjwxetmyZ58NGqdaEvMcOjBKPthOGxHJCtpzLYSU1SryqxaV9OOTnUlh/v7b7Y2y2az1g8//MBlWexzYdXDxZV3GU/TWJKRZTxxw/AixnYxZs3X8cC1ALO7u6sGmP0v/+U/148//rAebg7KBT1vJXIDPAQltpGakoRPAE4pF5bpiaQuKTbgWhNKQILI+P4w0kdSEZoeWhNSCjSrW+6H6x0aEpCMjyCP8gl5NdAui2zGxVoFDn0pwh4zYwdEO6qF7RBQkdFVYI3FgSTk1zYIpIJcklSc8LKFxpj9PkVaRqmwQGxG0QJYkTb6+CszMBWBQLsiJ+hStEoP/3DpC6oM6iZhLCODsCxqGVXbwLiF1n4Ll+JCoRMtLBUVaIsMLv9UpnXUT6f3NHbWRCAnO7BjmjSKkdAWD2zeMEXUAPPGTApU6ZvIamsqK5nKwcH6dS3F/GluWVvxhRde8OOaDYJ9Pp7BsZAUntKxJCPLeCKHtxOqlEuXnrsv1fe0w449zzseVba3y6XzF3amg3VQLq0E4Y0GGO26zW1ptaV0Ree3UvEbBiTOqGnEfRJNAJCAcm9fgKfQcKc96vQGrAFAFoEJFc85GjAq2rskpILESweI6UAyBqml5X5cIcxWGJkpMeJnix9SV578GY0ORYHJng7vJr6jFzjYQhuW/BZnicSJIEWijQzYreEVF9UBSQ7KUY8XgdRYqnA4EIZrU8BDAj8lSlmYtXa99nDRBRm4jTQcT/LaQK927E33xInMB6dFTnZ0v6Kbh2aTmwG37g3QOz9RoUmnoGQB4/pQUV9xh1Wd0dIyMPfBwd4rRdUMmG598MEHZW9vz6siW1ursru79yw+vJZE5CkdSzKyjCd2mMLqhYsXyvbOllNZH+aYJi2beVOu3/ji8mZuWyujTQbJwuUl9Ii0d/QUIh7V9J+THiszrrNiMgqaNhTopfRKiw8iDTqZNwAdJbf9UCStKQtPYY+ASgL/iOyHHFLiRcF76bWPZM1W7yTUMI7VsN4n4yYib6uBgIktPURSsxpU+/ymmuLwvj6Yz0B9qZ04zEWVXEYcMMm4tWTC44CVIqmoXrtCWYWAPIpFJQnH8Y1DYyKbBIpGUjyf8/d0LPpp7HmRPY2kUpOpO15SqQSlslwCCApzGwGnx0XnTfKM0q0VyvZpwiz0OkQTL5C3cVe0qpvV9rS1uztf2qw3/py2aqF9LWMZT+NYkpFlPLHDSCt7u7fLxUsXg+r7EKsjNNdbb9oFVV1tbRmbd1Xb4WER58KQ5YBo3lJ/EzlBS2KJULacNIyo7Xssmwv5ubSYjfcPbxlJvxqQbLzLUgP+meWJxpxDtFdFOiVDi3E/vQZBKVYWAbCBbyO1VwkRLYZVaagsIBMCpiaqJEGgoc5bdiu6ux/YxSWR8Cy/eL9CoiIyMpMjbtcalZDifKKemc1Dq0vpDiwAelDfrS+AUAUk+0EU70D6aDWOqN0EKKbl2rcO6ZFegWlKYFCDDkwsIhGyLSi5KSwTGjOVedzQjANV2WDOgaxtkVPFRY78xMlT4slvaONZxcZfbfno3DZFtib72VYDgqjWP+cbKJC7y1jGWR9LMrKMJ3ocHB6Wc9ZS6ZXvhzMQU9o8vzy3+fw0AbGhEZ5D/VRnDeBCZauadXloigIeOSQacwsqTmfwdhXvRG5o6nlZDSLQnGhxeO4ABnBD36M2OPjThCb99FvgWjSN/9nqSUd6LfQTJmMHME/+Z57MgJ4N/ArYyiJHBGSJ4PXaQwvizyAxG9zdwLtEM6ain+GJliT1RimycdSYn9IqkPQwzf2kDKdBDO3+jQTr9YRu61uIxtGG064p6ZHJlLLi03p1JR2D4UST+v8oJmWi5KtSHbFao4AyaKBEP4o6+tLidiIGCMCQlir2bCUJvX3i9FrRTZtW1chEujo4PIxSzgJYXcZTPJZkZBlP9GjzXPZv75dz58+VuT08dk1TVEbW63eK1AtiLqmKJor4pjq8WmpJVkWkIQ2FgziM1LSZR7Ii/fcSPFposmcgD52zcGozQoh3PTQF0xVub4XWbtx1s/VQUSSJygGkvsgFUWE3iDjQaAk0o+UmzMPPz/3eqIpalfTZLsI1U9I12jIzUK2V61PgKlxZxuiFBOrWi2t1RHOmdeZxDCsu1JBNha9xzng4+eZOOgVydHCqJX6l0OKGrnyl8noIFF4gUocajdv2sI01VHS0F94A/REopwE9VFLkv7KaEveH162awmRZaCkcfaBIXNFZa5FOapxVvMKJ2RNp42Rve96ymlZ2zquVZcp1VVZbd3tcS9nb210eZMs402NJRpbxxI+D/cN4EOvD0x5hm+b27f03z1+4VOpUgTasY/WiJovGPc/ABm2MOi4ZIdzXB89GYVFPWgqhCJLNGuJGwvuuE3ECzqmpZaEdQEp8QuHxIsJF3wJ8EMqOovNAvAmKG2hdUMoDCq3pVwvsauQdLqKWAmRHqCxHJiTd21+J5mVOZRkIpDgoq1pdx8VhrsivGnVipdePOpCkhDFh2OTS2a6wU+PvOgU5Wej4mwQaJD9CXq1y1SStj1WgOKZtaICxOoF8BjbLMaHayOQle6ay2lSG6xMo11agWlIgQAfR/6ww8cShoDeAjQIm1Ixyfu7c+e2/+Zu/2fr1r98rxqa5k0u1/Wx391z57LPPlofZMs7sWJKRZTzxw6oYlpBsb289tOqIK5a2ZsnI6xcuXY5+vPN6NRU9icM0IZDQyNBAi4TMhFNAGbUs5kxdRoLebgm8lTDJDUFSj1QpvhmHRfLiRE+jZUjkJgSKZkMg8otG/9cMzawTiGt1oAiRFsTpyKfY4ieJGO2ZGozfrsMhxFn6BfB2ygQhjUafP4BbqanhUXmK5U03WxR9ZHjH0bEGiU6a0wUoQ8nkAdq1q48EuxqJmmSaoS4CMqsAXxoCqNJMUldrLlQmY0qLQ0Xq5oQlJiUN5Gy6LMd0ZjM5ThSwUtMlVOGkhCevQ1w737nQb9ALLpCb1UTF1IE7zFoaJuhK9mrVkfrWt1/b+cMfflc++2y3nD//50Jnm81hWa2qJyX3slFYxjKe5LEkI8s4E8PM7WriOh6wOoL99+Hhuhzs77+0s71VppVs2qxRsBC2ayjZ2ZLiOmhdkBs7kGgcFFATAiElla5oK0d6DWm2EcNChZ1U1HDw78rqWlK3xLMb4lSg2FkGUAXrGAKMLIRFQqEVa0c9UYbyqJ3UUb9BUSQI0mz1OTK9IcenG+2VAeWRcN0htQmvXLRtWDFSSJFIY2ROZTNN379K8RGB7Ei/hFmi8bRQ2LgpAfj1I7s8SiVtGebELXk3MBQsLvYuMA9Spchb0G7ZowFFae62NCzUsGzGm6H19ExIBoadDxMbVGjC91fo1EeJfYfJermr+ner2/t7127d2v3nW7d2y/7+wR1u6Ki5OO5JVnk9jC3WHjILbRnL+LrGkows48yMyR64q9UDA/ky6m6X0jbtnOELXVpknqGoPpTNGWWEdY7GRAJ65h5ooU0xUkFdWTPoodHMGYW9CjRMwsSGxYJ04gsAJuoHAV6cPPQ1TMSltKoG6bdJkkRhl8JCAqJS5gGhIupIjwadDEiltIyxsFehm3Cl3ikoMkMgZqLknFVoqzAlaVkyaQDQskvVDCgC22O0hiIlyUaFJj6WHjE9+ZNOTCIbmlDQwIKUBPMqvXR0QsHCXzNHUYf5IGelOUVUdGJKnpRV2hHDbiflTEIJrjlCFYuUGYjJupZUwLcL5YlBK2mloyEUJ5UAY8jhudj/7JfV/nJr/6C93bT838Up6Xd28GDKYb41hclaLeXwYL084JZxJsaSjCzj7AyRcvHiRRd9epARomdz+dnPflbW6/3p9t7tcunyJTiTFEhjoMagYQCD3gVLM4VMFVYMUKGAo0xvS6DA4qJbDmIoaW+PcMs/Y7yDiS8M8YEDiRaLdmDIWHsQ6LKW1E+l4mon+BIZqTCzp7tvhPU43yPAhWhRQP6MZQmpGeZDik0QjQf7/DgAvAMBUBEQiKFu0jHBJUTnIwFqCZiIg3hfK9OvXm0Kr73SKyyYeWQZNQlHzJxQ/mGSkZCToD0Ty9PYTEpN3TlXGojZSv35oryKrM/4lCtJVsnPQXbkmUgBzYpXHCjflv9FJZgW+WuRVXUx1sP99es6qz2rN/cqCuqRqqGJBk6l1nlh4SzjTIwlGVnGmRkG4DMJdzMKexDfGns4bzZz+e53v1uuX/+0fPjRh6H85Z67LdGoEZ28dW+tDmnIIgBClCZzadASr6pjd6a3TzSkviuQpcQSp/qB4QAAIABJREFUuC4q/qvSSE6TkUsdjSjst4CPkMQL8ksY0Pn3ioSpkLYTjQOnC085oTCqVe7DyfgIe7xOCULlaEqqb+mtH9ZFTArFnGkKvemKpmmtjwofF8egDkqxMTka77SSpzpQfFFmCFZtLQlfKUTLiqYgnYR/Ti93oeXEtCowG1H+AQMKBoE8HhLOIUeozHHMtnB2SpeV5ZDCoAoiQ5lL+wQVIOBwx4tjNiBlwLMiizvfnYpv0G+1PM3dgrdcV0TqzVu3vrneHF4opdw4TYuytdkrKUsysoyzMJZkZBlnZthD9fr1656QPEh1xI5jycyNGzcdELva2gosQWOwLlmRj7jS6IoPbxLABKTDB0rprwtOZ2z/04ElixVdFQNlg/we4MkBGlGju6MsA7BBFFWbCsGtiKYtYZEJEMXsUwOE1retsqcAqQ+ItUGzlfSeBJkGLLYQRpoCanTmi718XwcCd6WfYcXrvFMhR437VHthKLtLLUVZUzRFRupKVZZDkluTC9ey2cM8qWu9ZBkjzzBeyTIKacMG6p3DUCZS0qGC1WtG8T0TJgX+Od+Nf9EGGvGA7PWMFJW12vMpK5/MTcvWNHlCsru394P1ZvPcaZORlM5l62gZy3iCx5KMLONMjd3dXbdON/bLV3nAUrHSvvZ2d0vTg2lrWgEmgcRAcvcOgGnt+978F5Y0lY0USfBo6nQUUnRdvCoqIXDw1Zbx0PsBbETwHWrGzNjUF+IqmCnQDb+mn5/0aNYbATE/ZFYU7wJmMhIl7Oqb5vokUiUQLFYLUOMgO7GoUAIt3PsIuD1SaUBbCxO2A0AGjYkXkxcWY8h/Lb27VGSg+5BiSwgM8BeEm6YOCNcUCRGysIp+FhKo1HUJO950pTki7SYN1x/rr4PkP1OYphS7jzRvJCUrk5dKVTRJx2fHmpijD+EvvW9H1DRzMp1Wq7rebF5rrTmN5rRsmSURWcZZGUsysowzNTyJ2Nsrly5d8jL0aYfV0DebtbNzymp+rczlgpDKSxhhBnfYl+kQNvk/KYjGKkfHP5ZCSAkQjUFw7RWH7CoIleCLDu8BZ/0stgAVmXolnbDCMkp0PHovQzIgpz3wIBVrWmOgr2aVQ3sjJ0wKsaOnu64KybS9ihJZAJ3pWq844AQV9FVhLUFrqbTMg9MLF23Mo/opNOYgR9RHsBacU/z9cN54c8J6lNPlezSBfpkAOzNUZHJSld/C5HCoIDEzarQrPJaQecpWSq9mgXWk1NbnWqt2eE+/u1B1s/Ob2rS1quvD/Yub9Wb6Kp/TJRFZxlkZSzKyjDM3WNlojOQnHNEhaWW12i57e7fL+vDg27XWy2KUyGrS762ip6LAPwgiF5mXIWMxxLtBWbU7pjQEN9i9FjB3ybZhB4NQgzCYY7CqHX5JAi2qAFApcZ0R+Nl5e8H12IvqXGCDi/dXgSU9yBUSpZyBzjNkTJkQsbhAfocWipenqEgBGLYKjHqRvLTevCgp0jr2STJhyaMq3H5rUIy7eBt5MXitoWVbL5cwS8u+BvMdyPWXxguj/Y+a8WgFJQ0t6U+n7Oi02us3IXfX2LdKXjPc7rIiworM0LzJ/6oJcmaymreMMFuC5yGrV7gxEq5r7rzrw8MLBweHnoxcvXrVQdzHKyRWKbSf/fGPf1wSkGWcybEkI8s4c8PFoO6gRHm/wYf0G2+8UT78sJZbN2/94NJzl15yunANFzSEI4EMBcORJDSh9TJ9HeJhb+9wErXAwD9RI5W7eEmf2hKHrEcc4DT/Dcyl66HbBIn5gNcJywpp0Aadj4ZWhtD6flQGQVnFTnSK/XeGLipesCtSCS/JSkPrrQ5Ly+iCJ6UTcwc8hcdit6+hr0v2NWTM3bR27xzGaGRP0eaq5B4r2k6Sp6TsM5FArP1EBOwZ+ONCbw0VHiqwN/a3qlvn5WrYejsuGUY4XUuXOSQ99ljRiXsnlGaQUEHgVXIqwxoFDrjlf2s2+xy9ijWeak2YzLlz58u3v/1txzsdB3Abpdfm/vHHHz8QuHsZy3hc486k9WUs4wke+/v73qqxhIQAvZN82e7RHtomm33r1i3bSf5lUbngiU2TWmZDQbgLGmv/ScoIcxRphAKUVNLMHXbW+ltlt6Ip2jkaMhchMBYVBwlcYwvxTbYqmmc/iuJGbPSRD3D/z/aOx3mmF4jVzQQ+Gt62kDucWU/tk2bniDwSpAERNQm5RPmlcRGQM9jkWisp4uUACiBXA8MSTNYo+MD+NsA0PmkiYV3sTdnFEsBToWmqMOwjnqVBYGWAlXQ4q6Iw4/7FQaNGbyR5vWAXA0vSlFKuypRHo/rUemUH8FVqxba4oHGZA/AMIC4m4RU1JDOk8Pbq15C28u+zRhTSL7xsSHZN+ddYX+d3zulf/dVP6ze+8Y3y0ksvla2trXJwcJBJiVVE7L6+efPmwpxZxpkdS2VkGWdy3Lhxw5OS05akLSkxJg7ovdcscE11BWvYkopUI3cTLIkqiWCIbayGg1uZNFEVUFyPnW3oW4VOB9Eo0isUHlerEkHAaA6JEwUBFcGusdUDfCwIJxmgiehIICsVTVJwnaphNasU8MHzHf0MYkfVrsw6l0yEwo+nitSaFaZAdHSpsmyxYMC9n7TdFh2LGlJxhJNGZpUslg5CBc/H85uW4NME3UBDTih2HySW7HUBJgvoRZyAUGSebCR1AjLN/YhYBuiVR3L3GLB0a0rUR9vH20uF2jB+UnYaKOQ4+RrSNWnOO+JD3Li5haqbn0uU2iLlNWkSaWXezOXczrnpu9/9ziv/9b/+P//8m9/8pjz//POeiLuFAbxpLLn+7W9/u7RolnFmx5KMLONMDnvo2u7wQcbBwf7KnGhrRQXeaCOFjiuwoguB065sRiv5kuriWmhnAxF3aZ1mGw7A6CpUSRYOUQHAl2YNv5YQWdvUpAGHxFgVmQWSZlQibwRJwHSPcp+jLLujMVr2PdgpaqNaW0iPCZgyBC4QYxlq9FKg+xFsEHfPIT2V9rlIdACSBWWV4JoktY6aIpFANPKGqJzWEsvqF6JSnl7oRBgCJgUvCyRMTDQqUOIgXbSFvDxDgIokLgY/iFZKrZS/L3H9MNXG9yepV5hKKkXMNAk5fjEqKmrBnQoUkvZyGupNSdau/TctOVG1kShkbZppNU1lVV62I7777rvllVdeOcIm297eLp9++uniS7OMMz2WZGQZz+zY29vfXtXYYVrzIMANkKjq8uARtGqn2rSkd0qrIa7u/Z2w1+d+vZnXmUQ0RbmhpYOcjYhWwClAYDwYsdTpNCURerskwsLhsAMqlYEdRnXkk0QKVCWIwUphUc5BSP5V6pAA+DoQkwUnGUJi0eJpDKPCJkQyg3RERQjfr2BhIBYCwXvUlBJKWzL7GzTlE5wMmAt8dRK6KoVuxSmmjlZXLAtfT0kY78AkpJU1nVCV09GtuZKHk0AWQVKIpIvSJjjjluY+fuSZYq+1hlsNbqyUYEEFhA6+ChWbZPSECL6DZcJvpky3bu1+yy7mD3/wQ927vSdffvmlEjdlzLBnFSdimkPnz5/387f1+OKLL7xKtIyzN5ZkZBlP/bBIdO3aNd9Bmk6J7SL9Qa56MTw8pvW8mQ2xGC4uVBKjj3wWJJpSfby0FPKkZV5Na7u0kYscJZmtLITUVE+H8ZqgOwIGBvbrEQDD7NfedwpZealdPUtJ6539Dxx5UAacyFzCrqYUZjNgmUA7Rb1sEkJkVeBi05XopZldsNVVNkCXiAJNopTIz0YWmioNuvg1SSxsxzD0EicqgOBoybqCFJ2RJk0lsLgN5QcJO1wmZg38nXQ+LqmAUtG3SiQwBVo68jXm57OZ44Dm+Du13uJqklefCNSofnUOtZ+Ft5DcFMdyDxJ2vQZV/XYhjIRtLNoX+1o1kLBT402jk8Y3dinbadqWWzd3/+rwcP38d/+7t6//9re/kQ8++EAvXLjgWBFLRh60SngWhzGLvvOd73iFyKpCth7vvffekoyc0bEkI4952MPERLwss7cduuEgFhDawx22rlbaNuDfc88952v+4x//uBysb22ZxPzFS89ns8SD2QzLVeqJJH1YyEeVQFTOEbG0plFJEkqpVEJVjQrAAjbaUJKYuKsuGa1FCK+wt2iiA39Z4A6TNQ1ojqM9M/ZDCvxfQmO8DpxcthygE0t1+2iTRCBn48VCafX8qCWm5oikSCxGlUxLCsCXAN66yj6hJXWQbuXSJFuY0hswTY7ekNWjSLytYz0DZZToqDhIdGKuwXoMeloNLZaOo0nGTpGSYJA60ZgG7sngcbcOQeE9UILukhxwXD66IUvWWFrphr4kIKPYxHyD8JXCHppkjcgNjqx9NK9Wq2n/9t6PN+v187du3bxud+GVK1f8uWEraQyaZ23Y59k2GAZkL1BVtrVw/aBlnMmxsgfzQgV7PMOC41/8xV/4h8gye3u4/P73v38mHy5f57AHlQFe7QFujITDw3V57rlL52Vvs33r9n6wOi3G0G4dBjEUEmUTgnEFdXeHtKbORDjqVgcvpvFIS7ykGdmI1y6Qq7CrEMiEEAaPgEt72GzGhPS7b/5rTBScmop9PvGgLRRZEbL5MgeriHYB0CTUCCoNrWa2FO0K8DmqHzI0aKNL0nMugSFOGwoPCjSsQhzd3x1mdxmrk+Wj/rZQhpWW/asSbF4FISjEaAUiJiHg5uov4bk3eysKoNiQHmvsc5GoSzYxzYViCgpasuC8CewgxoaEIzC0DdyLHCpSm7l5ThE3RqUCmx1mBiEGiJHIJdHf6pp2ioQDEKWuxhKWin5NJ7ve09ZUDr88eHm93py7fTtA2/assC9Lpp/mAGxrZ89JagtZrHr55ZfL66+/7hs3i1+j1tBXofw/7mEVnRF4zO/t3Kzi9axggVbf//73y7//+78vGeUjHvaheeedd9z0jWVF+3BZxm/ZvtH0lvFwhn24P/jgA09GTOzso48+LN/5zrde2azn89NqKqn9bqHNA0C0HMRt8lP9FOSSFoWQIGRCB0xTFkOT8uKt/qbaBqWrXl9gWaElYaXb1ljDp3VSS/jtdTgp/1zoTHfEIEYJlxDY/E9dZD6AGyjWWDljiiKAeIlUE91A9zol2zbnQipz8IIMx2plgtadjXF4gF26RClXKiU2rAOkU5tLo/5XePPNSO7q4LIzGO7GamqUJqgKA9gJGNYAk6olSo0IHmnRrUIeFx05GPX6BOZAlLitHVOWaFVBlI0nkQzoqVBOJK5PKyREgzLlb6EqszedpFGbVjvFRtOCJxRKcJZaUQjyZd7a2SqH6/Xlvb3d1c9//g9W6VNWUp/mQGXnZ4kHNVTsnO17a89YkLZNhv03h7HkXnjhhfLJJ5+cmeqymXXanBl/R7sKixGWiP3bv/1b+fLLLx/7XL/uUS0YWlC0k17Goxm21rbmhmGwnU3BTWgPFntKWR/UfreMhzcs0Xv33X8r//zP/58b5LWqb6qUK1vTjrNSWuzDLVvY0ACOW1npiloz2gCSzrwkhEoPVlLRrSBKlDSS4LfyoIVEYjjJeW0mpsBdu3adCsh3aacgZxmHaJBCHz9qVZRsIPmfS9VGKsnYy6ngskJKo0RFJNpJFSTZNmF7jzIG0wKL3JP3Jrxu00rCWCNE10BUsJXRek5Sgy+tIABVZEpWEalIe3iuNsEp1ldCI43tLPBfWOpx3RJ0oIK8y4ZQLFdraJuw1+bIGckulmoDaCNFXShfF+cU5xetHImMkc5EJZRxIZJH2FCtea9I3F+NrSzkj5rto5A2KSzLsCHXtldbRvHdaU0nauxY4H2aW7qWiBg4lZX7UFxu/uy0f+923qdRZH7c480333TdGEtEeE7jl/3czv+HP/yhb6Se9jEZZ93KfXayT3vJ73EMu5msDGcfIvvekN92E1oSaA8Ty375wbIPErN/y5aX6/Fwh62lramt+auvvfK/Fin/y872udXW1vamtU1FWBRanxF3GirsBhu1KEUhcqGQleY2OGaLVkPJekbN1KUwbckiQwAuJbkdJeRM2NSwOn6rSRstAVCQWtKmTRIZWaHiCWM3IisoqBpYhU7vFSFQpvZwTWJvJ8MkoEOIsgwIDAXng/EjXA2GgrTyidJDkRSV75lci2JAcI6YbhVWpXAcX5/KzlOJmkbHhpDyE9elBhOKfJuuzAJ8iBeMEgCcIrZCJ6LCihgP7ZjUrrQb3KmaPj6FnSngUuhbQwqvApNMhIp43kMF36MivjX7aBXJrDOOZWqHB+vJEpCf/OSn/9tmnv/gOKeLF/0ZYs9ue148iIv1kzZsI2Zx6bgZpltOTpOf99jKoBmg/b09P03U8EnWW7FYYBvOy5cvH6mIlGOVkfG8rEJk19gA+E/rWNkJW1C0BbKSkYnq2AlT0ZJ268s4/bAPFbP7EfFtP7c1v1MWTxCWfeDshn3//fc9gN7tb+3aPI6Exc6BlZ2zcH/YWlkSYtfA7undGzd//NzlSzuBNjSIQq2FjAYdEBsFimWNbBF2IrS3P0hbFSI/A37ZkE8I3VIq9N2jx6BhdCdp2u/Kr9oLHjBlqTBEAVmkE3KzakMNd+n9mz5PSUtZtACQY8G1DWBRIdCTxyNWBpKs2obWCZoVFZ0Mt9OL4ocQ4CpRa8ImP13xBAJhAdlAFpVsn7SWyzyhZH5DWRJNaEfP5koykQq9YJKynIthJaAoUbVQvwXnWUIWt5vG9CMHFKgiz+sKb1R9y4vk6q+ubkK/YMqopktiSrYF/CVTli4D19k2fiM1V/2tVep63pSpbpU33vjm6v33/+Cft34vqj8r7BlwFhMSC7SWWI3PEHtGsgV1FjEgx8d4fhYLDO9iP7M4e78KOOOBve7tt9/29bBki/H5UTz/OX++H8HCBXi8h/X89yttB7YenGXZ1o+zE6fUtt0Uxt224LmMkw+7yay6UdDLtGEXzb4fHyZ3Grwe9pCxMt7169fv+KFkgLV+4qOmsxmS3e4VOx+j0xlA9EkekiqgERtu7x9cvXTluWImeVrmqpIBIxm96Os7trLWZH8UqFxBXELYPWm+82Y9goasIc6l2u1SChGiQud8ceyAb/trhjgiJbVqhyaIyKwNMIwueOoHDkP8JtnKQZhE1KvpyA858yZEV0S20oKdyhXyFo23WRxHEqkVxDIkVUWqK8lqpkpKcG0RCKUpHPil6WjP4xCOqAFEitagwy/+XdQhKODeiPetSHO8yFNT0xR4XKBmmCogFQu/XKZWSdimZAhKN0i3YgkbdEBKhwd3M2K7ogH7UGiehV4aoUPMJ+l0WJMjnAWvNBOuTF61YiKNYvyOy221tDqtapl1llu3bp1brw9dit+UWTlabf68OWvJiG2Af/SjH/lzzuZu/23PsQ8//PBIwDurw87nBz/4QdKvmUDQefyk50eCgx3DKiQWGywu097Cnr1fx/PfYou1iDh/+2/DMtoX8wMblhw9jIQovWmY9dhJs2TEoGm7+wXDcPJhHy4rM96rt3m/waoUk5c7fdm1si/S/B7lsHvE5mY3qlXUjDL7RA+qkhpW0aTg15vL0+StszmiG4Uwu5sIpEOU4mIl6RYeFCMOkQURdJJAwgbbVSoLERaqWg1Oi6T7biU80tksjkFwXVP6ytXQCi9EjKhjPgJvWSHk7sWVls6ybm+i0TcRAD9iahpQSZBjoJpBbbUQbpPSbePcyFgCGpHM0+6b52AIaIdAWpZeN9Byg/4bWiBoNNUkERlHpGbtg9CSIA0rminIE5QNkELlU5ccCeBrUqWZRyakNZnVwkyggKCTWqrRbVOKmaFuFctXBc/GAAWBt+R8nEgiIs0goRflJZCrYi0rKT2C1DWyqrwBgAiW0Nn3xWytTtXF0pBJei5YAytb53JwzaVjSpbAsCjNg8NZqiLYXO25Yc8tglH59TRI2jMRsaoC7SdYRbjfZvROg0kMBe74/Ld/7flv7/Ow52+JyPH5j+0kVkRs0/0w8oO7GuWNCYlNwhISC7LL+PNx6dIlx4JYedG+rBdIwNXXPXhT2A3xKK8P+5o07HrSE5Ltre1y/tyFsrNzzk1vm7ZV9Yhb51TyiKaBh58ohDQ29AHCiPBS8Sva3xMUiY6Llwr69rnnOJKaGl17jFqeEdMdilFZSaEoKhKEsJGRUOKooM52hfeA01JeAzKyHs4oc8o2TfViS6iOl6QFS2Q4bOS4FvkRI2IhdZmNIYvarZYkDQvhJjDln7NHoRTKH5o2yBQGXTnY8vC/AGZxRCvZRej0hLopVFJ0CMySvSG4F7rbP+ktGQKyPEPJFSSVNZISJQZYiTQJeov/A/41sa1d3aXkLBLE25I8FEW0TsOK4lrz04g0pRb6EVkWUwcOlKVtdq+u1wc/nOfNNu7T/qXRR9veOTsbRtus2XNzBPA/LYmIBWZLROxfq4CMOJCHfX5s/xP7+TAGE6m7zX88D+YH9v4PmpCcKJUmqNIysD/96U+LGRMGs0e7CHZD2L9WskqFz0c0eH0sYbSWGul+NIX7Oq8X38PO1zAuI+bIyoj3e39bs0eBeYmypgnMrcrf/d3f1du3b8rB/u1y6blLdfbgN1n5O+Q+vdZfuncuCwdEVTZYu3YHvCLpsxaG/9A2TZpLNFwQuFo0RhBaIeQa71Gji5CNBnRWsJmvED0LMY3i/i89Eis9UiDbxQ13J/YmWiWaSDjH6KdIqpVFclJpi5PQW0IksP9XJ9jCSLe3kaBMm7ogVOwQcpejgoO6RFRUFMUZqKprtNQIG4kcQzOXG6G1SoF97SlOTXRMSMY5U9b1/POYDaK2lWK3cX7Uwa1d6AXnmF0f6JsFjiY0SHR8fYfxJnwolV+Y7xJ1jASXLSSAdTz1IXbHKzWryeX49/cO//vNen65qH6o7ehnyp8BtSYu6m7Dfm+fOQsg9pmwz97joAezEn/WWzFl0DYhHdc2ZrYxJFj+6x7ckFpCYC0bJgsWE2wOp9kUk+lp87dE5CQsW95L9v4GGTitGrDdj752J/ljtgyWJKQPK1/ZTUcgUhmyxEe9Trw+9q9VSPj+7DVaj487kK/r/S3puBPmyIatz3EUuN3kBsiyKtLvfve78tFHH31t8yug9ooceOXq2rWrr37w4eH5W3t7jkuIj6p2nzKqSVA0InGrgccIqSsoVhWCL2N7HVvwloUPkjrSW5f5SZBZQr8rkpmsNmQ1InkhSus6DA1iC9efzi9dxCOmhoqqR0xnpMb0G8N6dqaAUUk5tDKSiJ1VW9hoCH/a0HyllT+WyE5BNbskyLJir18ylCPvwNuQmFLgVqehkKZ084VmrXkYon0V5eqeIURO4bTYWnryRXFZ2scIpWpxmsOFgyQa0rE4ZsP5SQrjlkTvSqJ4Ig+aCsk6jZlZXLqkD/H+YbKlZIgfOX8aDJjJYPCrHWyjq6nq9va23Lh588e3b++/qKV8OM9/HmBMtG908x0dqjns+fCtb33LPw8WcD7//HN3+33Ug4nIWY4p9gyzAEz6sT1rWSW/G+ng6xqkPxumxIoGTBBsDnZ9T4rpsw2tnYNhUE4zf2q+WHXcEtyTXFdbP5srRe3u2qa503gWkxFbXAuwY0+OgdT+/brLcKcZzJBHtUJWtCwIf53jbpgj0pSPr59VlOymt78x4T37EHydg/3a1uby2fU/vXO4WV/Z2t4pZFeGGV1Eh+ZwBXjCNdjPsa5RkDIEAxhkTKVLrQZNpZIh3KT3dlLbomnKeKKPAngE0KWBAQk0iTACSxrORjXfI6LNLmJ9gDmqktBDMkxJMXihegkpMg14Bq2sKrATZeG1ShdZA26lN21c7aOFbio0OAADJe+lEXsK2jMYswqJjsBLJDtYwooGQXv21fY1arSCkcH6hX2e6FFE7tHY8umYG1SQuowHlEHUr2+sVSSQQQVKrpFPqfgPG88Hv2uk3zp0F1jn7kRoraOJQrC9huO0GE21+nA3TuPFnmMSeFSgPlNNL03LJDJfOHeu3Lxx8+rt23sX+Nk+/kWmWCG6+S7PoxG/wMTlUQ8GoLM67LlmiQjPg5tQ+5d6UY9yMLHjhpg6JTY/e76epoX+VStWp9mIk2lq/zJmPZ478YwMu4AWyO3CWDC1jNf+/d73vpc+Mk9imfF4T88+HHYuDxvkdL85lIFBZBUQq5zYGlo/kmVA+539a8kdhX2YwNiXve5hjo3N51DfLlou40HckFJUhMVC3TJXex/2z/H7YHSEtlaP4eCmTLZvhiN+hBuVYX/M95DQNovNe6OtDOCStcNnKVdib1WBerSwWYOMwgJDb1HE8RvWH/IWtmNuM1OYjmKxZKoJM5bs91BbjOUAbTTENxRI8+PXpPxUSSyor0Hja5PLG4WOCM41TXsoN8IilDq1Jg4IQG7F/7MN5Vle08rcgclD8xnXWBvbEDJ91FCTb9ECsvrhVGZJ+Gj0UGJFNHz7xUXqBzAswSfMQHx5A7FT6O0L2LLdAFEk0YryF6g7ysZRpDxePQlx+fQFhmnNJHGhm2vRBlbJc0hLnDebzfbt27er0lqwZ5CFOSZZFwcHh3fcoR7fOD0O0TT7TJvS9Fk192NLwsa4+SpPyIZ9fP5bjLI5Wsw6ybP0Qed/ktdTR4aJG1/3xMOvbfdsk7dy4qMcFrxtwdhTtQ+6BVObj/1rF/lx7SpOO5gxWyLASs6jfn9qrNDym9Q2lpItAbFepVkTFFx3tp5IL384k/Fy9sttbhemqkQOEsBBAGMHJbIYQid+9FEkDEgqdTtqcj4i24gHvW+wpXL/HN5oaIs4mRYgCO+6dE/aqLKIxX5kJemOFxv1mTDT6qQVlZSNx8gWilB4HLhbpVYHaiRBKPa0qpbhR04MEvYm3Dq4cg+PAknouUbPI7oaHbgBjEsQfoRitgRRsCjERQaGpkEHBHUB5imEhggPQcZS8myA9eD8o9jVuMrZCYkWCqXJwuwnPQwbuyRMflqFUBxhLUnf9CxpAAAgAElEQVQpqsi8ipIyPgJ7WJKK/Aci+U1JFsjEJtyQS9DGHe7cfCHTMdBqc7VVS6bKbLbMW1sr3d7Z0YN9+7z8+aObol8nHWzvfp2DHjrcsduz/I033vB3PIvqsayI2L9nQQdlfL4arMBaNiYV8biGrZetHxPhUc7/iY6mtpMnbenrKOPbcZnhjoOJCMGXo8AL6bRnEXj1uD/8LB8eXz8K+9jD9LXXXvN/aRBlP6dC8MMYFjj29/fe0aLbK1NvnJPLm0EH5ZBBzb0HWZfwDvGRBCPSFbaRlKH4BhiA7LWAYRFy6ohaMFlJzGqDNAhgs4WiJbmFxjRBFokl6fWbEFWLNa0FGY+VDVB+0QiCIfwVuQLgpFETCFJuh4R6AG+h9FqCvQMRc+1HEfjEjRMUU44Vko2iVZG1HEUe4fAVYGIk+zQ1Vs+16ZV+wFGuIYCVDY4WTOImAMyWkr8XnYgTJb4k0LXs9Sjt9eK6FXbpILtfQty9uayHJIYYDJnYfAYUuST4hWvMakdlDhL5U8jc0QMZeaaVpzwRzUKR0gXIaiizpYptcseAaap//z/9/fa3v/1tD+7b21v5ZZVGA2ifZqPB5OA+4ys/6KiTxIooN3MF2ktn8Rlq58DWwlkZTEhsfPOb33ysm+i4T+sdY9Gp07pHtau2XbQlBSyD2c1sCcnDqpAQPEPxGN5c9r2919fNQnlWx93WdFQTHBPAggcX7dK/aoXEdzDwcN3d3X3r4qXnyrb1e4VxIbVKEzqhRxif8LkDQwQb4wCauLEdOJulIysqgQMsCNCm7sgSKDkznAM2zgJKSqxOJZRVQ9sr5bWCQpNE0FBFRwWHKqT5NoTRKjo6ga/QzsbtAFZGxrS9Z4ZGJnJBnpXW+ylnXqjZxs6P6LHzBe8WABBWAyp7S8l8BqiUaUbygmqAW3E3JQc4U4ZcxhkVHzah0jmX5Z9E/fAacZb9opV0rslaBhjVITTXBPQb3A0ZvcNnb+jBxSpFSqQQCJEkUpdsYMUMkPFZKjS53/M8b+Qb33jp0kcfXS6/+c3hkYAoSIZPs+Gwz5qV7s3J+o9//OPd/uwrPQQt6BjWjp/pEVN2lgXNHldr60HHuP6Pc9wLV3mqZMSb4kAOP8iwioQFB07KSvbjIlmiYInICKSxgGQZqfUa6U3AJMIcWcfBbJzHN0v+O82ZeAY73vjhWOTvn7xB6rRVrHh9eM14/4zXcGQUGeXYUOZ23/23//b/1k//9KdLV56/UqatLdfyjLZ8oRh8WswBX6mSYuD8ELHZr4OlPSv1aZUvWQvgISUF10ODVLT/WR4au/9499qFu5qQP9I1KByc0EhZKYXfeN/BBehLePGrNEdcQBaVIQ/y5dqjJVGy1OtC7SQrQ8rqgpKmAwip5kEhlAL0KS1w8lt4ArrYaFjiCSlEkqb/w/xqK90Chhe3K5FA7F6lx3HJEyqoB4X7smgmSYJ7xIxqQkymNLbM4rap+ImCyEtltaEbY/aBBiGha2BRPbLlpO2xUOE9idhAA1WHtba0SixROKtxS9QwhVbT1Z+rTFv2Jzf29l67vX/g6/8wnlOWKJg8uT2Pf//735/4dVbhoM2FMeXGubCiTZDs00DffVrGk7zBPnEywt0qgSdlQPAabehuHwxLKshr57D/5muZWBy3zCcyd7yR7YNjHwILLMyuaRZFMJR9QCwZYSnKqhyUsL3TYMbIsXxwntxh18kS1VHczR6ivP5GRxspbUxwrZpilbbd3b1ye2+/vHDl0so0Geo0qe02ASJoTmORQjcWAYKUup8KpqhBC+Ew55YzBTriSopFgguSzFIi+GRxvozAQ+6HG6O9JviT8tHeWnFPfIAt2fzB/j7SkTpR0wN/nuzVqABUYlLi7LrhjfIPE0TSkAE4SqOVAJCIBM1XiS3JaoISgdnvHZRkXPRUQZ01mCntbyWscNlwKso3lAJjW2cIiXJp0HyKxCF1RypYI7xmKc9BD7rM2nAI5Uqz4gX0alejzdmjXOGkG/ufGsqrhbonAIZU2PFpTXa0QIEEx83iEBJKnamwiuud0KDMEh1DEs2xqakps07F3HsPbh++c3h4uHX+/Pk1N1x8Ztl9ftpgY58Xw79Ze9Q+W6YTdL9jWKJhz1XqaoxaQfSaWRKRZZx2nKoywmrE2HOyG9Fu4k8++eTP/p5sFOIBOMbgP9LR7jeYOFA+mK+3BGWkLjExGb0AlnHvEtlpx+MqtR6nj/FhPAoPFSQpbPGZEJ2Btp577nL5yV/9RERnWbfZ/WbmjdLkvYFz2oR0Cg8wA/CAwl0TI22AJWvpmEPuvI+scgS+9KdVVF9qYjMVauhUJUFtJP6W4mgJyOjVlcqyRPrzemDtih7UN5NwnUHCwSqOQMEsyDmuQFKRdrAMMzRdopbDTgmF83Mp8i2RrsCLt/h6ded+AHyFXY3sHYkSW9NRCtJzHJGcPyDC/SSmlHlD+Ury+nhTi1pp4M3gmqIYAeqUsqkFdRiFWzDt9lxcpgH/UoSSLKh1kBiDv3ZUMdT4U+0soT+WNBLM3Je49C4X0hcmSFp0NU1Sdra3y60bt/7i4GB99fXXX/+QTDQC6r/KZ5vPR6tuWBvcntXWCmfVgwBDPm/tv0cfHCb/I1NvFF180obFIzrgFiRPjEEWx2wdTLRyGY9+fCXMyHjTU33zOJ5jZKMcr5o8zJv0uMooE5Bx3KlP9iwmKPYgeRhttoJg/6Ss4Un6uP77quU7P/rOhU9+/+HKlkAoAxqFCdremuSUK63XJtlBAJYzhDfgsxq6WA0JRXQEDFUwDXlLhzF0b5wygeyRcQcl/RSGLxQyAw9mEE8N/kcqVgS9g574FK3IhlLIlwAem5cLjvzJW4ZWBrXVkxWTvQ7gOIJ4VAwZGlzYoSEyhOYWtjShjUZP4lRdF2iiAPyi2UwZEM1xvOq5jzI1gugpyyFk4vTsRmGmE9eH+J1k0xB+AteZMSMj+re0sTYhvVLhtOYGdlL3tusMIe2wGh5WUQ1KhRkaAtBTWUHsqbQ4UnopRhYlaa5nfN9p3j63M+3t7/10b2/31X2ZPrQX2GfZKiIPwyjNntWWaFhyw883FTjHNuj4PGUyMyYgT3I1xJImM/mkCCRN4Gwd7bwtEVmSkccz6v0Cykl+b8mAle1MF4KaHGSjnKTqcScu/Enf/37DMt87CX6dtGryKHjXX+fxE+2PCoIB1h70YWG4HTvOSWTcv+71G3/Pe83Lw0XK+efPl3PPn8uqSZtb0c362lSn89vTFoMeIonUCB8RqZS4DSYQuWM1tGpVynxHDgGySUmGKZIctCTCIGYAtLABEDv+Hv8KiKUoQFSWFioMZZmHuM2vwKU+KKtKUCibLfE3hc559KwTVFToi6c4vrBegq8ORiXDo8CEtiD/wrR4g0FZo1L+vlAN7UihI3IfKaxSJCMJn0fUjsoRgZcOAR2E1wqqQInpiT+vOePwGx5AoTRN7mepbPHk4ZJPw+qS9smnT3D2qUpCXUNFTaisG9iPQuegivPly+P8+foUqMMKh+mQQm4ExTGRutreKuuDg9cO9m9f/OKL636/271tleCH9Zw5LqRmz3AasvFrHI/7+XbaYediiYhVkvhl62df9v1pnY8f94bsrG+qx/mv+IO7lfDvF7jGbNkSErugFvypqia5H7n7cY7/jj1/lgDvdSL2RQwKB5MgVk0MwGjzoySuHZMAq+Pvfa//Pl594blRgtnmcbxicL/1u9fan+RGu9vx+fNx/e+3nicZtm4mJ303A6X7zW8EQd8JF3T8b09y/42tGRxTDg4OdOe5nVLP13Jx62J58cJLZW//Vtn9/OYb2uSC+X0gq8B2VlhtB/MWQITulIcKgYRNLtsJkopgBob0eaSSVQST2CO3FEGVMmsGRRBSiiQgRUtCIHCKDP5Wkcj8qeiRSI0aQrYY+kllH2igeaAQIEMnpVE7DbQUAmHAWxYqlFQVdh6yEZEkYxBwWiGFtiT2M/VZeF+7flrMouEmiN6PN0caX+tA1wodEPyMYNhCsnKsMa1/kExJV6KNYkgbqj3xl5gHFe5lCmNj7p+yF3Okd0RmdiGtSKlDnz9NxDOI0IWmPNEX08AalRB4lTIz2SxEzUguVgBs1NzyproqB/sHW7f3bk+buWOjTvOZPr45HDcrd3vejPLyYxVk/P04h/G5etJgOX7WT/v8HL8/yfPCnj91qCY+yLjb+42x7zTzv9e87/ZeXH/7vVWyxvc97fqUYzHpNOvzVduEeR5vvfVWEOFrdWAgecB2wezEXn755TpK947g1RJa9vXcuXPCiTMRsMBgr3vppZfy9fzg8EaAkl21Kgp/Zu9L19vx+HxfO5Z9sXf50ksviSUZRk2zL8OujInCpUuXhOY/dDW0lhID4nh83qi8We0cbP4sW1LAh3bddtyrV6/K/v6+2Psaa8d6jqO50Hh8rgHnb/++8MILYmvO97WEzlpc9kXVUs7Fvuxvxhvz+PzHc7d/7fc0IuIN+yCD14pzunLlSs7fzmf0pLG/4fVnIsQeNNf6lVdekTGBOw6OvnLlSr6e2BC+D+9POz8mmHZtf/CDH8jb3327XDx3sbz+49en5998XlbTyisjX3755c/meX5xmlzfYWjUd9Ytv0qqkpcMLaJd3jPdR0LvXBkc88PF0DJlLAM5piV5ZPSHKQUsTzBMKlADAoV5P/TsrSLOOjC2KWcRnZDU/ECPQnuxJV34lHv9OkqMEqJAZYzWYamS2vAZnq3/MCnpxGx1yHBKTMrYAWM7wmm8XgUxaQwmgYq2VFMmXLDxoUD6kWRCSoiucvaYVorYO+YDy9qigsGqBZKTmouUPBqF/mxyibOAkX81EJ8ErOaQ6yUuubOvEpASeVzCaeLQdF8uvJZUe+MVqjkxv/5q9/x6sylbW9v1wvkLnhR84xvfqOfPnz/xh9o+v2Qz2mfm8uXLYs8Yfn757OPn8+rVq256zAoChb74N/b71Wrlz2BrFdEcjsexzy+fP/z82s/5ebfnB3/PZzqf8fa39vken//83PP4nL8dm0SJkwR1ftnzh6+np9a9BmMY/57Pt/GZxme1hFeYMO7w+TfGGM6/AH9pz3/7l18vvviiUAuG6zPGgldffbVO05Trb1/8/VdZHwKSOUebv82pDG3+McZcvny57uzsCK/f/eLLmDiVY/Fr9emnnyoX0w5muA9jnnDRV6uVcpEpkjOKgd26dUvX67WfnYEE7Wa1HqYFZSQoymAhg3ETv27cuHHk+FxwctPt+IeHh8pFtNczOGG++t577w2128Kb2HfvX3zxhVL904Cu9qGy49sHa5w/F9fO4VhVJ+dHMKR98X3stfb+o7Qxkwib47g+FPoZEzL7PdfeLrrdVKzg0HWRoF3e8BTdudP6jDeD/Y39fvygP6gEM6sPfKDcvn1b+QCxf821cUTR37x5U9mTtdf84Q9/KO+//35WlOZ5Vns48gNHQBm/393d9fXnB8KOP/anp2lSnhv9GFpr7Sc//Yn84y/+sexc3ymr9aq8+s1Xy813b2x9/sUXf/3Ky1d3ptWUiFWsWNBWlG7zqVgBEgbdPiIvUSVYM4U8GG6Ehv8l98SpeOqdAK+ghNe9V1tAgCmaYRKlDLZoJJkbWfPgDS+sNoCyIQl6jDlVId0GRFNBFQU5VQXHowHFUAmfHZIqHDAqQImOxZIhSXKXFzlSf0E1BAwT7boblUBbbSljFrlKg5Qq+xlCF9wg/liaUisLQZHQ1UiIkGQ1CKj4KXuorzFtocuha7ZkuC/0B4zLMGsaMVNNhKvtl9YyYvCBUoSFiqlZTYvmjDN26HoY6ZGqRkqdiSdwy6yZ0SgYTSKmSSQXexBYTeU//g//sb7369/458g+V/acS9TLfYY9WwSsSPsc7e/v6xgk+dzg88mez/a8G1uyph/CZ5A9XwxjMT5XiMfQUH5WfrYpeMigZd9fv35d+Uy0//7www8z/mDj5ihsyjgQo8g52vOHr7dnvMWvewVbc523ZzyfiXZsCrLZpuok2LPR/8vWh4QK++L8uPmz5x/xKLzwI3iW82cCZvRqXM+cH+OnvY7rw9efO3dO7Zy55hZ3bSNrmzL7GZ/PtjZ2nvdbHzsXJjP2d3Z9qTbOuEtiAIDP/lE6nmTea/0Y63l8i48eD+xg9iYWqO3mPg7e+eCDD5QXyU7GNO7thOwGtQlYICwRdDzQl6HvaOOPf/xjvl4Gd1dbHDspK6eP2aj93rI7C1D2vf2eSGdbKHN3tZM2SWHcDOX4h9DmZh8YKnmWIaMtkQAk/ay1ppyv/S1vBA6b//hhOo6TAJ0u398ocnZ+Ni8EbsV5pifDCLi1nxONbmv47rvv3hdgasc5vj53y0jt9wVZt73X/W7G+w1W0MbEh7bVdp72YeIuy+4HO39WeWzdR5CzreU//dM/OdaI95epSxY8NPA+yg+vHe+4+y/vTwVN3I5j1/D3H/zek8Tt32zPb771Zrlx80a5/vn16eKlc9csGdiyh1tLE3vU3qfaVa8iN6FhnIciZ6aqOjmkCssa/nv40VShskihqoR/IGKHLDUOhyYCwBKe73oaVAOSUkG9bbDH8UVojEbpOst6R8w0ehh+i8vRbsSAwYABioVdmucFgYjVhDTkY1nFf5Ww2hpsFMpq+B9WNqRSuz19Y7JU3OCMWwths1ohMUtAChGoidopBdoqqinEH7+fgj0rDcAaUShyiK9/1JNEHXJaXcwDJQ8RVoiE/Sv2kQIOHJdvygZaCIS0FHetgdhBqhi0ZGnsybD+Qc1VF3dXYaEH1kQQmBOCdaxX04jx8ZdVCenexr6ZBcDmqq2yYyad3/3Guc8/+6S8/74n56dS4CJA056P9lkbCQZ3Ks9bsnIcR0FtJnzW9PgGZ/zvjz/+WLnz5+/sy6TJGdzsMy0QNLxT/LFYwTaz/Y3d5AZCtdfZ/Fm1tmeLbXbuNY7jXn7xi1+kXIUd9yRA4HF97Pk6Jm82f3vWvvnmm6nWbc91JjA2V4u1jCOUardzNL2s4+7l9my1vxeoVB+PT++///6fPcxtw2ZxiHPk5vYk62Ox0/IAU2q192I1zOZnx7E52jnY89zmbvH/NJL4dkzmG4xfWTWj4qhli8fFw7jwTDJsAqMgmZ20LTwysDu+uV3k47+zm8hOgHoRY9lmSDAyYWBWaD+3/6Y4j91ENofjvTm7oSyDNDEf+95uVLuJqd7J4GlzJ5bkbsAl8vDvNo7bc5vhmy24/ZxVAu7mLREZqzIFSRITkX/5l385UaJwfH3u1dtj1m3vaTfag/ZI7drZTc0dgK3v8RucgGa7X/ivrYPN19bS1mMc9ErgQ8eyepunfbDH636nMd6f/IDbnOyYlnFfe/Na+cuf/KX84h9/YQ9NaW2+VPx+s5C2BqTDRUNaRQ3fhbZijy0RwXzPbyQQU0y3DkOjwwp28RKaqWVEjARL2K3vqoCMA4pwK419+AI9kxYZg1cYNO3kMkOQBnZtMGMSQdFY4Uf1w730G1ofodNup6Yyq3a/XhoAFuRFbBZA7l1TiQNljIiNBe4w0SdCjQhCYu7wopif+x1XAQ4ztU0kxGJdQ72nPEEn8VyixsVQVyaNuSYVBmhUEIEbADJkLKX+Ghm/SpQIqTyuAacV+NrGwkrp7+8kqiD9EGSlCa8pVKTn+xc2X/zqglKlqKhJS1vfcPCzHzeWcxpYM6AUV//GHZi9NxfGzU16DUpcYVZXYrtTq8bOL6zXD6akacm+fabseSWQTLgT5u24QnU5htPi7+9VUTj+/LTnhx3j1Vdf9eeJxZ27KYNi933kZ/a8sfe019uxCeL95S9/+ZXUUR/E94qxC1UiPw8L5gXxwOZu2i3j+hnmzpIFJmH8ulPVmvHjNMOefb/73e88Ptp72PenGfb33PDzWW7//vrXvz5S/bHn9VdZb56PJSSkVXuiZj+wRfzVr3513wOj7OaToZutBd7jN8tJhgUYO4Z9HVdgLUPAtQtqyQxLaxyWkNxLMdCSEcs4bUHt5jcDtvH1dxNBe5CBto1/WeDlTclxXArZ5mOJ0mkSkePrY+s3ftiPV0iY/DyMRKRgXe3rfsPOy3Y/rDZxB2MZt63BndafpV/7vd2X77333onnNVS67D3FyqPE2/zDP/yD3rq1W/7z3//91s1bn28dWmVKQuSshENdFNuxyYXRKqJsMj80PNVCyQq75azUJ/ciWDbuVT+V0MjyDCa5o/iMeUei8h2x58ZGOH1sUHYpUqaaMFFBzZ+gW0NuFEBjFYaupP12zkrtmI2OvxTgStmIAbEXoiuhtYHXDo+GxuqCJ1T8fsDbeMLjVYnUPisyQmLBcIUgWEPCZUmT/coqVhWtDw1cy6BCy0wAcBh2dUrK1br7jl+zBmJKlJsgpUbyS1eeVdR0gF6Gb5+VwWC5E3mDKv1yQxfVy1Zo51naOiNEhx2Qp2OUp01rPwrBcPBw0ZapyW8U3kh+EPTi7B6Ztlbl8y9ufX+eW33llVea3d/cTbMiWQZsxPGd9DjsmWCvt00SP5/296N52Z0Gq8wPAogf291fZbDVaxtO29QaXvBRyLSPyUPBM9/WjhtPDpvf8ef/+LuCdheZUDJoJT3osOOd9Dl9t2EJlF1bW187N4uf4/ra8xuYEf93NDU9yWBCYq9nErZioL7PhRT2hUagKtVVLRn5KpQoTshO7E7vz/6mJSNfJZBasmI3iO0CHkYgvseI8jI+oEzajo9x18Gbz87NMvqvMj+uDwFgxwfX7gStmRP1m0876Gx57do1+eyzz9SSXsum7eF3p2SEPUdNcsX90ej28LVys/1rDwV7ML3xxhvy5ZdfqgGKDVj8xutvlIuXLhhu5LnN+/sryFtAcBWb+lTrFKiTFsJLa5QFvNmflF6R2rqchUIbtcDTtUl2GaJqATmTeDNiN5QK4a6HFsLz4WA/V5BqGhQ2QgGrRW1BXewTRm+US6nD/r3CRBglHAIjA42gUVawgkXrEukRqbH+0REJ/Ahs+RrdWHCrO5PV/2KOZZEmKRVSIfChKS8ahRHAbsie9bOzv1mNkq4E3dikRGn340ulfX6kG9lqlin5JwMrGEUNjbKCZUYS/sN4fSEHhi7GCeM1r+WCrKF66oVX4Pojd6Ttb6w9z78BOsIrGIkKxeRR8/JyEfTo8vrHN41vAn5SCwCzy79Oq7K1vVOuf3n9P6y2tr7xt3/7nz54991/tWTEL4pVFK09MKpR2zPCnFqPPV/z827PRvsaB0Hqd/vsMfjoHZg1X3F8peePPd9tDsQHPooxtrFYzTieiJxkWEJirze1cGD/7qVv8rU8n+83WAmxed2pO2BzJlaHa3KadWD8Z5t9ZRiFEwzv+1uV4eLFi2LlbyYftoM16qxVVr5KQnK/EtlpS1THx4Nkh6cYuT4XLlzw9bFEw8qIFhAL/HIgo2zIYaUbrQXLB8nobX3ulo3KMan7e4yHfqPbA87WxG40q1JQNMn+vdN9YhUwewja+hmOydbPHqz2IL3XsN6xPYwsIcYuTww0xw+GW36/8EL58sb18tmnH/1gs9lc2t65SFRiKaEDIpBtB8SxS3YG0i3EIpzjorARATkXYIOIO9gAV3Q4mNTURCGWNFVx+EAycwSZUeANVGsHoJbEdlQFQqRG9IuGjFV3pkrgKvAQaDiBQIMGj1BklJrmpMlGFSgyFZfaqsEOFoi2ita0Fx6FzIr52g9q7u5A08pQbmkdXFuo3E5UjXZTnjjfCNWAfsQNHPBxDV0PN7gNzTmBCOssnRok6IMVYcOt9D6S64alJkin/ox3ViXah7lI95KR7IvVRp5L6QIvhcdnzkFYcQtnn8hKaxZmUly/5eqkb2AR3kjBulJA6P2OsUu9Kgd7ez/48osvX/7k448/YAAjKNWez/YKe77YvT96dA3jnp/3jTN2tu6ajNgzh5XZh+Tj9ZWfP9ayuR8O4mEOsorK6Z6vdxy2hrYxs+eWbRjvodv0yBMRDquQ3GuQxVOwHvdj6xwfY/w6cV2IVRDbcRZk3dy5kmp12mTkaRpcH0NXE49iyQeTEba1jP3DdoJVLR6GnfOT6CJJ4BbBvB3MeGd8C0Fatj4EhFnr5X79aLv3RvaNvd7+274P5tRO+ddf/arUlZS33n79LVW9iN1rymNFi4PCZBrqqGiVMKhbkG4B3LDv3bt+TkEtZT8FI6If3HHNOraEo53SeEX6enQMrVc0wNChWT+kKrjpFoZR85ZXB1um9UxUGUqycxyLMrHg00xDVLsiKdGRdJaxuC4zdGRrmbVBBF16Syg98aLZk30WcIcbFWHbQEWW2GELT1bzpMPudvCKMaCEwPlW6f2DNkYkaWgwAbLLWk8DPhiTgDZ8KK2ms45b+Gp0a6JsIR5GIgVFwtY6JBep5IbNJoPdRJksQTSqpXvjINPi/PxaVwjnqua91Y2DWYfp9xurc8qOGVRwXCd/1lJXdq7GZCiv3trdu/jzn/+DU30L2nGoUiuZHPbZON7ePsm4Hz3zLLrWPqxxL3zeacfYaXictv4POh70fkja9klfQGQwM+4yXJjTZkNP4zi+PmxlcRBNTcqySNcCeVoHe6D0ibnXOL4+I8X3JK/j/UfqoA2rmDj4+XBdPr3+2XTjxu0fG052taqFFBJSTEA89UCmtVJzLGgNOkNHDMAIOO9TzwxdjlqIStAQuspeQumJh4+qKRKW2me1s28UUqCprKForDD4aie+AFlQtLU0ylF3zvdoHjmSdvylV2pYkZECQXt1wXEXAKuAxzal4GxwPWAsm9BVGO+JYX3Jzm2sGLCu0/f9gduV5OTSiiUC8Fzo16fKbAAwUPec6+UVPmW6jBuNZXRw9cELWiaZMFaumRxFKSaRwxBTI/AHsFXMt0XFCsANHB/tmBRsJQAHJG0iRaAFS1BSTN4AzKA4O5hGGro0LKiE8qq17IKbbVQa9ZQN4sIAACAASURBVPvLKOmbeXNB27x94+YtB7SWwbNp/MycZav+ZTx749Tp2FnO4B7FuN/6PAzhsad5POj6dGXF6EVawPn+D75fnr/8wrlPPvrTX0qdZLWzDf8VOvSCDzIKZSWHwv5mYo0gAuwkweKFHDmYHwSFRGGEcqWxwY8ujsTxow1DlmmLDGGuqXdRqXblf1MjyDWJnYPQqwaWLgWlBJIvJNostfbNNxOfyl5JTS16dCNqzM2D+YSF4X0c1YuMlTWQljzh4CEBhFm7mliSVSyRAyTEz6tKLho0Xfq1E2dXU5sjOTIswJA4nBrvyEwkqT/paYeyFmTNmPODc8u5OxLGmnSoRlG7DUdVHgY8HRCjhRIxvhaCUkdrKQSTVbVKJ2KlM1+fv0R/0DNLnl8q8dpCSS2T87rIOY47dbW1Xea28bbazo5pY0CEcVo9EKB0Gct43GO5c5dx5seYvERVyvRg9r0Nttmsy+9++5vy+ecfr9q8ubaaQtmxpc0rKgQQg0ilcxw26hBK/QdCLZSYAj9M09S9ku4Xm/FTBxJw+M+kn0lHk+Rum0gUsj1mD/LU3QJdtKQwakS1eF/KaDBRCG6JsqyAUIdcJAJwU0mD/grdNJ+OBdoVuyq0eUN2FvVQpUp7YSJRWBUZzXcJKUF1pLJfoUPnR6LP4smd8VudTlMIHMaJKjovTjgZTIDT1aV0ObQgHFVUKVjmykvL9LOQDc1iTlStRPLeoN8d5OahGJd+ibisXoHJpJQ/b6lgggNXHj/ArVWYEvbZFQrnIrFTwd2gheouZXtrq/z0p3+1ZXgDqBCX51+4Ug4OD04kPHW/cVzefRnLeBTj4XCJlvGVx7PbfX04g8qv3BXav5988lE5ONj3382zYXP2ys/++rt1vT53/vBgU1Z10k3bMAZkn3/oBUAHFPSagGKy8EBPOk3jE4SftN1VwWa4gSo7FWqdZcnDfWCdlJvarsLQpFDQkJLphQ7xFgAVyaPVSvfhxK60DoPsVjXUdc32D7fskY0x2Yl427cq7omD90V2FQjUFAcTUmayXNG4FpV8H1acur4pmdGt5BTi3IVeKBGIWyFJORO66BYJSxKspuHYPVdDtwU1Fcq2euMjrhILFwG6bUcKLn2pC7O0wvWSLm4vf+Y6zMKaKDC3FZYBPOsBJB1knlSGLVz7Au8glMtcf8/0X40w/v+z9yZwdmZ1mfBzznvvrVtrKlVZKns6SXfSnV7obnoDGhtBAQHBFT8dFXAHUTYHQUFxmW90cBuXD5VPx2UQxgU/UeSTQZxBFFFZeqWTTnf2tVKp7e73PWd+5/yX81Y6SyepJNXd90B1kqp73/tu9Z7/ef7PYjOsXjs+cuDgAbSmWpCSOZDG+/v6MTY+BiHIF6MpnuoIBM3wvmdiQbK2v4LDjfMHfJ4+ytbg+zevxvduncDDp2p46wN7cbx1aRzJE60uNgUSLAyOdXozwVMuRsRL/5nOc7jY0XJp9RUYC3UYPNFM/dtWYbFiY8QIcDQHjrUWhY3+rB3BMEkMnML9GR7CtXotzg9BzpuFDIdyFavWb+0/cmAyy9tErnRdT0ISz1gFIfAyReicr+oGL1MPExK5kVEw3hLiJaMJ/FIHEXA4TsM3ojGBum+pgTlP684Lh9JL1gskmIAnOnHtIGMztVozSSSkkxpxE9hITagYQofxil2o0ZrCBJRWJ4n95MmlJZUxwpuw7D1CMll1dI2btCzvJQ8X7uE4JdcomsRW8MRbYZjJ8GTM8mIvVupezrSjJlWiEDPb1UsFpoF14g6CAgTB2iQxUhMrePWlo0baghoRgh1xnm5CNJQNrBeI2DwBObKCsKXUm1je5mx3H3XUYlRHTN1UuxaeG+F+LZXL0ZB+dn5258zs7J/Wa3U0oqyVdnDvvr2YmZtBt0PcqXMZNp5thPcE7klQuJ3Pc2Qpjb7MopWfeVL/zo0r8X2bVmHrcD/+/OBJ/OPJWfzjyTnMdfP4dbaxcaAPP3jNarx01TLcNh5cR3M8Z9kg7lo+hD87fBJ/dugk/m36wn22wrh7+QD2tnMMloA7hsr49NPmTF+e8ZTvNMl7KRqcoACRB4nZIsm8ltS4Zdkg6rlD2z0Z+vz6dePYX2+hG55q1QG4Zcsju/1ADqzMgDeMltCp13Go2UF5eASzlX644HuSexzvAi8dtPjZtQNYXzL451NPtiFeVs7wirVj2D3XPC+CsrqvjNdtWoXXb1qFz5ycjcXR1R4sZY57oS57pVJ82Ik0UEZQI4kjHxgqDu85n0dKIAmL3K4YAR7e0m4Fp8By5DiMj0/sbNYbr+vr7+vvqw74btdLK4OmeulqMBUzFdwMKojpZiG4xCykPIBz300sPIx0gCzrVZx0BCRdlyWqYquhAfP6uVp6cHqw+GJ5zazhtLoCyu9k4vUmcTS9FhC8n1Q0aEScHAeLiLwk6LPLSpwFdX88kRwkQI7cO7iIESiFHUetMmn4FItahLovnAgoDib6Y8eAUEr90QnfaJ3oyexNKD4SasNuqqySIXm1leqEJn1iK8ePZKxEMBf10dd0xCKROCFNcn0W3iBGTrlfcLWUskMcVskXkpuH7wi/cJPsIiP3mNyrFFjQajfQanXmjh6Z/Giz0VzA8g73/9zsXJS6BzXb2ZyxzzfEaTOgKxzrcFHbuVLjtevG8Zf37MBrJpbHK7Kv3kbTOdw+Oog/uH0b3rFjPTZUy2jnDi9aPYpvWTuOb1w7hu+/ZnV8du6vtzFVcLUN33vX9vX4rVuuwcvXr8Aya7G/1sRsJ8dkq40VlTJesnYcb9i4EmPlEr48W8N89/znaNNAH75382r8p+vX422bxrHSd/GqqsPPrh/CdQNVfPzYDPJnqRjkKSMjwQ8kmKMF+2ApSHBavPQzaQRY7qd3rMe7rluPXbUGPnzwJH537zEcarRjtfw7t27BS9evwD8emcI/n5zDHeMj+FS3iz9uAa8btvihYYedw4M4tfJ6/P2JGawYqOJTLY8/OAXc0mfxQ8vLeOWQxXBfCd84sQ2vXjuOX9x9GH9z9BSGShnefu1afPfGFbhm2SC+NDmL9zx8AH999NSCMzxcyvCilSP4mlWjeOXEKDYPDwClDK9asxxv/OLj+Nhpr382Dh8D3Byatdq13vuRCFvHpbuz4rctsfnKKXDUKjAczuIMe55xSgqvkHOd8RgnoY3ljtfbzrIhBYssFBFhjzWvHFSZkL2GyHqxJRWWQqKrFmKDA7HReQnCY3aC84WPDVMzISHGipKFKZgij+FCy1o2DHEJ04k/Mtq3EhEx12+OmzvRJz5TOTNBTJaAl2DXRWBHqEyccFi4r6H5PHxjGqmvEEix0fHEWZbbqgJa6DqWnN+csIzFfpWKNEfGLcl8BSJBJk96Ou2qpoKEF4azSA6sRnjCghMJHObZh95LD81r4ckUoJyAIWNcqs4CdVkAJ+rGRK2Ml4ScGD0geIsNJ45U3VK7gOVICMTWDLVafUO9VhsOQEZw8jxXsRDQjeB2eqGLxVCMnG6IthTH7922Fa/fMoFWu4sN4xXcN7EcX5qaw8OzdXztqlGsqJaxd7YeXHHinTc714iFZXh+9lmDn7hhI964ZQK/vPsI/uTgJJ43NoRfvHETJob6carexO5T8ygZo7yoEgxOdbqYnO7EZ/Vbtq/Dt29YgffvPoxfeewIRsoZ3rx1Aq9ZvwKfPT6D9z5yAMvLJbx3x3q8fPUoVg70odvJcbzZwveNWMR1Udfj5RPLUbZ7UbHZOdGaZ+q44AoimEwF+E4MWsKNHv4e/OyfTsjIWKWEd29fj08dn8YXZ2r45rXjeHC2jn+amsPLVy/H/71zI65fPoQjc4140w5Vy3h8to7PTc3h1tFBXL9sMN7gK6oVDJUz+E4X9U4Hu7sG28u0gDvU9RgsZZjoK8OFFb/L8eWWx0TJYF3Z4lDHoeFo/tkyWI1r71CMrKtWcPuKEcw1OzjRCsVPFaVyht/afRjvfnh/rK6/b/NqvGTlMuwY7o+/YVPNNk61u/EX7prBPpQzi1989BDe+dCZLYmvxAjW7+FeAUtuw/0RFC7B++B0K/9wX0nWBPi+Cg/D3bt3X+yqLN7bExMTke64fv3Ee/r6Kz8zMroc1eqg67RaVD/wYtiKUZjIcCmhRoaseKll41goaxn898zQUAxAQ3KZhcDKUe1xJDt0Lz7rBMewRyp0snNGAmhY0SFJ9S5PPAyeD71lJxJyGY3KHeET0Jah0mCjmfrFM+ZZzlqU50rxwaAEhwir9wdyuHj2xDNMkopdfGvOPBNFUpBmb6PkWAam5EQRauMlki4BNErmiUchbRVyPE3NmgK5hosXE/cvt8RB4cgcsXzRDzWp7GBCjTFpkWr0nNA9UEi3SR20RNc1jr1HxGzfcumWeD90TrTBpGax3lFQkc24PpF2W0bnsD5fw/Hjxw49eP8j92zYsOGA/N6cbUEYOFUBYQwGgs8kC4bQLgnIxT0Tozg4U0eLEftwiCv6SlhWynCk1UGtm7Nv4ZOH5/J9tFyKRcvheiuiHgFVCZwQexr6efqQ96/qK2OkXMK/Ts1jsGRxw/IhtDtdVDKLR2bqGChl2DRUxYlGG7OdLk5HVUOxcqDRws1/fz9etGIEP3nDBrzsMw+j8yxCSZ7R5I+AGrz/xs041urg74/PxB7f3noL37BmDL9y82ZsWj6EVr2Fg40Wtg4PYK7dxaPzDVw/3I+KNfG1chOHX+Jl4YatlKgqbndjtSzDc89rxAJzDuicJlUSJH15ZtB0HjW/8Ofhhi6FLIBqObaFTrQ6esOGn/WF4KL+Ch6ca0QIcWV/BbOtDk62u0WUPo4A84UCavXIAD7w6EH8yP170bkKbZurXIzEz37Zy16OL3/pi2i1a/991Zo13z62ctxXSmXfabctWYyKgwa36tlMy4tCJGaVpOW7lYaL58neOPW4EIUHa2G0uKHJ2JJ7eJhorBfJKr1fYmu9ZZ8TcOCJZdcKguipiNCKJ9JiRTpiUotGJ7hAdqRixEXPTyfhcQqJsC6m0CEg8oLIU1WCqq0KIHEiMp5M0+cKjwIaee+18cT+6RxcZ3TqlRxdmt+FAWIl2p/BDu/Fy0xu9nD8liJoJICOZUFG1cVclDhSRwvwJFTlVCsU6Khe1FVeTVmdHLRnGY+1WouqqsoLp8YjZjD6lM0j1BVRLemuiUG/F9IJtJAMnxuIqnGfHbnOEeHZotVpBpT61MmjJ2+776vu2zs9M31OA0XJEHnooYdihstSH+E598qJ5dg938S2oWpsOz88u7Dd9JM71uMntq9DNbN4LCAd5ykazjfkGToQeCfOx9b7hWxP3h/mh4B0TLU7WhiNVbL4vZnA4zlLUVQsRm4Y7sdDr74LDx+dxpu+9Dj+YXL2jO95po1nrJrmPTvW42du3AQEQpP3ePnaMfzw1tX40nQdL1m1LN4UuyZn0Z/ZWBU/Md+IBcj2oWosNgIRqlhshBurSHYqnb6oZL7fNM+bpz8W5NWncn/Gn1tDtMUDzPS2he2Hv7e9xxP1FtZXK2g4hz2zDQbun1xRhmObzx2q801827pxvPOhA+i4RcmQWBIjWOuHouZcSFwoZjZt3hQt+r/4hS9gdm5u/YaQYZNleVwcE0EyTvd5TFgJ59mls06QbrLoMsQwEBMzMYzXUFmT1BqyGo9C2lBsuKRgTabhjDKEPcgJH5HofaExGEYEcpbzSjxKDopCscIh5RhZA1GESFvCMZhijYAAbI0uRZPwP1X8SqktXD5QMiC60oNgZq7zWhHwlhjr4f0Xo1RmSYhlSMFEn5WrHESYc+dIJncnaJURkzdoQabohE9G+SJkyWK7KUFQch4cwyBSgJGxG/mXmIjsUGSwEIeEYWIpUIcJJpKJqF2rVFmwvCeTX0ZH3vUG0qqio06Xng4wY6eVPN1vklFDbGLy34u7ytgcAp/Ut3IsXzaS7diy3Rw/cVyTy8+GjITfhWDZfSnptFdqXBuKjxfeiNXD/Wg12uirlDDVaOHhuQb+5ug0vjxTw+s2rsS3bpnAybkGDtRbT3oWX8yQLdRzLT0vaMjrwyIVhed3+GO6Q8+psxUip4+wB/WZWixKPn3vTnxw7zG8+f69aJ6FnPtMGU/rYiTwKsIFemC2jpetGo1/P9Bs4fljI/iea1Zhst7CdKdLFMKwOiiX8IqJURxtdWKxEXghoQKe5QIjkFRPv5mWytBipiP7d+4dk45AKG7c0xjqE1QkkKfJxIyix6NXyFkQkxgnEx7Ac/P48If/BNNz01i5cqzSV63AZJnptp0pQvkiZaUwNA3IY5ml5MxRki+ImpmYhuL+GSdyRkG41ExCWrCsgskPjpfx4uAppY34lOjsE90/U/HCPmHUPjI+T9IM5YkSN0TRjYXuYLrqJ8KHF+1HcbUuUETh+LV7wRNe5sQzxLALWDIgjQ0RUyi+uOVDXrA26lMzVumwk8YCVUr4I+PGDfuMsMyJeSFybhV1SqzjaE8nKJIYnkbPfAelw8bzzzWNLUAyHE4UR86yWkZTuJqEGNclkjH3V/h4yOXMwHYJ5HJSwInSzrIKWORCVsMDNScwFrBOL5Ros9I9goCgljA8OJitXDN+879+4d+emDw+GZ1ZzzbEhXipj7dduwZv3bomtjx2T82hGtRxjXZEK+4YHcILVoygk7uI/O6ZmqOw0WegstPwQmBvrYmJagXfum4cb39w/zmLkeJd+XQdS74YuXd8OEq2PjM5F3uCYWzo78Pv374VL16/Amh3UO/kGCgXDsU57J1vxps204e0wXw3j19YgsVGbywcodAIBcXGjRtj4RESSSWISZQzZ1sJSl5S+PPYiWN4zt3PwWCplHVbHWSD1nTzrrYVpHtFQTW8MtYahZQiXqd8mdgJ1GdfDEUt5DVe80UodyQxVVObxIv8ghNdVE7hCOLPWeVZ4HYmu3OyN0exaSMrZ0tZ/S4szi3Lgh1RItmfXiZ4NgFhNiU5qwuSocSH+F7H87ZVnofUPi76vbnopOISCdg48QZJdYbIjqn+CM0wESgpxO0LXinhjXlK4k36FtEhC1bAaFUsQ8Te3SXuiROUQ6L8PZ9jbsaJElij84pS2gJSz6UI769h9rBRbxbZ8YzpIc4LviI4WrpXqXZRdRJ7wohVnpfqVS3y+eX0OQ6oVKu+2aoPnJw89jLA/x2ARmzRnG3RsUQXI0EBExaAe2pNvHv7Orx26xrMzzexe66hC8VwzwX+xuEmcxQDlhW//8x/fodjjQvsRuu8C8rw2m9aN4a/OzYT0ftAUdg5MoDf33ccM52nB5dzSRcjgX38vhs3wed5bK98+sQMDjXb+J5NqyJB6LGTs/EilI2JvJDTR6/gWJyxtlqJbPNACvuxB/ZdMaZ3eMAGpUCYcELxUfS4OVchEgjVN910k12zZq2bm5/HSN/gRsANO5LFxEC2Ao9SRLbixwG2f/AqvPAsL9XnQU7AhklxIsKxkEJEphgwiuLE5ZX9IChvBlCDD58aDxDWosuo5ODJjsPikHxirQhWmVBJxUMODg7W8D6rXBYJyqc2gBcTNwYNmGDJ0InTosoUsDbHYIIJrm0phaVQFfFETLb3JhUTkhKcG8I8TEzXFQZHCp1zRJzgbJ2E+LD2hjgsobdms0j6lcnecD5uIPLGHBzpLeURbpGMfkacCIFSpZCqf5EQHS0GbQGZYlULF5qOmzeJP+tEtBPfLX0sqDs9U3LZqh5cpGoekUnFYCLY2kiIFbjLWpNnpVJpdmb+lk6rE0hZjbybnxEpFF7QUhvfsm4cH/6qG4EGEe/7M4PHp+biXpbPAfs+W2Wv5xuhcHvzlgn82k3X4Il6E88dHURpqB/fsX4FvvnzuyIHsb7E2zxLshgJ3I0/fu61+JZNq3C81kS9m2PbYB9uXb42/jJOtzrYNV3Tm/bZxDi+GmPncD9+4rYtMTH+xSuX4WWffSSuZi7X4HToqACQsL0LGQE5aTQa/q677kLe7WJ2evae/sHq2uB54oPdmUHZFtNX1Abey5wTK9koC/amsCxPHYXMFletjrbmOSTPCKdB3iRwQiIrikO8NQnGFyv1wF+wqTdCK3vOGHYMs8j7IRbtGaEaql4BqTcU9idtimGLclifEb8k2Ho6o2peIZtKlcXxdeIlIo71kBnceOJqSDNB8QApRKSYkoxkLj6sy/hjEtlXtkcnmI7RyXlTZIJRpYwLMU+8FpE+OSaeGltQDDOsZAzzXSx3QISgS2F43EqS9pqE1kH5PUQ2ZoRMvGv9gg/Rid+I5QEkFdrH4iuWqFIoxoKsAM3ZQhFkWH0jLR4vQqmY8OpCrMHk/OTWWr0+gHMkpy5V9UzgQ6Cbx1ZEeN5Pd/TO642LHHvqLTx/7XhU8wRvq069Fc/zZ+7dGe+h/7TrEH77CUqRD8+d20aHohjib5aIBcSSKUbuGRvG1qEq9sw38cs3bcLdK5dh30yNoToTuRzC58B5quclMCoA+vlPWVIGOCEcQKCFX7gf8VUcoaJuzNZxrNnBloE+fPnFN+Nb/mUX/vbY4hHihIAXWjOBmFqv1+MD9kLl4uHhOzAwEN7vP/nJT8bCZNWalTf7rh/JggGa2psJAiH5aoYsKjz5pHonlAKZCBNLRJsHQVGR+JNxaMS/eF+BuCZReurYaNVa41lm6pkpqTJSL96uVIYYsSQJyICoSdQ8i7P7ky6D/quFlbQ0yJRMCwVLs7bE+DpTLHCcTNBCc9CiS5ANaWhYibk1RvkmdN4ySrploqdb0KpQo3pnjCNvL1PoQ2g2cVKVmOI+cJ1IKhPpXnlWHjHGoJQOJrxwYRP5rUwlDfVHRsxTvaLC3xDHVcugEG3fUCtoQVMp3T8L9zC0riwsFwieicpQurNhPEzNzqDWceG8GqL9iD2+46ISLJmGoSC9Tqs1Yk1IEFIvuKfNiKTOnIpYMWhcQk/0sCvVYOrKc6T8WoeHUYuf4UtOERB/q1qdiIKAOwNHmp3oexLUlR94zjV43thwlDo/Z3QQt4wMYKBaxm/sOow3f/mJq737S6cYedXEcrzrjm2YOzkXSUmPzdQ45XTJFR0rg5EegO2hgxEcg4OdBYDRwLMMFiaFG7lcEM5IMRJu5gArBL3WZIgoCDxTAAf5z3BXPB64qlf5OJ80QkssICLB9O3jz7seb39gL375scWRCoqrb/gzSH/Dn8GV9UJXdkEOHIqRO+64w9x///1+165dqM/PbR0aGECWlXze9eLKRQA9MwpjZ0Cb+VBeh7VFEqfXZBKdglQnIUhBIduEJ1ldaVPkntHJo9D90EmJk26igsMJq1LgFNqwuJKTw6rVTByxqxfugZewvNSPiiNySdT7lFgmnusMcS7xamGSEvk0pt9q44lbET4hBDq8xPxqeJ/jk0LACUtyLBWQVj7HiQ+tjxwXKstyGJNRmy62lrihlJzvWcHktIHnxYgV0mbjEywIgjFsp2YkZIiPjwobBzGLE8QDOuEbbqV4sVUzwoN1CbGCY8Kz1aYdhNQM3jFrdZ8SJdaKd01U2WibUM5TCDJx3XI3b2OgOmC++kUv6r//gQdx+PDhC/o9eZaP8NzeDGAbP7uvCaar/BWe38P8/K4UihHwM7zDz+/gwT/Fz+8ZfnaHh+Fefn7vAfBkW+0rOKTGDzzJWZYVf9fGFfGbtU4ebSHC1w9fvwGbB/rwTf/y6Bmdxq/UWDLFSFC4oNaKypZQKT9VGdRlHKHYuA3A9XyTTvDf1wU5+mX+7NA8fRTArnBq+OvLAP4dwMmreVJCoRgs8McrZfzSrVvjTfyeRw6ckSR1Ibd1QDCOHTsW+R4BDRGE5EKGFC4jIyN2enraB55JZrPQqlkZoflSluftjhVD9TSbCZzBrQInS2PFCcQqYiGMX3irV4iBkQzZvkyIOft58EQmM7H4qWqOStKHJPIn8yRIMCoTmhWuKO+W04wco1s0yVdDhS1C0E0tpDRNLthjJYyaQniNtTLxG0YYPMRFLPmAON1P+SwpdkpQpIkC5ArdBc8GgFKQaLKufI4Xmq7eXsYWt89JMxSwp+wiUAqR6LSNtk6KZ0u8ViwRc8hkjSsdzeZRe3g5bWLwRic3F5+RQhGEVB6xN1r4v1SgxXRjciHI2ATP83FDFEO+cA1D3e5io9Gs37xm4vF9TwCHE29J78tQAD7D5aDnGWGh+Fx+bk/wc3xnUBDzQvFSx5ZzvH+KC5TwDD9eeIZ/kReeV3RIKMUTtdaCjw3fe/zkHF65Zgz/ct9NeN8jB/F4rRnn34CiTHY6+MjBKzPlLJli5BS3YNpFCvuVHeGGvQ/A8wDcCeC6q3QqwJX5c/mrOEIi098DCAz6kKv00Lk2Em6ooECav0TC6X7W8st1CX8/1e7E7b752rWRRxIIxD/4pcexaz5xSQ53HEZg0Ge8YppnI9SF74c8DWnXXKybb0BG6vW6GxoaMoFvcsdddyIzvtxuh9W1zcj6Q2ACCXjN6F9id5ZmZxJiqHsoTSPO+RSla6WAcKrN5SNUDwwVoNqEX1Bh4TghXgB7/uD0C+DZHFzVntL44M93bA1bmNWY1UGIRMp3AWt1ol2KTOdcgFCGCoMqjjksHGgnx6eJdoyFFJipbO7lyRdFKLJpCrWO2CsibRaOjGcVj5VoQMsHkUt6Mlc6PrMRW7BeUI9YeXgJzY1ebawGsszB8Wzgz9RfOWTD8mwxEzPUizG5wFKx+ZJDuKTFHlEqjvR3gVJ7KAvQsFI3/aI47bAZKZSi44tntZEjBnEweCdH25RnrFoqn1ApK70wa11WrgTBcmVmZvaW+bnaJzKb+TVr1yB39HtTKVeiBXzwF1mKYyo87xd/wRlO2r3B75K/7r2K3Z8x/rrltO/nXJR8HsBnAPxjeMSGZ3WXb9IjzbYq16LHlPNP6RkehQUXSF8QvtbuuTp2DPXjI3dei1qXlmCj/RWgnGHbF/bgF/G8WAAAIABJREFU5x89dEHbvZixZIqRO8eGYtz7FRwBgvtqAC/mIuT0iX8pjsHQ0eIv8E39SQB/xTf2glHPc6zr74uW8V+Zu/DArKCi2TDQh5evWoZa0PcXfmb5l2fPbB3r+iu4YXQIn33hjXjHg/uiF8qLxofRHhjGT021sKKvHHe8Fnxcmh2YUhmrxschFmNBNRMCuRaDbBeKmFCQRGTbWoyvWj5Wm6v1m+g343VSEHRe1rnGKICONEU7xgQy/q4zLhUx2srQVWzGq1pnZUMkymHCI4lgHbVJjF9AMzCa+CtlT0RmhB1BRFPZR2d1zorUFN13+XzZbGxWkEAyfiu3RV+LdBpoBW6lwhIZqRWkR1bdLCeWX1MibRR7Q4oLsHSFc3fJY8XY5GZKfiSKNxRPJFN6LJM4nIiJNOVXsnZJ9cS5wZGgIqiCkknZV56103It2GbGZMn91XCRRSQcK+eGk40TUhNf4TjCzuRsoBpTcqJpnrSi2G7WiiU8f76RlpeRq0cOuZytI4nDQlISBY1V9IsN8m25XEKlUsbc9Mzd7VZzxZo1a05MTExoTEd/tT+ijUu1GLlrcZ/33wDgZfy1cbE2eplGxoh7+PpBvuv/oZ7nnxotlz6xfaj/328c6Y+OrXlcnLv4/AxE0zMpRmXcPTaMG4cHMN++cCqL4QVmkE+XoncL7dTJmXo0Bf25W7fEAuVX91xe994lQcgIOTA/ft26yKy+Ah2rVwN4JYBXAFhz+T/uio1/AvAnAD4akvXBMrixCqGRgaD0oYOTZ92XYLt8w/BAtMIPLrTha021gtXVcrxBD9TbScZ6hhEKk5DpMFyyREQt2QBT4NePNfDzswY+72IMDtsqFvty4JCz2Fgmd9EoR12kXCPhntxww07c/+UvY92mVS/OHX6/UunbMD6+3DWabWtcwgsMu2/KhGdZEeN0TRqmw4yzzBxYReskW8+IQkTlnYaz5mRy9ar6MDL5OypLDMRRlX6a8cTnxCfDJK90o0yTcC61S2I4Bz/GxhlR43gPybwhzim3LzJR53oO7CfapCMr2OS14bgCSt2EOPmKywZRbJIkVrcPXsz71PIhuS29k8+ypO1pn8OxMXw8C5Txp9bw1hNOQTvLJ9WpZiUa+sv+SVHB8meIwln9xAR9khRi6/m1omDi4F4aLEgKcQCRMGqMMGYdpO7iCB3LiJ5PviOeej1ZvCeZOyNqGe89U18iUzVnJMTyfRK9XSw5xgaRkOPcGjp2h1Ipc95YN3vqZKk+P7N/z2MHvvbW2+54dH5+LrqshhZnKMTD7u3avUsjFpbK+PVbromx/AfrrUt53t8E4NsAfCOAHUvqAC9ihGd1mPgzYx4oG/N3s938ox74bNhScAif6Xbxrgf34yOHqGUSLPNvHx2KfiJBxhv+HoipgQOymOIOJzEoAxW84jMP4+OLKFo4fVz1YuSv7tmBV21ciYPTtdhSuEyE1TsAfCsjCtsvxwcsoRFK4z8H8AcA/jYUCcHFb7ivjF959CDe/uC+qAkIZnJ3LB+Kxcd1Q9UY1BdeF5QHYSYIBKdGUNHkLhYa/incLL5gkx+ycCoWWFey+Gwjx1TusaFksLViMZl7fMeRDnbnBpv7MiwmZ0oMzwJX5KGHH8KOG7b9bLVafffA0IgdGBzqdDtta8gOnry6vcg1o2aSKQ8561g4J45muYB30JRDExQTVp3wS3jCpvPnaKXrKeteua60RlcOJZKZUdyElTAYlcmC+R6WJR2GsA5q21hW/OjMz2oPOSaREpOAiOEJwvyDpZiQLb0oeNTLxGszyTtezEdkwxouZhLVQ6TF7IfBaTVRa2OKPBQv0btiWMspOlKrcfFgMyKsRg6G5PdIz4vOfpRcRzzFGuXciEyFvErcAiMyhmxcLPf4VHgOgfEJp6C0mahwdka7Uk4d3khnFUgluRfWCO0+t+ZYksQFTQCwCBOxjtm0VlMEBBBi4qugbZYwFg+1tCN7kZiqLGk/QVbubZblc7Va6fihg43H9+y7+9rtO+7vr1Zjq1MyagLaGPJoZmeXRrZJCAz90J3X4kVrx7F/uobOhT/vgzDgtQBeD+CrLt+eXp0R7oLBzEarCqYrfM4Df547/6cbBvr2VTOD9+8+gqo1ePWasYhah1uu2eniRKsb33c5Zs/w/F/dV0H4/O/+9z0xDTkYkYb2/bnQmgsdV60YCS2Aj969HXeuGMYTs42nNNld4AjKlv8LwHcEVPDyH9GSHF8KwJPz/n/EoL3BPvzvEzOoWIvbRgdRKcVEr1h4hH5jcPtzi3gdZDJdlQEVY1D3wLzzWF+y2Nf1eNWemSg9GyqdOeDrYkZ4EAeURfrlN+zc/lcrV6x61dCyEW9LWTckJ3uYkgTYC1IhMXPctIh6UEEvaBXsZSXOPNCMJbMRyzfsqxoIkDRpcVa/zIO+KFCR6of/yQURAfI2zdZCIJBpTxc8hjN9E9IAsVFV8Q4kZA+kn/G8lmd4okjDhM6tmhDHjm7cYojreDAdwhPPNOEoSCxUbjXEOdqaZLfO7BQbdTCECrCYh/4jTi8RrXDszW998XRFpQpb6pvk7EqdHgMn1ihRsEwkDm+LMhgpBV3iH0vfS4IAua+UCLZCRFV6sLELroRT0ZA4uUR2SPyG5aZM8FTxwj9N/FI59daQSpvLpWjOFjbkOKWZkSjmFFFBmxlXzipuZm6mPD012d28ccttDz708APHjh2N7RkpAbPMxt+BmemZRfv9utgREnY/evd12DwyiMem5y802C7YJHwvgB9nJcyzbQSw8q9L1v7RpoG+gHx3T3Aa8WI+r881uoyQhCTkYPWwfKQfP/7ve/ALuxaPS3JVOCP3jo/ECnn9UBWPTdcuOXGxMMoM3d3Lfw4vzmaftuM5AD5ijfmJtvd/u2eu+aHnjg7dH27go80Our79pPO+mDe2bOuEJIHxeKLjcU01w7XdBh44MY1uIEot0gjFSGjVSK98fn5ufM3EBMqlrOuMs7n3SsO0wjm1xVnay5LVUbgu5/dDIXyijBL5lNLQGFJPybJqdapLe8uUhDjZWaZtsA+81w6DaFDFopTBFKP2pLJkhmH4w7EkI5JBEueGnba85TmXCSkCk8Q/wvKfQu3VXFV7LvFfkdtJzAzGBpzWLEYgAy5NCk2cZFPqCdCJNYYUWU4IHGRFEg9VOhjCo/ESUeeNIhsmcVgirtWNnvM2SoStBNMxlCWyXvEh0SIg50oxE3qO9ZKSLNoVChaMNrJWBdRsVcJ1FrdbNP1fWUFG+jdCWGHHFyqgiNIibSVhCXkWHccCSYjBrMXyxFkpqIfFn9Xk4f4LF6hiS+MT4+vcg/kD06em0RpIaonwypDnVK6Ur2o2zTuuXYufvX5DRE13nZq/kDbC13Jb/RueYS31Cx0Bs3uV8/5VT9Sa+xj5DlzBT1wpNKHEcSrNGCALLO+6RU+Cv+LFyMtXj+Ljz78hThi7TtUWq78V5LbfB+ANIbpmMTb4DBs3m/Bl8M5jrc4fBjO+IB2+WrBYOWjfc49jAe62luD2RbivRalT6atgYGAQ3U5I/aww8S9OMurBrXO96DJTr4PKgrA0zaUwcMWOA2tHgxgmfqwuWgmBp0+KjlU5uZiHR4llRMGzbCVOMDnPTUa4KcIXYZACItSQkBfLaAIXFd6o1NSkaBLiXzonbm5aiRDFk0EZpXhIq0MxXlNooSjbRVUs3nDh4ZkvKlPmAnIG64+4wsh8+meYr7NYV1jDYiIjUhuO6DdM3mF30hSFA7JaIxtSb0M3J+JNmRMDuWRBl7g2gXWhUEbEVrjzw74yTg1v+bQWo2S8F5MJMXZRoXMsIKwRQXWKF4J0ZeRWU2pPAQ0Du8EqOZjt3zkVUNCdIt1YRD0hjNmbri2XSkGJg+NHDt7VbjY+mWVZntmFKKNzefwd6Ha6V8WN9Tefcw3eeP1GnJytRQXNU3zeB2HBuwC85PLv4dNuBI+rt/FXsHr4HQD/7UoYaRrmtsQupXOLbs1/RYuRt2xbg1+5aTPmO90oX1qEQiRIp34awA+wOqY3zj++i7/+I4D/cjXOV4D8hqzBLcsG8dm5Lgb7SotiZyhpvRMTE+bw4SP+5ptuqrSa8+Vmu4llmQW63chTBHMwIsUCUoeQEJQbBoYnUVGOOE6pkZa/tlk4my01dCzUJiwqhsXNW9oe7GJqIbH0NqW5pBR4n8L3UxvFB/KBhYI13ircZMSvTc6D+pkns65CDA27DtDLaTleCPdNUJDEtBBnIc6SOXFWWCHLnQ+T+g5CMo3sTCdJdEENbZkYQ0duiPhJpmYO4sLCBA+jWlfGH7wXlU4szKwlu3RGOARqcFx3WfVGIesQu4Cowsk0sZJgIbacIgh9w4hLKkcUadtK6hwm2Bi9RDbJqrmdIx0+2feCRljaaRySxHWL5QvqGL2yRbt5uRHEnA2mVKogaNVbjdY93by72nt/+Em28OHSZTbGKgSV2ZUaYXf/v7u341UbVmLf1GycwJ5Cwm4wlPwpAG+6Yjv69B63A/htAO8B8BsAfuHpfDRXrBh5z/b1+Jlbr8HUXBMn251LjX4OfJAfBfDD7HzaGxc+fhHA9/AK5KNX8vyFx+VUN8e714/gM6YfR3JgfcngUoV+3W43wtK33nqrbzQaqAxU1rRyO+hbQiuFNVrNW5oj2UpEZisJDjGx54/oaR6kuqYwcTP2rlRQJFmoTpnEGQiwRM5tf4p9S4JiUg5rOp4jLR8RTU00xnKSXa9VgaeeSQI1COlwXibFuOEs2mpk0YbEykQphlmxzGJ7FeF1goy4JJrGZMney3N2jQT70pQcxKgS9O+EViHqGcoUtoWixzuTfM8dSGFiGShxRso3AgTizEzG5zzlx31jtzajdifcbZIiRlAuw9RjxHadAE8sr3VQ93m1gfGJX0M2bIrEpPqlUKlJHiHZ0JLUO2FOxHZhti450HsmzHpq1MQsn3A0mVw4pKKR+3Ts3AphqygyJXUlsaZtKUNWylCrN3d2Ovm4c+5wo3F5lTPvvm4dVvdX8IVT8/jKfAOTrS72N1oLIPtrBvrwsXt2YOfoIJ6YqT1VPuDbQzZq8Cy8rAfwzBzrAfxnJvb+KoAPPB2P8ooUIz+xfR1+5pbNODJdj94Xl1CIjDI89ZYeH2RRRlAW/QWAvwzPGQCPXIkPDVf/ZNfj2j6D966s4NuP5Rg3wKDBJRUkYfUXOCPtdieuAqemj98JE4jg1bBhmwtSTvTPOO3LWrOQXUeQBcenwPuCrJbZGfweiNhUDcAKfEPjYsaIc15cQWkmclzvGKLLC7PAGmGsCLkiql0kpEaX47RUh86KQliQVgFrMxLFky3cIyIjVqLMiEzUS2XSKjtEg/GERhJdM0JfwlJR4FNV5Om0CIgRW1PW55I0w10GodEIrlD8XFn4U5+FlSyCKnhpnMlfmHZh0ndoM0I/JVgll4h/r94pzC62XlJ4CPnyItmBkkYdGa8SEmS4CSepwZn6s3C7R86p1F4+/dywaTy3dvgwweQfxAQf+rEzTKNhpbL61cm5YVyLO1qW0m9K5Yqdn51dOT9fq0JQk8s0fv/2rXjdljV01LlDvZNjOqLcHTxRb+FfpuajBDVwRK4bGcBjs/Wnwgd8Ga/ob75sO/7sGeF5/v9wYfd+Rk2eNuOyFyNv37YmmqZIIXIJ0t138Cp+bHH3sDcAvIa/Atz3c1fihAQS1N62xzf3A/uXOfz8yS5sZi7UQHDBCEVDMHr6/Of/BUePHcWKVcMvLJX7xvv6KkzKyF0MnJPFs0nWHDRXekmGiw19WuKKXJTbB0ljoTgHCmxT5azGH+UF5SgtpK1NdiNF4ioblzo2edW2hwAKxF0Rf08fKxv2M+FlM2tsLfcX2FudOjpOPDFIvqr9H8fmXRyMRxVGKn0ilkTWXGDKaWRy0v6FzzBsdkI1kOFkfGfSWp/6IVwPkJCF6R1qXcpHxMfnIFxcTfIF0WkNG5exKhdK9NFKRkpL/rcla/+EurDdK3eGlJZhnBJSjZidIUFdnFJDB2O5+GKvFfB9xwUFF3yG3WW9GnFz3iLRVI2X2o0bW6yfZhc3RphYJJ26byjUbYbkPd1qtVo5NX2iDz7nKkTqyTOPiylWlpUzfOiO6/B1G1di/6l5leSGRWVI3A3WALcvH8Q3rx+Pnx9T1WfqT6UN/wfcMu6NxR3bGB35UW57/enT4fxe1mLkjVtW4/03b8bkbONiC5GM+4dBonv35dnL3iiMnwXwQgC/HJjal/vEBP7hqdzjDSMZPlw3OOosVmQXv73QLw8eIxs3bsLk5KQ5ceTEzo3XbEa5v0LzNukjLLtVyExCk4+nbDqTOh7RSEyMy2nOi44RXCJI68N74X5QtpsgKEadW3kacUJWIUmEFf5CCrRVUkNKUFGOCpM/rUAWsupXegmXRVzDFMPkLM+v0VMM6siaeK02ITyaCsydD2mNeMvNHq7k6ORlqaWRSgr1cjViBZuy/mhuB7uMSaZvQaUslueEGhiFBFIoTqwOlVnjNdCGK6ZCW8WoQieFEJD8iD+VJVAMknGzxxUqQO49RTf6qAV31gt2Y4lyawp8Ia/OLVToiuaIqESeXPE5p9kIc4QpL+m9EmUjqTgUQSCmeYZxqZghHMr34Nid4YX33TP2lYcew6HDx1Ct9p3x90OCKD2bs4QTEFqbzWbrjK8P4zVrxvD+mzZh63A/9pycjduQ0x+4X93cR6nn5GnOn+cpRALH782cE9Mbl2+EiJP/Eeg7bIj5kaV8rhfP4OG0ETgiv3nndTjR7ER78IsoREIBshvAr/UKkSs6viaYpQH4vcvNxwk337QDRjODF1Y8DjQ7PPX7i/oKD9rwtXLlCoyNLc/ma/WxUqkccjq69LS3HppL431Ktw/ECCjazjCEqF5j/FmyrJA3CW6ecnhpeJbrMhMyUkci6dP6lJNHuILg7jKfWS8iWYFV6Dxxsl5I5gcv8CMLI83JyWzUS6uI1+acsKO/fk45kV5ZrBJpyzH38eOdHJ9unlfsTk1GRW1qqEhilatJtAbOq+FVPhujEnVVL7OA+EzqSbRPJrOArWZJaqIdi+SbL90fmv+tN9rhcZ6bJNSjMSyYpmrOiHZGrN7lyA2pXHyqe7J0eqPdiZqgSWPNaPIh3xJ0EqhRx2BQeE+mJvyy94qNCD2WjoVEwqLAgVBc6buhAWgj2wl53P9yqYLl4yvv7BsYsAHGK5XLZ/zKSqWoNOur9vNXHwaHBlEqn3lNGp7hH713J9ZVK9g9UxeT20sZwWrgf/OqvVeIXLkR5NEfBvCppTyXXhZk5L071uN9N180R+R6Xpm/7HLsW2885fF6ts1/K4D/frlOW3j2TnuDd4yV8Jf7DuBL+xsYH6xctNS31Wrj8OFDuOee25YdOXKs3Gi3MRIYDHlIkXKSB5IZ1mow2B+91A2bY3iV6XrtBniveSIyFVtpnxQnR2p8yOpfyCTWKE7vLRt0egXgyc/DSGeCU/ZVXxObF8TUYF9UkuIqWULW8KEsCP7jQXPjcxfZKbFJYJLLLPNvpY8AI3GeXF/xdxlJ0BaTl1A77h3J/rETmhAvOGWWW02Od84uuJbWsBokWa9yN8sq48OrxpZLDK4CfJiDrbrJGy+qlJQWKGgIwx1kTUIsHsO8EUjQXpF1Q57whDoFUkkxEcCJpChWV4a6Y87LZYbWt1aYKNyGc+naQC4y10T8CitNPY8k3TaOycTRx9fkXPsILYctb0K7x5UqJWdtZidPnPzq2nz9D/M83/+U7d89KW2CHPh0NdtP7ViPn755M47O1aO5VunSlY8/zS2D3rh6I0im/xnAbwF4Z7BhWkrX4oKLkddvWolXTozhWPPMsubg0vba9eM4cnGtme/kPuIl3/m9sSgjSO3+mE2HvptTgxd1hAt9vONw3WAFf3ztCtzzT7twstNEX+ni+jWhGOl2O+jrG1jbPzjY3+4El0KXiejWRY8zlnqatPAMK+ecF9kZL2cLEgeVlbLLpzb8JSAuvN/xNG5UVOKiwXeudhJWo2aEiRnnOoEYIp9SpnBNnhd7cOMLvxfkFMvtoRyczMaUA9pzSxN4JqqTQI40TsJxicfLE6iUNqyBARMjlN5LMy4pX6AR/2keNjxX5txHSKeV84yp2vMwuZEmDluA8OuNbF/EJEZoGkayZsgujtAPbr/wBC90XTZgSypmr5eHSBbKFWLvOBHoUOnl4CU3mHjGEDBCNC7SgBOJMcuLwgHk0mvhyrEAunjy7ufr4hSPkQxE9jsJVyhjZCReCwkxFOSHMTdKbIg8lsyE2IPgod9sNna2Ws1VeTff3+heeChmGIH/UbU2FiJv27H+Yp/hp4/tvCp/zqVspDcWdbyRo1FC9+GzS+XUXlAx8tJVo/i9O7fTb+vZIo2dx956KxqiXMBNHIzKfp3hpN5YeuOb+GHyBoZZF3UEE7Q9tTbuXjOGH9y2Bh/YdRBZfx8uBh6p+HKEok/NztzcbneXBy8G53PrIklQaJtJgGISpYNnIDYBKySsET1VtRG6EvaiKmWXCemTiIlp7NHDaNYMVStehDiMPzBBkmw6hTqBxBvg9oXwKqxXmoUWNMJtCIAPy3yNEgySPslJH0pyUYT3khoe7M8hny37w/k7js+TBN/5AhIhsfwas88QkbM8OUefJD4MNnvRQo+N671KTXgIdMLnRy3wRfhqkAKKC3EvPLnLOUzm90q2TeIjIXUWHlWx7QRpxEhDSngoHCwoby8cg+yv1FHqwSqM4YJ3N10/4R3xNVJVlpHc4wTdCacHYloDjxD1Xsp8uVJCvd5Y4ZyvXuzv5bbBKj7x/OujRDekfO+fa1xMdszpI1gH/CaAM5NYeuNqjjDn/iNbPLxzKVyJp8wZecXEcnziBddjttHG7lPzeGK+eeYvTmK8gJs4OKd+pVeILPmxFcD/AvBLl2NHw+0S7q2f3LIKy/ur4eFKE1Mg3F3AV+CM5HnX1OZr93hgtNJXVi8qy0G0RhEM1b+IdkK6EkW5KxcuHCvvZMXNk6k4i2SObS6woHBh0QiESaozFa+wLRcpvjDpyYSlJQ45oMft20iSZetXNTblqUttzf1CcNHxvlgg040bjeJnyUj8NBIu5yTjFXdXhkHonFn9vhPXe/YEg+IKKMy6fLiOfdDkJ744uRZgluImIBb4dsFEL4wfLVqYRZuJKbxIeXV+F3QEXCQ5cZcjExDhz7IVropqjdZrqVAquKYmgouRWpKKBicqGDnXbCxvAXHdS34xeha0CGWHFQizWM1+C7hY+MycOMWmZEvIu7l93vOeV163dt1F/f793A0bsHVsGGuqZTxea0Zy6iUUIiHG/2MAPtgrRJb8COaXDwO472rv6FmRkReuGMFr1o5hqtVBf5bhh65ZjflOjmOt9qUalulHsFS3xw15eo23MZfkNxjNWpQR7qijrU70J/itmzfhO/91N1rtLkrZme+1M4EmLFFFo9aonDo5dfv4qpWRpAdpystklKS5hTencFY1OxHUgR09JU7mdDKElUA5IK2QkSY0o00efomz/GF5MvpmLoov1EHFVbGuv5kaYfXTFEshfZJJeyDnqIg1QNtMJv2M4+9l7i8oYBNSwYgIUURcjP3PLetpFD0B0g7Id5xyY0VUwxBLEVZI/utIqAUTUfmValfC1Z6G7cJ66b64dPIKVyMdumMbMd6m8aohTphLOicpz6dw/1jOKGL/fUHDwOdI7q1cthNbZWKVS5/lGEGSG80bztWR9D8N0+FYYUa6ZBdijB6FR2ehNRdaNT7PsWbNilWrVq/AiRPHUa6cyZCaPXMY2Wqxpfd7N6+IrfV9U3OXGrw2wmF2QVI6cPGb6Y0rPAJP89MA/l8APwNg/9W4AGctRl6ychneevs2YIZoAkcabUy2L8mwrDhCr+pDi7Gh3rgq4zoA/5XDCEOk98HF2ImyMZhqtPDVY0MY7e/DZK2FzJ69k3i6Z4Jj9mi12m+azeZYlpVQLld813W1eaAQukwPkphG/1J4X2L01ROd3+114vTSDOEP51ewFManpbhMIDyxpPk69hgssSx9UvkI71VTanwJ1O7IBct0rEphb3VbgAGsBPZ57UoICSMpYAmxoRaHoARUZLFlK2f78xStIJHqhlm3ayNnVvEl9QZxECwnnfDEI4E2jyyRX6XBYkTbHD1U4gdYRie0AOQqS9gx2hISzbPX68T/pGaZBNKob4cUWYzWeFcojAR2YdJmIWmnAIq4hJJYuacMW5mlOssIv8PxqTCpKcOsXbWJEVqKL9xp8VUh0TEykwF1N5HLB2/LfeW4j0dPHLu71W5+NCuX2gMD/Qt/VxitDt65IdU6jFrL45UTo3jvzg04OnfJaMgLWUa6+mI30BtXfYS22jcz0fULV3pnzvqkPxl047P12HrRFy9OIRKkuj+yGBvqjas+ngfgAb6J/2IxdqaeeyyrZNhaKWGy1jhjnkZ48A4ODka31WJB0u50MNDfj7vvvmv45MljttPtRPGMz8FRJ+xaZtjkQyZmEoMUJjcaRWNSL5rN6NQuqldur+jKujhdJQcOz6gH0TRowpJShniXCc6I5hfUObBESuWJ2EntIziF0UKJbd1Ty4P/zyrlAoxExu9s8sl7WZwAdd43IkIlHqsE4tC/HBl9WGsKuStcaRlxMfVh+vQR+1HhDxNWizUcfCHhj4s2TRYu0DY4J8YIo8ZIeyi2SIz6oQQQQsjAqeyzoowycadJUcVJywKJOUXNyPi2UOgKwzik+4WgMGmzibmZS5xeLKzfSCasHJGCFQrvWzpyo+2ZmAktql9u1yjhhl5PIqGMIn8q5WooujEzO/s1c7Xa7+Z5/nCz/WTvkPD7UpuvxdA8Gcva1eim2rg0fsi7OHyzN57+YxkH8H0vIyVXbFw2n5GzjL/qFSLPuDHKkdYfXAxoNjyO+6xFVXxIz+A5Enh2F9/MAAAgAElEQVQh3bwbl82SVSJfIatjcLh/e7laGYrwtZdYMbLodHHut77ImZC2gCeBCc8PEksvXA+y8Er8SqPNEcPr1fg/jonX9ypBgqXCqsgotAN0eM+SUZ6rTOKnEDWWJTUZt1FSW8Jw6IzzGpfDK/GEuwvg4SV8jl9V6DAlczgQWhMFu9br+x0pXFUHbKVusGRhIvrjRIGljTtqK7gIX3EbSJkyfD6cVGk888t+8HGIR5xPM/2T9997LQCKhx5f46xLHA9jUgGhGJd4xEKJyXFYrmTVG4bJyB6FcsGTt4sSij2EypxxIKBz0PsrSmgEzXLFi0I8HMPXX/gxsufMF6ZddyaUI9HLZmBwAPVa/fq52bmVebeLbociETrtTvy7y3M0G40FhUgYTTphF+t8fAOAz/QKkWfk+CDLsa/YuFJBeYbJj/c+e67ls24EdOSl7K748Ys9eMMx1d3zCGka9Ub8On2UyyWcnDr5VcbZ8epANRQuUQYiTQCWZixIUuUgezUflVV0gtsFcCc8nsEIxSmS9XcciUXgGH0Jq3UbfcCT/pMj+sSYRDomnhfC1ouKptDsMYU8PEMZd3HCs4aW5oT5px1EqgygRqhscrrQnIx+xqYjou4JKAAn9qtROr3RKRqilQcnCRe5MaI2ouKMp1hTaCmJskh6V0VYgZEUz+gLt1+iN7+F5t0a4mQw+ZTTfmKwjCOVrUT5MB4GOjvOq9Ou6mbZbg4LUTBR+TDHBHqUfB2MtK2SlTzURZcrB+l5Wb67wAE+Tq+lhgmk/1AnRq8eAyt0p2TsgRLe1s2ds7kb6K9WTk2dtN1OtxK22251FIAKXiJ57qLb6iKOt7IfVG88c8dPMVLy1itxhFcCGQm/EZ/rFSLPihHSI/+Gya2XdQTIub+/H9VqFQMDA/rgbTSaA6emZu7z8OWQSUNLVOczSpjXZoLQQWk+MBLCyvYR5BgvaAa9k39qBMbnZSrBG459OjVuJtYz0cNKTCdo5nMm8Qx0GlTExLILiKgnaLqNUyu7cVFNZJzatYsuRomJhpm1zB0h11FHU6P1WnElfoWXnyXuKefAkN2I9yIVidvNtNXCbqXJ8FxRioI42Yt7K9eCNp4/wg+0aon8Em9twUrFsGcIGdd6khPbIrSkXS4jFhwQq5dUaAknmK5nJp5uEJPdZCOi8BYF2Yj9itcrT3qjUJxZs1DLHffJxjAjsB2+IjoMSBk5z+Hymoys4SFnKPM2onUZGHBRCoscm2idYvkV/Fr43pOw3JCCHK7/zXfcVFm7YQ2GhocwOjaK8VXjES0MCEmIZlqEEQJoPtkrRJ414y1X4nmOK4SMBMe3O6/A5/TG0hlv4mv+c9yaW/QxPDyMHTt2xGA8G9PnDPbv24cTk5OVmZnZzaPLl6NUqXS73S5FnRleiPL61VieyHh1mjQ0ScobkXzHSL5hB07tgYhLGGtvY/6Z0YARS+rNlC0jUSsQkMNGCzSyh/csDTUh78yTlYgNAbmOZkYXJ3AITQX0QUFVYSXmzkZGqtBP+UMyp59aJG2CJ1xJI3bKVFBWAzjOxnokbEFwDsN+tTadv7DQL3RlCHmwVrzJhGFjlQ1sGCsASbLB/B+vBQw7iXix11dWSKEJw0IUqQo9xyMr4yZjPqmTHTAMNxCYYjOf8nSNZ/8RdoFJ5BPtxxGakjiwRr1lPXGRvbi40IWwShiieovRHZEV2eT6psWxCpiJJFyIRjKpbpWC0/Il8tFvJBYjEytXrjh64Bim2mRKGVo0rWZrsdJ8f4Q9Kdb2nrXPqhGe51XmkVy2cVZkZFGoqrRKvuvZfiWfpeMODmj63cvhNdBoNGIhEoLxwp/btm4zGzZtAs1u3lb7qsTzCBOsEaIrmY1bnnUpEYRJD84IX9DoohdKOuRfB0dzAM3QTgoMF8oG2mxYHzuidzJtk93GnRPIP+AcschxVrccpvKws6HlQq5l0SY8FUpWPMY5OxfCeokiGBcpCBz+56ONp1VdLDM0nbzcRGvPTEU2wm/wljN1YT29WFPs1bfUi/LIKePTsibHeT5SSykwQJE7IfAKN8gcOYd4NWgzCvCQdRtfrKRCAtNOU0JukSpCzrJyLYW9ajkwmI/fxpTheG6c2NNqs0UN5AW0osNxUgTR/nuOP3TK9mDsTKGmCP6IUIsziuLPSdATpT023A1CfYmeu8YoEkbdpHB99P6h4CRn2Gqe85K8Fim58zF3xpZKqM02rpufno8tzLmZOUyfmlkMRGQ7mx3+Wq8QedaO0IZ/9+U8+LMWIxVroY+/ixshDOnrnu1XsDdiNf0VDuA77+AFPGrneYC2221MTU1FmWL4+yc+8Qn/yCMP4/kvfX51Yt3qLKwIvcszUGg+TfjGkh2o0CoEQXD0H3Wf8hwiF4WrsoqnKFwqLIR9SPWE5e3kgWNghclacIxnugkB6dS2oe4J4yEkcuH5Xly24ofQ9Guk+qGQOY5yJcwgJ8mmkXg+iYmjKdxSWJ9QUpTLoupQH/N9pRwwqTph4IFeaI0SJAwKrq4CpkS6LkNOijFRhIwnMqr6vaUEFk9bD/LgjE9TwaxMwAOAA3Qg3/VkPAcqLRKBlopOdofn/gg75hcN56welmHiSTSSi3EwxorJq1ErM0ablO8sPiChQ0LXz0Z1dbhXAhRktY4lxrPxNrmYULkUmy5MhpEMY0rXCWiSnAKBc8JdC6kA2bLECU+XbmJrMmN88NSpN1u3N5rNfrrMi9KWeRObYvXa7L3x8wC+PZ4Fg5jWvJjjrMXIw7N1tLvdi5Xz/igTGXujN8LYDODvAPyX852NcHtXSxb99vx0pqAWCMjIjh07IrExrAbHhpZtH6j2LzNZRsINpwyHWH6wJsY4sR4V7qSkj3G2SFhKc/vCMBkAQaqayUreEN4eVcKxZHDEboCL0cBK4/SWJytpL7iAJaitCSfYxx6JTV6ePD8py9QUKKrWe86CkVAXXoRncd6Ne289CyQS7iHpu4msAAV+eP8ZGJIiwEsIHRIz1DBphYPlhAnCK35wbZYUSirkNZKDWyCXCIFTagcn4AIdkyh+pZPCXh3Wy4nTPNyo6uEoOyG/pHBh3r9QcATGi/Vs08/7Q2QOpYkIKOZSLDKVM8xsYeKOpAHDGokvNIQoZZT5p4du+cZidpEPzNWIhzjp29AxOLo/ud3kuQwmdVaoiOI3Msi2pb6K0FFocuXVvj40arUb8zwfq1T6UC6Vz/s7NNM5S6wHKeP+mvkCV1p12RtLd4TQ1FvDrTtcWtzb4qxbi7H/hazwCxgvAPCrvZupN84w3sFKm9GznZygpAkPyA/evgU3jZxbKRxQkfC4n5qa8q9+9auxbdtW7H30sbu8c9EGPs7bYtBOtBCv3l+gVoZ0AQzPekYZj5psJviJFfKkaEaNkA3VEQI+dT0Y/TcszvFi853AB+4heBZr8mLXa3vCkgZI6I8c3EYm8LHdYJN9ufAm2NiM9MEFcWwqCpjLGf9ZqEu8EUOTOOt6iI09VKUrziOF85dOrU+dLc8i2qKuOblmQMTB1pr0c1U5B4SBCwnWHLHwyShnV8U4sSWEQpQhN1cgHyVEY6G9QGb6mMzLTqR6ucNZzphsLA0frdq8SWeKCK5Cctb8vchrZSzJJ4oQ26NJ1RhRLc6Pzpjq4lgmLYFHUndxqmAq7GRvrJG6znjKXQo02MidwsjNt9zcNzExgbGxMZRKT6IFLlhdbh7o49pywbiVTa9e0XuI9cYZxqdP1NsDP3bdWmzsX7wO/FmLkcl2F1OdLvouTIAe4MFPLMqe9cYzdbwcwKMAvv5sx3ei2cH2oX7c/+JbcMvo4FlPw7p166KSJrRpBgcGo/HT5NSpm43NCApxeVFyS89carBYkdKwl5Uz2sCI030Ut7J4gTPyY6AJkQWc8CVpfrS8Jc/UAmFBxDLFO1r60oScczq+rpUlJkfpoNwv8bKyd+wfbr1A9Ix2qPDCM4E0lirBqd3rkr4wZF3ujSOyi6AeNKgCCoRXK2xdggGErEFiDifvSubvheJMzlNBlWpEJkt/d94JlmEKjE5GRkwM9RWLMRasUPOFGxySDKTsVgm+jftqBcLxRiok4XmwO5zolqA2uc4nW5F0s0gscGzlGNHUikcdN9WowpP0ZD4mryECWkAwIsaFqWW/WFbZSHlrxS9OOk90TEq7BcN7RveYjir2qvLgqxqbgJW+Pr/lhmv6S9UM87X56MnzpDuBxysnluOXb94U3bULi87/yIXI9t4TuDfOMpZNd7t/O9FXwcfuWbzb5Kxqmj31Jg7U27h2qB+N9lPuDQUvkbPPHr3RGzRWMbn1Q2yY9FDxvJStiWFdmweq+Pjd2/GOhw/gz47Px+h08ZQIT/2ZmZn4FRCST3/60zg+OYmh4YH1kZkRe/c5kRX06c2KSMPrW+VERHKpYZqnEfSe0+O0K1DUWrKmpSCS8Ukua5WLadQ5gjghlgPjTZJvyGRljHYkmCgh1uLR9dQzg9UyjcKLI0l0BKETZ0yx+FJPCxRdReNLLE/ZMo/zS40E53HjwSZuqSid6bjF81T6MV5/BCZu0C64ZARvGL/R1oxgQBD2hFEQyigsUQADBNowBKkQ3GGSAYhXHxAt6GIhQW8mGxEr/mGK6cTMHJFKyaEqOdarQ6wcuJqKEHVYCxT6t1UIiaAcr4JoRKNWDs+RhpVXFjWStY2FnhjZDXKTI9sT+a6+kJpngUAcivGSLZVdq72jUas/FNxW7Vnanb9002a86ZrV6HiP+W6M+QiR8j/W44b0xlMZJWNe+Nh841d3DPe/5e+efz0eKzi1X+w4azESGNoHmm3cOjqIk+2ntPVfYgVFb/TGUx3fzl9vPl3LHrhKoSDZPlTB23deg38YbmDMmliQVCoVnDhxAvv370cWuSEOt956K27YeT327H2iXG80MDI8EuPQHTs68Mo1KCqohojkRcNWmJIUJ4G3IkYleMCSTZr6rwsXAwyz6JzMUghDNu7yasYSrFGvdujcalQ5qxNk8Sx4pWDE4TiMP1YG1EyBTa0kEcDEjTs1mM1tygYUpaoyZcC2tCSV8SaX5kyk11Dgr1GsApk4qgkg4X1q5lDfQYWtCXRxViZtq6WDMk+pDuQDsCIi9pJCx4fMS/cM1tG7RS8kaJdndoYYj3ktYeij6KAsH42E5YZX5bHjZISjYthYP9Y8RBbN6ULGvhabyvHHEuEnniTP6BaXgNIOizVSJlYwFIoc/Pg9q4xCq4mJqqzeZRqJ8pm8BvZxnSjaYhsDC2MBY8I+Bp4UjKmemprZ2W13Pxr2PbRp2izzXd9fwfXD/Xjzlgm8avNqHJupYZYKkRDz/8beU6s3LmRYY350X731qXvHRz72NavP2nl/yuOsxUj4PXhgpo7XrF+ROH5nHxVOc+2N3riY8etsLb3ggVixBp12FwfqefSicNwSCE6Swews/Cmuknv37sXNN19rlp8a7Ku3osTEmW40fjDO8szncxaukLjE8wJT+gTRDFULjPCwD56pQvmMC1vDGLynKRQSTOclIo9EDD6ZRyjfs2goYSSCRZ05vASXyOKeJKOeybIwCejw7LhB3RZvpTpI1qCePEJIFWTlE5gHAi3CrJjAUecjHhJJVekDLAMajo1NnBBD2DTDirRHTOAUJPBe2izpYBgpiMRMBoDEwMRKDeFEh8NuJuzsTlRZKzpczxviM8nR/GTLYfgNzjsWv0idSRRZRhgM65QdSbO9176WE41uJDBFVm9EF8gizfKd4xn4kDwc+blWstT0IXEOKazCNh3fe84zpZYqIitv9CjeAEbs8qSUkUqPP59qaIrYCbuclRCKczM7O/+C+dr8CgDHnSOC6letGMb//7wb0JeZWKQ/dnI2TCYrSsZ8hIPReqM3LmgYWjR+4Eiz/bHFOHPnND3bW2sVW4znGosWJd8bz9rxQ0ycez1LgekGNUDNecw7j5VMtAu+In19fWp6Fr6OHj2KfYcP7TCVbMVAFuPTjXPC+bAgBYM4plsv1uGQO9w5QdehzEtP4LoyGjgfJbpXRJA85uganpe4YcGeW0RaYWpExjxVmgGZdypUVXGBZa81mVAt2ZYbxS008teI5FehGc/TkmdHsgJa4VMCjrdsiu8gvh4Oygr1hfYEqEUkOl1DvQA2AlNbsEQ+9Wn/OUw3sUFUQC0+GVQgUZa+E7t27RKJupfM07k1IWGEhfi4YkfKKwwSk+yskC9kR6MEWrzclChjOLuwkCcs9BE+OPXp16OR3lYKBzZqiS/wCfnLFvMJKZU4ljyehdJchoYC13NaD5dN0jRTPRb52yl7mpJ1jQJIRMwWnlI4tfXZue3W2KHBwcHj7VIZo9bg12/ZhL6Sxd5aM1bhmTGv5iC08d4jtzcuYQTfmVdz2/2Sxjm1Of82PY/ZZud8JNZrAXx/72r2xiKMu5k/ovfTvAO2li0GDTBlsvgg3rJli1m+fLmZn5+P8t57770XGzduxKEDR17c7br1/dV+RlKc5vMC8hC3In4BdHpySYipc5DnHgtP3Iq9s2lHVJ04qxxU0bNadtsSgw1jWbErohDRZVDFoAzWAglSRBziPMavBBTXICULWXjFusf6NK2KtIVBArZoVXcNKArgmBYa5ahMWyH9sFWeA02Tnl2HqKLQ/JtIuszIPmUBpZWdS5S3SuYu1KUwXjJc4nmy0YfUchadXBWqF2mHA202I9Vs0YotcT8N1SkyxcvUbvRscz1mY9IwNc642RbNZ+LpdyY16rgeFf5Q+Gzi1NjkqKb3hSk4uTDRiAsgJ2pxltvwXeI1sIcP1kY/4FQXi2E9F7qciMS8ZSPGvvE7lolLhnglxgWksFwpjb/yla/o27hxE7zNsGN0GOuqJRypNYXoE9SOf9krRHpjkcaipPuesxh5dL6JQ402hrLsXC/7YO+K9sYijnBP/jaADwfX9+O5x91DZbxvmcehRx/D/XuewIMPPojdu3b5gwcP4uDBg+Zzn/scjhw+gtr07D02d+VKuQwxCWH4W2iJXnQxEh7iI6eEYtbELjXgHaYACRoxA3fWc/BrpJ9ExCUP3R+lNzpiGRBT0TNSorIVx8RWh5T/G+NsQzER5zuyn3eG7c+izocNUXnC9RzdpvRRMaZIlBFp/pBDeWyv0O95WEDnzmjunWUDMydJcCIvNRyRI8RNmSY5H5A0H0yiFSfQBCdoN8lILcWnUQoODudLJ5mnV2+Y5kLzbUznD65uHCvrxazMKyaDnIugyFcW5zbOkIPspuNrLZYqfLSGDOySqshrA037QQExEyFxUX2k+IwCK6bAdlGHNM4C5KPMg16JkSmqQG0UXEkXiWXFauIiHCLaoBWSEbSM0RNOxi/O+ywrwdqssmZirK+UOXRPncTk0aMYLWfowNwE4IvsA9UbvbFYY5xjAi5pnLMYaTmH/3liBsv6ztrNCTLNF/YuaW9chvFaAI8Y4FsPtHN838pB/NHOlVjRrmHfvn3++Klp3LhzJ17ykpdERU2r3QpP5wlrMpQqJZ/Htgu7lUF8x53gCYWUFnWu8BLXz/ElRlEQetoLH0JsyZh7Ie6e0ZEzLWQNFziaf8dzKePwQkKkCYVFEkZZF164ixQdwxBB3DlrPZvGktgliXCg7+dKxwvBJKEhAvvzkRuxy6CaxjHO4GT6BFIfg6sqL10k1taysxz4/BjWyyp/Q04sRBXNvqdyoFRyCKfFs+uGY56MQfEkUZkjfFWj8I9ujbm70uRgBTDvhkOK6o/lqdJQmAZjxSAGheNnNMp46Z0UYWKt4gqi3oCXScgMbcVG23yH2NXzRvQ0BXWWkH1iDeOURGvUxZZM85y8BuK9ojdJjDVyCGZnzrvSoSMHn7v/5Km4inzthhXoeLzTA/cDeE7vYdUbl2GEHLLVl7LZ81qofWWuGWHbs4weKtIbl3OsM8BH2rn/r/vbOf7Ddevxry++FdcPVJAPj6I0OISpyUlfKpdx38vuG5jYuLa/EyyKjXW04mUiIVl0c/SuEaUmZYrEhLu4giaaKkESNI04WYRrdonO+jrtW+oJiBOIU5Nxpq96kZnKzOpTjCvP9pZkEhT7aqnYyVWxojQROEUT1PIdXpLhvKBA3DlI5hRK5WDhBSEO3Eny7OIObs94SdxdMCNLqC25v0qxpG0M8OuYCRzCeWitzlpY6wVWkLJG8gettnJkJ2jmli0i/YxfF/ib1ijtxXidtVXhLJdX7dWM0baHBNs4YcNYdRCxLlU8BWM6sYExCmpJwec0MNgYQWSMp8rTLfBaA7F1LPe4ks5IhnTJTNFnUi6d1stq1x8rJ7H3N1wpB45UVipnqJRL5pEjx18zMzuff+DGjSM/d/M1//Nos/Of88UJy+uN3jjTCIjFL17KmTlnMbKhvw8/uWMdTtRbZ/rx1/VCk3rjSgxr8GYPfGHX1PwNE30lfP6FO/H728YicfWRx5/A5IkTWLF87Ma+/uqKONnmjqUjhkPkYyVigsSS5ROiKPHCbPXsX8Y1B9gZIlUE6j8isHk09vaaYSYB/HEF7UQc7Cl1zRbaF1SJsBLF+ySpMUJhoQi3Yt9DcA/yKRHuh8pv5Oc890qtk4iOTIJgA1TuuMQFOie08VwYvuscT+Le6EuDU6iVxH7PXmBI3u1WtDNSxYhthpeIGFrGO6O+YMnxjB9DmfEyHVtt3vDdZVLiDDmaRXjLeEGP1IZW/iNSZ+qD0TGmitIUzp/4qTEjwxJnGeKyVshJpHw666iXQqgbk5+5KLLEjCbecaGOoDNtnWN7FoJ+vJMSL+6NNRpLDCS0ywpGZtm7Vfbce632AnknbNs5VDKLerkPDx6eXPtjm8bf9APXrn340HzjxV0n6FVv9MZlG98FYOxiN35OMsgnnn89rh8ZxOFGC9Y86Vb+wyBd713X3rhCY01mzJtmOvnh8Ur5CxurGT483cZ8mBdbDYwvH31Nt51/Y6XSV+nv7/N5t5OpsIST5UCkhQKzUb01dZlKcxwtdR3NuEad0lUYApmnBZBPJBQ2LVHRbBTqyHsl/MYoF8EZo/N7URlDEfysnqEuDiT3VidmjcVj/YWRKDc2BSuoi2V4nePFuV5mZq+CGkERvM7LLP1JEz7kjKXFdtTNxn2wYjIHjRmEZPpyn2MhoqK0izymywm/lRTGAvoUulkcHRj4JN5ID4rxKmquGdFB6eBSKgh4LF94SnRWyouUP4lPzAeZLB8JSTIkAtL3cg+tgHlFmMIkpZXhjTi+H4UqTD63pmCtKwiRoetn9Pui/PbOiHBGrpGcwmDycthkqLXb3fdV2mPvWrvs1cfabqSR+zM9v3ujNy7HCO5n/3Ax2z0rMvK2bWtwz8Ry7JmrnyksbxsrH3qjN67oyIz5nelu/kdTrS4aucNNt9+BVStW4fDBg891Lh/s6y+HR3TGcWKe016oC2+9oNxPZowY1rxqqz6MTPoy5JVltKCQ+oO3oCm2kCkXEkWjs7/RT6Mpj9oRzEnR1b1hU8+4MM51jc8iVNH6OMpA8ZaMMJSVWdSTCk+W/iX1EMk/C3wMJEtSsTUvijUIWklJbV7X7uqMokRUw6iS4QW9ioAEBlEibDobNNkHazqnPE3uJqnohDTAHgJARbxLWcAohgvpddDultQ1cLofTp98RToq9O9Cw5HXqhOdUI90Swo26T3ASUh6Y5H9O8UCo1hYMVhF94HcV3L5XMGFVfm0kMLQF9otFIdM9+Zjtg/jeQd/XK5lb1ze138k95jPHS4s0aM3euOSxkWb5521GAkhOHO1FsyZK+qelLc3rtqYd/4/bO3LPvOdg1j58HwTcwZo1mvbMpuhnJV99Bdxhp1XsXCy4WATI5m2zAKQMgFeGAtij1pQQ8T/2mR0BWkKWHbQ8mmyJccuMf4WZ4o4Mo4SVkSe7daFRSKqVJX4crpNWobzJGvTK1Kmm2xL5jsuxnjCNvr3NClqXp0szXUf5Bh96qZIDg73g4zMklLosO4jusIHfgd7q6jFKkywUeVJXFzPoGk10CJCoBNDSYTREsVJVC3nD9tomq88TvkcYpAs2H3ZZmaNTs6mUDyo9ll6YMJJMUDKKBKBLbfynE+lgpPq1Crplg3VUJASF4AlS40ek441HoflXo1m86YwnSK0J1er5IFZb7ELZdzRreE3m0dwm2uZx3Og6TxptnujN67cWAngxRfzaWds0/zB7dvw/BUjOFA/Y3umzJki/b0L3BtXY4SHcBd2451V+4bByaNzp7Zu/LfZav+3jcJuHRocCZQRtUWVVXay4DBpkjsDoqB4gSFVDTi7RFUdceZ0acKE0htVMyq/M84QK0D+nX6VjKx0jZqzFlbHYqSKQmGg/AgrzMaCrYZu3Gh1ISt3m4zSaKiOxsfMf5nIi9RGQ9F0ZNAmxq5EAdbdl8+S49fVN3dyxEmD9t+KslpYmTrHGmWbFErGRNLlU14k7Mg3GTxI7qoLQhHl+kL2zUmBJa0faJPKGFuoTFA4jwnG0XvCpHukcP9w8hAhWpbJRCkyyOhV1kvlRbyb0DmpVZjQTE3CBcWZV8tVy8e2z5Yx5h1+qHMKb+mcxAgc9ptyqtl6ozeu/BjnGuGCxpPu1+/euBL/7Xk7sG9qHvmZb+gQqPRXvQvcG1dzdD0wlBmsQY7Hli3/zOsPzg8eKA0857aV477TbmcQr1Tul4i+VBykwKCGTQi8zpASoedxmsSBw0cQA03EJE2ksWB1KRUA2g6IbiEy2UscnU2ogPAdcp68szRROyEvRIKEZbdxV0j2F5KkhxipG3KYRWx7WCATaY9LBRNA+0/oARND1NIztW88d4fCe3JHxYRlVELOh0zShnpi3FGSOBXh6fCsG/Un7IgrxYjUUM4vmIw9+7VanowdcV/p+vFmvex3wUk//DBjSxVnEpBCnmmO21EqpGUWi1W9sWEURCMGJddIIm1EMI5CsWCI1+NZn0QROJrfp204g7Ljc6UAACAASURBVJQAQFffJiQHrDznc+I4RjFjLY93KcIoyBbqAA7YMl7gGviPzRO41rVwxJZRi8hTb/TGVR+ByHrqQnZiwX27bbCKj96zHc12F7XuWXuN7+pp1Xvjao9wb3Z8uNstNtTmN30N2mumhkbyB8oDps91bZkD/sPkLitxK0lmjB5Yk9JuU/8+oQtWJ+gCwaGgRCUmpIavJs6jWHAqVVZWuuFvmSIaNG0WWkDR2oRRETGfUO/xBOIowiOepYKeSI6NmJCZRDQw1qTv8e91psCCLRiXmdO2KS6xC4mw1qSSxQl6wfCFMZKPYwr/9lrssLtJ4sss6FkVijtJGk7YgxZfkBaHpACqQIrPlE1FFQ3CUdLnFhARpCJA0Kn0b7Awl5t00k5JvSrVbOsZ5NvKKtfIxCpTkCZFj+QMZlI0+0JriENnimm+rJ+csRlOmTJe15nGe1rHIxoSEBKnr+qN3rjqIzhp338hO7GgGPnArVtw28plODDfjBX5Wcb7AEz0rnVvXO0hZcEpYzFRzvD1rmYnnTH/qzxkKnDoN7kkqyaSKPMYnITCMlrA9ENFRQpUQ60AvFi40xzmTapEIJQAiaVNLQjhcDC5M9JPvfILCoRYfR9PyF4aLuDvOYUjij0NKDEyqUKY56BJM4BoSyIdVN9WnJhNOn76MbmnyiRpjOIUEbPw6tnCn8kwhRcnfJa9FIiYcmx6DrVPwbgRFynSorKQ4F6zoBASYzIj7S05CJ8mb/ZBJRqK5TqEKzunbREpQjyHGTIdVREPW0CTFhabbCWb3s8u7dKOSk2sha0YafcpUdqnNpnwcMXwTT3mCc6JD+ujKGPeGLyjfQI/0J7CKZNh0pR6aEhvLLXRAPAXF7JPC6xVjzU7BRb3WUfPW6Q3ltQIN/ERbzHiPd7ROmE2ui5+qzqGOWOw1nV1UpZOjE477OfpmZDoecIWlEKpjF7naVZICMIu02JCFryqLXRS1s+WmH6r7RmXJKlIfIsUagvdT0L140xaSGnjydAbUXl4CWGBT5N64S/JptxK66lAJTXc+qAcnwibuKIqRo4flrNxyH7LQMJvijwKmwzevEAF6ufBCAlt3zpFbXy06hf/WSNFlXJIvAAnRmJzTz8X+oLomRpLL8+VovBYWPy7EPaidol0amTPlUoiJ8AVrwn/3LKlq4JmUjBK+eHJ09fqlhMWZKjzpgWtsl68FI2ek5M9nrAVvz7vmh9vHsfzu7XYpmnHtkyRK9MbvbEkxs4L3YkFdUdo0zz4kltwstWNVvBnGFsA7Old695YiiPcsVV4rHMdfD4bwC/0r8TDWRUb8w4GEFwpxLOMpy9B6YUvYFKuSNxaxgteBScEM1AZjK6wjbZniOfpCsoYoRsklS/TQxUU0FlM9yPN/kkOG/cnNymk1qS5D0jFghQnuS2IfgSCkZ/DIy+s4FmzAxdj7b1wLHl3iyySBEY4Rl8WFDP82aoGKhQyysHg8+zZjT0YdklxQPYtTnmpih6l86t2dkwP5mNk6a8rcnTE6Esuu2gDDRUp7H1ivJCBaesxGC9sISseuwq4vdimRbkuGdjp/vnClfTCT9G/WyguwxwW7YHxbgrPCdziKcHjpCnhhCnha7vz+LHWiVhg77fl4h3SG72x1MbR4A11Ifu0AN2b6nRx3VA/XrBqFFOt9plkvV8P4DW9y94bS3GYqLIxEbre7lq4r1tDHzy+VBpADRmGfV7QwYhPKcWgCr/RmoIKwjFAYb1RWxH6Ca+pbSSL2mS/YbQgIOWtoBiMW8hMnhANkmpKFF8KPvHUTzDsa0pzlGMuhuwFwyBEdSGbdw754xYAA/3WeEEHwMQJrxwOq3O0Uk201aRcBXHc0lmTEmJE1ZPUL1bPUiTJ0A+F9SvJxjzbmlg4CDknqVeNXiCBo2y0dNWOSdFS1qRyg5CQQukQURKrfSaR5iacJfw/g5aTEqwshaRXQkqhEjVqLCuxfmpqn6ATEeZoRhE13qA/5CKIHdy4IZcbbf2EA87gzaFSH5bD4UdbJ/HG9kn0w+OgrfTUMv+HvTcBk+Qqr0TPvRGRe1Vl7VW9d6u7JYQWhIQQqzxIIBh2m82GwQYGxjPYYBtsPGNsj83Yw8w3YJtnGy+Mjd/4jbENGCyG1Q8hEItAC9rVUu9b7XvlGhH3zvffJTK7u7oqqyp7q77HTtRVlUtkRGbcE/9//nMcLnYUAPyv1YhYz2g1HqnU8Z4d/ViMTvEvtHg3gJvdx8DhYkVDR+KjIAVeEi5gr6jju36BjXBfdItYR7wyk7Nmw0VkEiCXrPX2Ul6vFtr7y4oeTQWEGRcLrR7VATMNPaSwK6S1GDNlfasmtRmvtgzR0HCax5sGEkuaD8rditsug0gaL3a5FE0FmqQLYQhXQ/bA7RqZFDSaFZQNCYmuoJhoF1NOaVjXmxqF1K8nbURPwmHMs4tkIkkktrSMNWzQm4Wxxlg/UWkwGzKjGBvXjiP6T7YVpSxbDS0xnM8eIW6foTF2JJhJxhWmQGPImiEhia9YIkfRm2WemRlje/NGDcXTpq/6oyG4mYJuLnXpSorNP9ayY8u9tJ7F2PxyXRjyzGE5wNPyqriGj1dG2IujEia4j1mlD3FtGYdLAt8TEo8FnCHve0hzvuztDDIyUq3j9v4uXLu1H90M6E4H6PI9TNcj+ra+nwFXuM+Bw8UOWjSqjGGW+7g+ruBZcRkP+Dl2yEujCxGzBtz6H0ZyyJJ5FLMaqVFZk5lqp16ZNehiyXplg9iMFXuT7NBm5JkLfDvy0igENAlUdGgbR+PKG9yqWDlsRq8J60vKF0hUkdaorGnwJTE+UT9x62tqegEJrTBuJ9wE2zN7f2Gu2L2EhjAreEm0FPqq3hRnrN5VWm8XpSrhpkbRrJfV2ZvSMJnkL2ZN1vuWJ6M9+v726RPlrUTTMGwSWGj4oo4ETsiRtI812hXzZpJ5GN3EYclUTrO6VUUxS2ZHXFhCUu2Mj94BqvGkrOotH9QMzYQD6OdIBqzMfczfLOWlu1cZZ8e8FH4iLrHfr46yQUQ4zNOm1ePgcGlAAI+kOPt2V+BhOoxRE3LZ25KVvuf3duAtW/owXq2rn68qZPHqTd2YrEb7GMNe91lwuJQQg2GrqGOWe/hoegDf8DuwSUYyL2LEesGgrwK3GTCmtaCLGrqyYcsDSauERoZFQ4mhiUXcMOeS3KoGksaA1pU2CUdkos1QQ5+qaM+lnXqRjbRsIe3rG42LbNInNHw8rNDSPLOUSffBrq/GW1aanBtpyjeSSztRap+zMZ0jtHBWJsWSxOxVj60CpuXFTGck0cM06WlksohboUMy0dQojTBTs+BWr2KXdNn0MPvanrHxsK2vJt0N1/+jnHgT4xfbNDGfW3rLkHYaR8ZKVyx5w/ZEhSSaKRwudSFFWDs49fq68mR94LipdMnECE0KddTssWaGv+jPj9UU6VahfpQngUnuowyOn4um8Z76lBKojjFfaUccHC4xfHpHPvOOX3n4MP7u+OSKW95y2/Ghl1yX35HLjE3Vw7z7RDhcaiBCMiAjZKTAX6Z68KlUL/KQsl/UWayvhkUyTdvw8pTMLCiCcZ1qJszlrF7Xhemy2BaKdeWwhZRkiEYoBQdnDXaTGHqquDwbhqIC3KwAxV54C/0Iu3xJOx8LO2CiVaHSXqwzaYofSkrL7XNJYQsqZnxZ2Ag77WjPzeovmidM9NbS44VM4vJPYy2m6SGFKUEY9mHrGsk71jUGk/Rn/mLbRFZXYrPjEuFLokixmbasMdGjlbCmASIaatPE11bH4zKz/gveiGQ2ih8rdBVmojaxydP0QTC7t6xBjWwUWXjyqpphSmmHlFhjw01AMVNudkgopB2EVo/RDxRHWMCKUrAP1SbwimhekZAF5rm2jMMlib5U8M1D5ept13+zNbuRlqt+35ycH+pMB46IOFySoBP6OPMwzTy8tz6Fj1ZHkIFgh7yMHvWUVB6xDRiTzW6qDtIYkdBiKxKvMStItR0d3SIQ1mdCLUuNKQkzO6HS5RNzDislQRLoYkw4zdW3SfO3V9B6ETOtHGNrnjRljH5EWBkETzJkjeNpYsxlZCO6kJGErxmJi5CN6gI3WSnSGnw1jFKR9KhEIjjRz2PD9JI+lLQlET21axtXsLvG9FwE1P4XSZ4ykPjgmuaOULys4QdiJBuAlWZoo37WlG7IpFVoSNZI8WWN7bftLGurpvlZbEIDdQdHGI6ZeLTYtxdrNqG22ahdhLQ9o6Rxp9tvZi/Hmpgmf6fPZcgZnuYpXC2q+GTlOF4ezeMIT2FRuck6IuJwaaIjGwx86vB4y9veEhmhL87zegq9pXroPhYOlyzo2rTMOA7zFF4aLeIvy8fw/LiEAzxF5XBj1ipNoUCrNBIHTC2sMM2XphK+5CaIzuTmC1WWUP4byeSw2mFJ0F3DjiL5PUfjQloNverXT8bZrL5SQXMlXUzQma/SakXsk9h7SG5VuboqYUSrTe0ly4i4TNohOt6vSW6hF34t0uR2axsPtZMhVrFivWFNsrBsYl3qSRI3exjlcEI+zJ+a9w9nLOlCJfu4aSTJFnF4UrFRXERazxO7qdpF3mYXJx2k5AmU2CMJ1NO7Ss/iWvFLMmTTmI9q7JyG6NeUQuyklKGGzVubdOHIH2fe83CCB/jp+iz/08pJtlOE6vMYO32IwyWOUi3qefVwd8sf4yXbNK8c6sZ7dg7iRLmmft5dyOCWno6XjVXrX1vGmdXB4ZIBtW02y1AtTZ/I9MnPBN2sW0ayS0YyZnbYNhEz6gt6dW1vJmaFnY9plPNVkUCZb8SmTWBEpVIX/YVZulTVQhhmQKUHLZ5gpisEmy4jrawSdi5FNEaMrVJWMBvmasKDjYhDqpgak6sjRcMz3aoahJ4GJp2EtJPNzaJa+8pcqR9Y4n1mV1zRmBGSlmBQw0lTCk9olYuR4eh2kH73pjijs3O49bxH0rPSYyrS6H5jCRGqHa/4ipB29jaZYwIL6F2YQkcSEcyS8VvYvaANRXRzx8hctL2IbIwKJU8jzJSv2sm2j6Y3gZk/qJdRjRlhymsN3QhURLClTQJCaLUs0+/fkwIjXqD2xvtrk+wt4ayq2k27aRmHDQIhZWlnPrPpb49Nzt89Ob/imzqDWRDZOPCyZ2F7bxdQ1WSkGgkcq9Re4zH2RUdFHDYKiJB0yRh9MsJngyL+IN2vjMCG4kiv3kkOCvR8iCoACLUSw0x62i5JsrrJxE7cyEqk0WE0Zmhs9cPTS5qNSdPPKJB4hnLTqNBkgXORmIiZ0ouZWWmenJGycfVt5zhULSeZ3SB9hEpYUVzAmtMzpZPQDxVmJIabYoVkiV7TkgulP7WDIdJIYKzGROjXtrExzeNKumgjm2xMGhMzpuYhEkeSaJFeVLB0NxeCWA4dME8mshalvZXg9UX90HSHkZSQ4FePrjBuXNiEqd4ARnhM9mhmekoa41rVajHMScf8WXN35ZDHLE9KtpUJo0omPZHij1qYaqpLev9rVZHtCHG9D+UR7svtss5/szqBm6Ny4qbqqiEOGwUSqAspt+3Ipcd8b+XAAv/0X/zctn5s78rjwMRsEn2u7mgUWA4OGwV0BTrPOKoswBvDWewQdfyXzAAO+wHbFkV2dNUMwtrr9kQdamc77CKsFx6eFAmSjBbrYGIbJuaK3PqPnuK0wbQxqS3JwGbgyER7wWhdZk25NY2hFTtfYlzTT58d1mTA2pxybodgYJJrpJm3URJTye2bMxJeayWfzAjxpFBipaVoXPkbZYnS7TJFo2zSSpLCb/3ApGJqzDqz6i2uzDJkuyXb+kKO/DB4VDMSYX0W4k1qXtTmgLEHgdmDDEEa8Dsa9DDRbSSuu1YUzJujg5PjY4SqZMim9zlvTG43OixmnJlIiHZr1d50XBEw2WjLmQ4UpR5reznUwYmI4MVRiX+4No4hEeEgT+k35c4sDhsI1Oj0GPOOVeotvalTCh0+Y3jktuuwLZvBKDmwnnrfnwTwOfdhcdhosEXxbSJUEwwfyQ2Ie/0c3xKFhnrYJoZZlpSzvG4ymEaAXcxYYhneGLxVsAuwTGZidXFBMwdTQ9FjqMpvlP4em85FY+rDTHMokYIwFQcT88ttV8Km4jBrSMqUjoUb+zEtcBGNfokdRlFW5cZGREfSmI0y5qEcVolh5LLMGl9Ik28sk4g3MxYjrLeHjc1P5khibaKSnGK0GRgHI0+66pQUxd1gu18NluoAwlJjJ57RweBAkAWoOjL1JDDxMFA+yWRQJCIhmB11MaM1JjVHTf0atqB3LrcNG810SDrMbUMLzeofo2m1byhRBMPOKam7xNaLjiFpBamR3Unm4U31WflLtSlq5mGUBa4t47BREQHYAeBEK2/wFDL+9m39uKqnAyPV2lJiksh9ZBw2ImwDhYStXYjxR+UR/rJwUT7B07KkLCVM40E27qsFFEK3FWTTzIfOgxEN3YForDQy8ZUwvQHdARBNF/H6qrxJeUmCBCG1KkE3U8xMSVKiSASVxjTLZPipqSCdtGKNVk0zRW8fV8M0UqtxzULKG1MyllBw8wLCphw3WiqmK2Os2jUtS7zMYBQeJDgRjblk/VC94UKLcXRtgksWlYDyOEPvM4G9PwnmpYHyBBBVza3S9G97K+v70P7Z9BzgGW8BBm+UCBeZnvrluvHTyBeCOXq6yWMULzJpP9lOV+KcYvcf0/zTlnCgBUSw08WJR33i36YlOEpvI+U4AhxnKby7PoP/WBtnNCnjiIjDBodcDW9IWi9URP30TVegk3MsxmIpMrKF+Ir79DhsVNBSQ74OFEH2oqjEemWMH3tZzHDOusgXy86o6OFYk/EqrRuIvQAHkmgSO2HRMHDlSlOifT6tHWfDz7QRRGtEKrZwkcgqmU25E9yufJYf6J5Cw92Cs2TARV+cNxSaZjAlceJKhkQS43LtfNEk6mjYtpriALNmatpY1s4HSzRC52xgjrVYS8ZtmM3iAyfzuIix6hRkKs+w9VawbbdqplNfgAnnWR7M8EKqjngpoP86sOocY7MHmEzlJEvaZfbIaB1HcrQ4Em6lI/QSPmHqHGZKByyJ7Usea9+5HhNKbOW53Rd03yNeSm4VIT5cH2OvC+eVrXuJLWF/7eCwsVAG8FFQd7IFJJqRd2zvx7W9nTgws3iKVqQJs+6D4rDR4ZmU1LyM8a76FLteVNlH0gPyEE/L7aJuliyuE3EbeTKMm5ES4yNio9K0cpInoxZJLV/aJBnt9sWZlA0rLM5skJ3QcXuC2VaN0ocypk24hLLFSHL6kjaCqjPo0gPTDEjN7MAYyiZBOdYjxCbfJPKNJIDHTPqQrp0zaWzWuYm0TzovVqqpqgzCNq7QlHyTLOwJT1ICXshaiSGOwIZvAoZuksgNArVZIK63RkSaQfcPy/oX239CojTGUB7lMtOpJq7tfLMxjFc2qpRtbN6+TRGWljCakoXO2jUlLdjjr0tWOvWHedTS4dLawTIT5lMFkye8ALfGC+w3qpS2Gyr/kMjpQxwuDxBnWGz1nSbk/PO37EUggdLSVRGodHbg/e5D5LDRQQtFyJgK27syruFfRSW238uwh4IM65BC+swGvKiZFGPUYS6KtVJDNsLgGW/4lOmSvmwUGFiSFGtNxtRjPV10sWm2Oky4MbxqXsAWY6RxQbEOItIO/jTZjllVrQ6R0ffjJolGGn8NPb5rDTRIQMJgUwCTNEHbtbHGXlIFvJipHqMC0S9iyiOa2DSS4RKDVRmFDFGdYedLwbbfpilSdTaZ1lkTlFi0DqSLgBcAk/sY4xk0qe+ZDQO2BRDe2D1aamwGes1WSiNhbY4U0kQlifxpols0BuwBcp57mOAB3laf4b9ZHWcBwI7x1CkeKg4OGxxHAPxZq2/Rf+f2Aby4txNbc2kcWqxiGR+RUapik7Ga+wQ5bHTYbwHpSIZkiI9XTrD/Ifvxeb+TDYoYOSHVbKgZ1U1ML1SxQ7ujM5kM+UplYpVkqSTKUzsPIxQzEIn0UzArU00GVrSzR5NvmJ2O0cO+IhmjNSZfomlwVjZyaoSZ4lHJMFTtkA1xqQCsTb0WSJgygvmdLqRo+apWSnA1PNIoGDCmvdOYtF4e1pZdi0d1Bo/2I5ESpRmw7S8GNj8XKI1rR9N22BgR/aEJm86tYB2bBEoTAM9qN9bEt0wKjzWmiWy0rjqMMUs8ZPWf0Nivxuo9CRtsRONo71cu4U2CyaoE+7X6ON5an8EE8zHnbN0dLj+MreYdew/cdj2eUcjgcLmmiMgy54LIaEb63IfK4XKB1ZFQP/NfhwtYYBzf9PLIQrCMWW4b/t8Ni3j1VRJGi2CVjQp22jMxuABP4uW4GRGW2u09iXdL8legl02h4/FtKyWxZzP1CF17YDyZKxYskaFYEaqNnG0Mg2hFh2gKIDYZOMYbzQ4Jmd5PUghpxM2Zp4iVoxszQ762JMKaLcNQmwLru4ph18u01kOE7S0ZELGh6khthmH2MJNexmh+7ci0tKPKScC/MUsxCcrJ2C+RGy0xNg7xtgSmvf9pX2irWeYJYBweFjhnv1GbwFvCORzngXL9dfoQh8sQ3wbwxVbftn9osaL/0dolyVEK8XWfKofLCXRFO8c4Yubjl2pTKEqBP071yjkmsElEVnWgY2zs/9v1Pxn7tE2VWP9LIKkVCBNhT3+DtT8Xev7WalbV3GvikdrwMFHru7DSUDtta67irdeXPlamWpE4cRl6wpP4m2T4VU0OW3N2bZgG2/iBaJAGI9CUltYYUYuHxPpeDwzbDo3eQaiMSXRtZ9jzGn03mopZrT5kRZhNJUJCcbjaNs4m8FhTk6aTnhXrJkYhdtLXRDabcSCZ+MDwZEbHphYe9FKyR8T4SHWMvSQqKX2Is3V3uIxxaDVvfbXfk9bi9xwcNhi4UmJxTHEf76rP4BPVEbZVhOwQS1l/MmiXzuQH68zOEjML27MwwzMyGWzVCx1PWgK6t8JsCi1vOHNKrYcFayT8M1iXT2lDWLhVo+hXktZI1EomqAYjTMNH946kaKoEaOc1lqTgSjNNzJvEHNLQjWSDG+ND3GbyKrMv40pKhCCi0V2gayfD3jcAzG99YmYtIFJB48Ge31RzMdO4Vm1jo37UPtOGtrp+xGyHTag0YmV5qz1dmU2aIT7jQbCq1O28F8cl9ufVk4qIHOWBbs25E4HD5YuHVvPOV3sauM99sBwuV9CXpQKmFpqfiBbxZ5URvCAus4MshRDNhCGZb2HNMgHd+OCJMarKYku6H7C9EqstMcJTqaNN1C+sVlRaX3jYhFqeKDoSyzHbYdFVF1gbrkZbxsamGFPYZHts00hXAmRifpK8lyQWn5lhYqF91OwdhFXK2DYHR1RiCGcZBm9guOpNgJ/VUzPniog0YDQ0ZgeYN2W7NKa8I5u6afp/rD2u7uLYflMiElZ7z2Ng8/BwkgV4e30Of1QZwXZZx0EeJNUmB4fLFHK1fOEMO/gVcL/7ZDlczrALzH6exqCM8LHaCP677McXgk45hBgpCZPxYnPp0DxyK00FQluiJg4kWh4ptAVqo5phWzsm7deOzuguitWM6MQ9KaxRaHPGf0N4iaZYlbiRm2uydHUEsDQtIW3iZn6RKFBNzhsYNZP08wkz8WMydZTBui2X6DKC2vz6vPb/2PsGiZ69ui1zfogIaUeYYWZ2bkmampSej2aGTAmR7HIlB2l0cAwVMYZx5GFm7OEwjQAlxvDrtXG8LZzHOPMw74SqDg4w4tWTdBGV9ThSfOUv+2rJyH4AEwD63e52uJxBCw5Zx3fLGP+5NgZq1nw66MFOWUPaVCxY00hr4vApjXsWTB+B2W6IUrxqAYfq2RjHceP6yZNIPRX7a8saNvamkdZnBSKy0UFJtCTcTuWYx2ptitJ1KHuQpslV7QTCjfG7nbgRyq9Dmklmal8Ik8TSPLtrukyq8hCSODWS2Pt6hoFrgNIYQJbv54OIKBgTXOtIZsohjDUVraStgiSTMdbFzvqS6OaYjb9TXjTSxyzz8Jv1Mbw5nMVxngL5Vjsi4uCgME5fvbTHEXCOuTBeca+slowQTjoy4uCgCcmsEbb+Sn0CWSnxV6lu2YeIdaroWKvaMCpSO4nSyNlFEmVvrS4kMxpTnozj6j+wRKgBU+YwCyXTehNdnVC/5HoyV1qbeUuMFCnSl/6JPsXk5jE7YUILt4m+TzJvGlxHQTWaklD9JgMRW3FRb4HLaEG3ia56A0PvXmBxBMlznS8ImWwPjFWbhU4lZrJh2GKN8a2Prd1S+xxcaWAx5vlqX//X2gheGc3jqDIyc4m7Dg5NeJS+D1s6snj3D5/GP4/OrLhv1kJGqFVzvdvrDg5aizBvrod/uT6BfkT4WKYfixJsiwgRN9ZnzSDMLK/6HV1jm+AX3SxhMrkoN6l8dmG0ayVjJgBXNKZzbUq/Fj9okaWtTuht1Daq2i/E9Iu4tZk3bqI1IA4pB0eRGE7CTz9tFmHyeWWWfZjejs2O05UdPXXCdE4PyWIq0xJeimHv64Hu3UBlsrHKn3cwT5oClHHlT4znjG1dI1pG1Yi49dU3smQb/0MTMzwlhhCxj9RG2fOicjIx4/QhDg4NhELeube7gK8cn8Snjoy3tGfWQkb+CsA73X53cNAgKkLBZyEL8NP1WbZL1PCH6QHs4xlsFzUruTCKC+MCb9oEnk7FY3bWRs/SgtSRys3VZNioXor2tdClE12fsOMvZi3kxisticPVvEUHvFHUjBmpaQqto4U4KoORpiPdzeDnpBKXViaYCq2LY4kgBbCcfX4T82/Dgi05kXrqJy4D1Tmw4k5g5x0S+UFDRHCBVmylZWF6Q5WRrTAphtxOFjGj0tV7WqLRRjNzSuTOX4WHE/DxkniRvb8+wbbHYRL974iIg8MpWBjKpL7w2MwC3nrf/pb3zFrIyHedbsTB4VRwlQalJ23oinlPfBwfzgzjh34WZ4ngAwAAIABJREFUFJJm3UyZNRY0pX/NPEyBX8jGBTkF4ZFuhAQWiu6wJNk/GaZh1t2UJabv1vNC23DpeWHloSYSNzRtmiq50pDUpikPRuKK1wA8JRkF1xExqS9ILBzXo7jlcbDFkwxRDUjlaFzWGG6YiH1a16OqBFm553qBbS8Chm4GUgWgMnUe9SGngyWaEWaKRo1sQcMAJW+4wdh2V6LxMU9RA2ekDyI31V+tjbMauBrldfoQB4czwYCvdWaC6n+6bz9mwtbD/tdCRgjfAPAz7jg4ODRgr5APqEmbEH9UPYFfzm7CXV4Bu0VdG4BRF8BYqKqBWdJ2MGuvxZUtPJfkHxpzkQTpNUZKle2IoJkOMi3niaahKfbFGLYbbzVhBoTtE6jQPiFjxlhYB7wOhm23A7kBPeFCvCmuaULSd41epcMKsHAUmDmogudQnZBCeoIFBcbCClVWGFJFhv7rJDbdDHRu0891QYmIAe3DGNr7BNoZlgo4Qo9Lqx1u9p2wxR3D3HTaYJUxHOYB3lmbwYdqY6CUGTcx4+BwdkjiB1JiVyG9qr3kvf+K4bXs1k4Ar3PHw8HhTFgL+SwkXhwt4iBP42EvJ7pkDF+ZiXErXTX5cvpa3UTuWd8LPb7bsJJP8mZtoIzVi0qZ5M7qyovppNhsHGseah3kbcpdfRZy+Gaw4Rt1Nkyi3jR26nFVj+ESCsNa+9G1S6IwBEQVYHEcCPKSDT8X2PxCiaFnA34KqM4kg0IXFH4GWDwJzB5i8FOGqDEb4EM7SSAJxDOeuUpvIyF8SDW2O8LI5G6a/WJ9UqU5LzprdweHlfA+H2x2Vz6Nvz4ygUi2RtzXUxlxcHA4C+jKeZT5qkLysepJfCQ9iC+lusRW1HlaSh3RIrVCIYna0xYYVNZo8BJtf6oHf00On1Gx2pRY7TViezb6uUxSLk8mcFjTKI5alklLETCW6RaqErIccSBiQsFzBKqY9F4L1rFDV0tIZ9KxWZOT2joTd88FtBcbGfZzve+S4pGnrd/V7tKG99w46FO5ZAYeTUrJX65N4p31GYwzXxFMVxFxcFgWT1O+6EQtxDXdBbx0oAt3tjBJg3XEJpwAsM8dEweHs4OurqmsT/4TH6mO8LfXp/kRllLjwFwmBqWqUcBJncqluTiHCb9FMndqnC60CsRG/ENrS6xsxKhRdMWEG1cTLZo1qgiu9bAcUsRSBnkpM0Udud8q6L7UfqFn774SoMeTQDUsmye4mNScdhyZ2dg/k0+Y7DLr8KK0uWq+2gPYCR4o4vFb1Qn+zvqM+Zk7IuLgsDL+f3UP42T8r4eKLe+y9XR0v+AOjIPD8qAFbJr5mFEhexPsd8qjaq50nKfgM+MkouY1uKlqJLbk2g+VNS2AUlCGjG2kNNu4Jy5qJulfWpmqGcFlDZWr1BOuMSSN7lIrQ7SuMVOg16THkLOqauNczOMkQotthZTcuIzYIpQyWOG2aWb0rce4L7fKCH9aOcFeG2oPkZrzEHFwaBUqpZe+S+OlGt6ypQ8D6aClh661TUO4E8CH3CFycFgeREjoypoWtTfWZ7Bd1PHB3DBOwmdkKS+SVHuTm2vGZWkIlZsuC1NxcxTQCy0bafIp19f9UtnQEzvxaGBXpbup6Rsl21RKFSmEiXjjIgbjaQkemFbGBoSSx8RQcuDEPlU53TM9TEN7RmjfFlILH2Rp7BY1fLJygg2KyI3uOjisDlQf/Rf7iPkowu5cDh/cvQn/3/GJFZ9oPWTkhwBKAPLugDk4LA+6sqYwvYNeGjfHZfxOZZR9ILtJTjAPA4IIiRKCMGtfptiDsQQ1pqzKB564SSwFEQ5NW6R1FTXm8zYLR0H3fYiY2IB8a2MS1RmyPQypgkRtfuMePO5ZB1o6BuS2L63+F8btTO2jI16KTOrYf6uMokfEKnvItWUcHFYFsv1I6qweYziwUME7tvfj3TsGVnye9VQfQwD3uGPl4NAabPTdIZ7CrVEZf1A5qVoEoyyAJ3RLwUTZ6b6K0HOoNGRq/dC4CVlJUmB0Dm9D+2ASdpNsYDXKy4SnCgOyQVPoKmKQzEk37sGjklJQUKHBqn5kk3S1761uzJC33FGWxi5Rp9aMSt094jxEHBzWgrtOfwx938qxQCmOV7yttxV6xos7ODgsD1rmjvAAt0YlfLw8wihY7zgP1JUE04mwjeEaE2fPrE8r2ZVp83Vp3Lm0obt2crXjNkkUnJnUUWO+1o2dYnczHVLm+uWqxKuXGmhKKNcPBB0MUagaWVr1q73gFLE7yFK4Oq6yPymfxLAIcZQ5IuLgsEYsSUZiKVEXK9/WS0a+5Y6ag8PqYE1DSJPwnLiCP6qcYF0yxCHuKw8LZjJ3pQ6/YzG1FoQWXKpujmxygmfK2Ez/rimETpqYPeW+ymWiiaXHxFWIVBHIdOsFe6OCxLXkj1LYLMhpVnnEqTqSYIgkY/t4CjfFZfaJygkUZYxjriLi4LBWLAL40Xr23nrJCL14ayk4Dg4OCWzL5iAP8ExRw59XTuKGuILjLDD6D1gViYnBs6UO+ouJbrMpeeTrLrXviKcHgKUN9OVKtMnVfTjTUyFhCGT7wYL86idpLilIPYq8+RaO/BBjpREGWQdCxuQ0PPmW+hw+VhlBBhI0vuuIiIPDmvF11V9eJSIhUfA9bMul101GhDNAc3BYO+gLSN4jW2SEP6mewNVxBQdYSuk8iHpwEzGjgmQ8bhSuREnUpGosbbSNEYkImreRamBESDPGapmP0AMkiq7kBiAvtFX7OQejjB0g2wtc9SZg03P1Dj1Z9fD66pz8nZFj6J6JMF/hSMUbdKTIweH84KurfRUq9vakfZSiGHeOzKzZDr4ZJJN9lTvgDg5rA3GCWeahEwK3xGUVrnfYC9BjHcqt2kOoOV+jVlXmrZwZtzNdQ9F5/zCTq4aEqJkRbjJwZCyZl5IYuI6xIKezaDYyiMhRu4aqQL1XAYVNQM9WYMszJB8dzOB4Z1q1xvKVGF0LMQqlGJmaQCqUSqsjPKYyC914r4PDsiCbj8nV7KKAcwzl03jjD57Cf33qxLpGey2+446Rg8P6QC2CEyzAVlHHJyon2fuyw+wQS2OHjGi2RkIIbYFmh2ekdpO3eTLSDqnqbo0Sm2hhq9aeMGXwJRmFaAZdnKU65IYnIhZUAYrK2rI+1wcUh2L2NLK4f28BmVCgcyFC33SIobE6euYipGoChXKMnpkIA5N1RUxmunyEgapHOTg4nIpRAE+sZp9QXs3Ozhw+fXAU/zKhsybYwZfd0I79OmYqJA4ODusADfUSIaEslPdnN4mDXpptF3UmrDdGol3VNmmJZFUy3TQ1U8A6rVdzE0VdhO72kKdI5w6GPa8B4lDnzlzOoN0W+gzVDEcYKBsWeLFEEEl0LMYYGq/jmn0l3PDwAiKfYzHvUWqy+4g7ODTwWQBvbHV/0GlqIBWgJgV2fu1BLEb6JNSurvH33IFxcFg/qEJCUx0DMsYnqif5blHFAS+QXJucaYIh7TyO/fqa8oinLL0S+xFu53/NPCs9LI6AbA/gZx0RAfS0NFU+Ohdi9E6H6J0J0bUQIVsVqGQ5Hr46j0+/eRD/8NoBpGsCHYsRBHdNGweHJqxq/ae2aEc+jQ8+ciQhImgjGXF+Iw4ObYImJAH6RYw/qIwwGv89yX1NQXRUnhKMNLmkKfWIMLZnKoKGy6SKojxcqUIiObyAIz+8cS3g2wGlsRFSkY/+qRBD4yG+95xO/O+fGlBtmnTd7TwHhyZ8s9WdQe2ZHR05fPbQGP7m6KkW8e0iI26ixsGhjSBCcpSTiDXGJ8sn2TPjCg6xFAIjE1FuZqbooeLy1BQNB7MJtSaYtmGdJhBXGPIDQOcWraFwWBnEAKltMzhex3du6cI9z+1CcS5yQ8AODhqU4f1QK/uCKPxQOoWpag3veODAGX9vFxnZB2DGHRwHh/bBh8QIC9TC99u1cbZNaodQNULDtYNXw5kV8JlQUXpSB/xatxJz48pzI9sPpDq0XsShNShCIqAmbZ7ck8NizoMfOzri4ADgZKs7gchGR9rHB05rzzT/vR0Qq9koBweH1mCnbLbIEH9QPYmiqIOG4Dya7xW8KZWGGeWIGa3h1kqe8le01pVSgINOuaHzaM4ViJDkykJN1Ux3+0jVHRlxcABwuJWdQARhSzaNR2cXz2jPWLTT9uiYOzIODu0HERIyRrsiruPj1VHkpZAj8IUPk0+TjPcyHZKvYuGYual+jta3Qko/Dbgew9pAOpLIZ6ilOTw3UePgQLi3lb1Axdsg7ePj+0fPep92kpH72/hcDg4OTSBCcpgHuFZU8T9qo8xjgh1nPnyuOjDK4EzqMomK6tU+JDHTYldK12PKcpW7qsjawYy4Ndau/A4ODvjBSrsgFBK7OrP43ugM/vrI2dNj2klG7nbHxcHh3IG+rId4CjfGFXysOsIKTMhRFlCFBMz8n1ADNoyZho1QZRISusaAlwWjcLzLxeys3SAfknw5RkcpVhUSB4fLHFUAP1xuF1B7pjcdIBIC737w0LJ7q51k5B7yVLrcj46Dw1pBY6N0Yyt0AA6zAM+LyvjDyghLS4EJ6QsTlUdtGantV7lg8NT8LyQX4SKTxe2QHVuAsOIO0WpBx2QxxzE4UUfPTIh6sNGDfRwcVgS1aBaWuxN9b3rzabzn/gN4fGH5Eb52fqMqrY74ODg4aFEkfVmL85Ey28pVYnWjn8mevGs+QhCeykxs2u8BnsL1cZm9tzbNppjPKupCXSYDNmrIhgnVnPEYWFSm6ohk3Nf6VofVIfagjsU1T5a0E64rjDg4/Gi5PRBLiV2FDO6h9sxZRKvNaEc2TTNo426+7A+Rg8MKoMWMnD9pXPSJPTk8uTuHhYKnyAm1AoickNnWprGaMt6qpRjmO/yEwNBaeJSn8Ppwjh1jPvtUugc7RQjfsJEYUnvFM3jlGQlqz/TsZYjr0glYVwly2J8sBrju8UVc/1gJs53tPm06OFySWJaM5Dyuyh3vf6ilgZu2k5H72vx8Dg4bEtSOIdLxjRd34yu39yiL8SAUiihQUiz9N1uNMTAZYvuxKq5/vITdhyqIPYbZTk/9N5QMU8zD+2qTmGS+/LLfBcqxiQRYHDJEdciwJFnPlRK7XwFkikB1Bi6CdpWg7BpK8n3BvfOqrERVkpVaaQ4OlwHOOrRCX49N+Qz+8KkTeGCu1NKe8Hd2ZPWDY4GDpZo6Ua2jd/Og+wQ6OKyM7rkQDz2zgH9+eS+6Z3UWyuml/5gzjA6ksH9nFvc/qwNXP1nCDY8u4orDVWSqytUMISf/M4nfL4+wSp7L76XzGEyFkoiHnwNSncDwc4B0B1CZSWL1HFoEkY7poo/rHi/hygNlTHcHjog4OOhw3DNtVA06fQ+HFyv40GOtO374H370iPrHrlwGb93WhxPl+nqunB4z9rC97mA5OCwNWsyoEkJkxI/kkkSEQF4W1MbpXIxVm+beGzvVY648WMG241XV5qmkOWY6fRQCgW0B2EImRmcWLMhJFYbnpYCwBFSmdZS+w+pAVRBq0xAZUWnI3FVFHBwAfH+5nVAXEj0pH9d15nDf7GJL+8v/vX0nkh+uKKRx60ART8+XVe95DYhMgt+r3dFycFgaREBIHzLb4asKx0piSMqfIfEktWwijymNycPPyCfaESixGNAlYmyOY4Qxg4h0/kxoKqSOiKwe1Eqb6A3wrEcX8Zwfz2Omy1VFHBwMlk3qrQiBTUEa//HKTfipe59qaZ+dcor6dw8eghQSnb6/Ho2bm6hxcFgBsmkyplXojBSppmz6TNx9j7n1z4ZIzQtUSgxRFYqMuKmZ9aGeYkjXJV5475w6XrEzjHNwsFh2nSdicbJcwx2DRVyRz7S0004hI/sWK/jovuMYLKQh1n4m+7E7XA4OZweV+inbhCLqSYjqcPGBS6kyaG54ZAFXHqhgpuiqIg4OTVhxna/EMfLpFN66ta+l/XZG8fZ3njyBsVIVg+mUck9bA1xlxMFhGRAByVdoUqaOesDcIncRoprmKCzGeP4P5xEGTBFIBwcHhf0Azu7rbsAZw0Kljrdu7UUxWHlw94yvWE0I/PqjR9GRC7DVA7b4DF1c96RbBClsJ90xc3BYBhLYerKmouidgdbFBQrEm+wOcONDi7jiSEUJhB1hdHBI8Eiru2KkWsfevi68tL9rxfsuyfc/fXQCnzk2g4eEjy+VBMZiYNAHota+kNL5jTg4LI9S3sP24zUMToQoZ91l98UCIh0LBR/D43W8+AezKOU858vi4HAqWgrFjaTEFYUsHhqbxfdnlnWNVzjrWfA9x0p4+yTwjrEIbxuLMR4zDPstmzcuG57j4HC5g9oAlHOy63BFLXjuyvviAFWpFvMcL7lnFptH68r11h0bB4dT0NL6Tl4jFNL5hnufwvFKfcX7n5WMFH2OFCS2BAwP1CT+eDZCoXWx3ePu2Dk4LA8a2d15tKpGfaUrjlxwEOmY7fKx+1AVNz60gKnuQLVsHBwcTsGK6ztVRQY7sviTA6PYX6q2tPfOegqkhOyUcWPdm2L4f2cjfKsUY2fAEK/8vI+5Y+fgsDwWCx52HqtiaKKOUsbNjV5okEiVXG9f8MM5ZdVfTbn+jIPDaTgK4MRyO4UGX4bSKUyUqvjPTx5vef+1dD2W50BZSnycArskQ2bl7yi5nMy3vBUODpchaimOvqkQV1CrJs9dO+ACgvb9TJevjgXlAE0XA+W86uDgcApWLDTQd6kj4+PXHjmC2TBqee+1REZokmZHwPCNUoxvl2NsCfhK0zXUIHqy5a1wcLhMQWO+V+6vKHMtZ6p14UBVkVqaK7fVdFWocV4HB4czsOy6TlWRzdkU9s2W1CDMatBypzqgaHIGfHKmrpwdh9MeOnx9o6jgJbhJy+M/Dg6XK+Y6PJXGS7c5N0J6QaCqIsUAN/14Ac+7fx4z3e44ODicBaf4iFEGzVAmAAXu0u2KrjzSxRw+vn901ftvZScSA2I8232GOxdjfHSqjg/0BBilWV+KOvc4Ch7HXBQ3Z9o8AOBd7og6OJwdkc+Qqwq1EFLmjPMcOf8g4znSiNz+7RmVR0M/8zU6Pjo4bHAkzqskUt2eT+Nb4/O4Z1qrMqg4QZMzf3F4bNV7oWUyAlNGuSKXxh+cnMP/8+BJRVDoAqIYePjq85+B/lSAmUaPqLV0HAeHyxhWq3DV02U1WXN8UxrFuciRkvMI8nyhVN7hsbo6Fo6IODgsiQqAp+0funxPxca8/f79mKiH695jqxoopO8oVUC4EBiphRirhRivhXhqsYovjEyjWMgotmTgyIiDQwugK/GuhQg3PLKImpvgOO+g6tTgeB2pUDrbdweHs4Ns4MtQOlKJgUIG/3h8qi1EBKslI3Yj0vzME+Z/2XcCI/NllWlj6AiNAI20ZSsdHDYwlL9Fp4/rHl/EtuM1ZbrlcP5A5ytKQ2bOU8TBYTnsg/m+ULJ/vR7hd/ctO+W7Kpz1rCdEo1YpW0jwna5H+P19J9BZyDTbtO53h9bBYWVUMx76p0LsOlLFbJcz2zqfINO5k4MpZfsehC4ryMHhLFDrObVmBjoy+PjTIzjYoqFZKzi76ZnfkJN4np45JFKyHDH544Oj+KdDoxjMBDbOwY33Oji0ACYlFvMebv7xAgYm6iofxU10nB90LcZ4/Mo8vvucLgxMho6QODgsDeW82p8O8ODEHH5rFYZmrWBJMlIoFNDX16eIB5GSgYEBlslk1M+cL19C/siTJ5ANPBUf7MZ7HRxaB+WgUFbNHXfNYKHgOf3CeQJVRuj2968bwDdu7VYVKrql60L93lWpHBwUHqVTUlfax68/dgyhaK/Se8lpmo6ODtWmqVZ1CWZ8fFzSz6lUSlVJliMkdwwWFRGJdQXlgDuGDg6tgRa9id5AeV08dlUOjzwjj6HxOsQSGi2H9oEygnKVWLVp/vnlvTi6Ja3ExDRdE0QC6apEqi6VriTymDJHI/dcRxYdLiOQkekRRT8kwwt6O/D18dm2vvslyYhtx9CNMYZaraYICGPLnxQznONtW3uxUEvGew9dXsfLwWF9qKcYYg685qtTODGcVu2aQil2bYNzDCJ8ubJQpOP+6zsUERycCJGtxMjUBTrnY/TOhOiZidA/HaJ3OkS2KlRrrZRzVv4OGx5TAGboTU5W6/h3OwfwyYNjGK2tnMbbKpYkI1EUnUI+WiEihNdv6sEzeztxYGbRtmlooqZE8Tbus+rgsDLI42Km6GPrSA2v/MYUPvO6AXUF7ha7cw/az1Sdorwgsuaf7PERe4Gy7KcbCfOpddM1H2Fwoo7tx2u45skStpysqbTfctZzLR2HjYpZM0ij8mZ293TgrVv78LH9J9v2dpdMw6hUKshmsygWi6jXNfOxZIQ0JPT32dkzSzR/eO12bMukMB/FVsBKA8g/T20m9xF1cGgNRDxo8SPvkad259TVdxC5Re68geljQPucMoMyNYFcRSinXD+WavKJqlaPXZlXx6eU87D1ZA1906EiJJIDrpDlsMFwGMBf0luiQkNA7qu5FP7s0OqdVs+GJbue1J45ePAgJicnQcLVVqoiLx0o4rahbhwv107/Ira3seTgcBmANAnUBqCrdPq3w8UBqlwROemZjbBpvK7Ixxdf0Ys/+9lNePjqAorzEbwYS2V1OThcyjiFdYxXQ1zb04F/s62/bW9pWZ+RAwcOkHhVCVeTBzA0u6wm+PmdA+qf8ZlP5ciIg8MqQVfXdGVOV+PCpflelCDha74SY/NIHaMDKfzpOzbjvusL6JkNXWnEYaPhiVPeD32+Y4F/s7WvbW9zxUuuY8eOYX5+PiEksQQiMLUt1EYlctKXCnB9Zw4zlXCpJ1x9fJ+Dw+UOSYsdU/bwzGWlXLSQerhACVsLpQhfemmvMlDLl91Bc9hQONL8ZpiqjtRxQzGPvNeeq6WWgvJIN0IiViIfTyzW8I7+Dnx4z7U4RuZA5Evie8j7HqbDCEtMIbqJGgeHVYAWt86FSE3SHB9Oq+qIw8UNEr92LsSqQvLIMwq4465plLOuveawYXDk9DdC2tCt+TT+4oZd+ObEXPL77pSPB2ZLp/yuFbRERoiIkI6EyH4XE3hbMYPhgo8O05OJhFRE5CzSkjPehIODw5kgEkImWzStQYLJO+/ow0RvSgkj3WjvxQ86Rl4sMdfpKwEyiWDdcXPYIDjGjHjVggoPx0s1vGFzD35me5N2JJvG0YlZbP/ag6t65y2REZh+zrFI4u0dPp6XBg6VT03qW+Y7d8x9Gh0czg66qs5WhBI/0mTG4a0Z3HtjJ+67vgPFucgtaJcQ6FBlajG4dJbyDhsDUktBj2/KpOCfpeIQR43qLVusYFt/F352Wz/+5uhEy/ugZTJCW5MG8HKTKCpaj/x1ZMTBYQnQYkXTGZSHMtPl457nduHRq/LYvzOrJmi650L4sRZKOlwaoIyhjsXY+cI4bBxIHN+aT0/9t30n8J2phRXfloBETyrA0wuVVe2ClsgInQsnYuC6NMPzsxwjlNfQ+mscMlayqRbu6+BwWYCICE3L9MyEeOiZBSV8JO8KMtWixYxudB9HRC4dUIWLHFy75yJlG+/gsBEwmAkO/3h2Eb/5xLmtK7SmGSEv2FjiXXmOQR84UG+5KkIgFQvZtO1Yx3Y6OGwY0EUzeVEUZyN884Xd+Nyr+pAKpcqhsaV9V+K/9BD6XJFI0vjUnTeMwwZBPh2MfPGpmXP+Zlr6xswI4KoUw5s7PMxHci0j9G6818HBggG9syG+/5xOlRRLUxhUIXEE5NJGJcsxMFlXuTXVtCMjDhsDURifuKHr3Ce6tEZGuI939WVxVZpjLF4TGRlZw7Y5OGxIkAfF8aE0vnJbDzoWIm1s5pJ5L2mQRqQecGw7UVOTUC7R12GjYLIWnrh9oAud/rl1X2xNMzI7jfsOVIBrtyATSoRy1YTEVUYcHAxy5RjfuaUL08VAtWacLuTSR+gz5Msxdh2pOPt+hw2FUizGutI+/vRZO3HXxPyq3hpdY3UGPj55cBTleHm/pJbIiJidxl/PAjfmU3jvFcM4sFA5m6fI2XBigx0fB4d1gUZ4HQfZGKCqyHynrxJ8dxytYjHf8pCig8NFD85w8liphp/a1IO3bhtY3eaqWfcUntddwP88Mr7sXVf1rXnfw4eVwUl34GEuWiKF5uxw470ODhYMKM6FLk1tg0C1ZKTETT9eUELk2IMb7XXYSDgRcIaRamiC+FeHeL6MOwaLeM1w97KPWxUZEVLiq2Oz+NmdQ5ieK8FrvTyyPCVycLiMsJjz1FX0d2/uwnyHpwSsTrx6aYJIx2yXjyuOVLH3QBmznb4jIg4bCTVy9jjdfXU1oFbNdD3CStPuq64n/u6TJ/DGzb3o8L0Ve0BNmHQfTwcHDZq6GJwIcdt3ZvC/3jCITFWoK2pHSC490DELA4ZnP7ygNCOLec+REYeNhIlIyLnhbApZfm61UKsmIwdLVfzV4XH8wlVb8dT0AoLWpgAcGXFwMKDFarrbx/N/NI/JngBfvq0HA1Mh0nXpxKyXEGxVhHQi1z9WwmxX4IiIw4ZCKOTk3q6c/PujE/irI61bu68Fa1JaffSpk3j79n70pwPMUEDeyg+ZAlCmQYKNdrAcHNYCcuhcKHh4zdemVDjel17Wq66sKYvGjfleGqCqSD3FcMt982pEmxJ7uSMjDhsIPSl/5lipil986DAm6qvXi6wGa6q7nKjW8cFHjqA7nybdVisgQ/tzS6scHC4h0BV0JcMxX/Dwyn+Zxrv+9ygKJaHGfblwK9rFDjp+M0Ufew9UcOPDi5jpDhwRcdhw6Munxz5xYPScExGslYwQ/vLwOB6anMfOfAZxa4zEkREHhyZQSF4tzTHVE+CW++fxi586rnJNJntT8BwhuahBEzRkckYTNLlqjFrq7NUsvy6Qnw3ROVlHYSZUP58vfRC9DhNAdiFC13gNxbEaukcXzakaAAAgAElEQVRrajvSlRhMOK2Sw9mxUA3HXjfcjfQ51osQ1mWpdqRcw9t2DmCxHrUypfgmALvW83oODhsNzCwYNFVDotYtIzXcf30HwhRHpuYWiosRVLkiwnj1U2W86htTmOv0IZsmDRQBANSCn5+LUMv7GN2Zw8ieAhZ7UijMhiiO1xAHHFGKt19nwvQ2ZMoxuibr8GKJya05HHxWFw5f14kDzy5idjCN7GKEzulQkeIo7YS3DmdiMYq/ev1A8e4n50p4ZL58TvfQutx5vjI2iy8em8Jrt/Ri/3x5pVHf6fW8loPDRgYtCKQ52HOwgp/53Bj+5s1DCNJCiVodIbl4QAt2NeOp6aeX3j2jKlj1gKnjB1UxYYoE5OZCHL+qA/tu6cbIrjxmB9KoZzm8UKJntIq9P5zBs78+jnQ5xnxfCjxePxNQJEgCeVP1mNySxRPP78HRqzsxuiuHxe5AbZ/wGDKlCKmKwNXfm8LNd46qak3suw+aw6lgjE3Pl2v4xV1DyLS5OiIg0eH7KEUxHporrY+MEH7/qRN47dZeVcaJlm/XzK73tRwcNjQkMNafwnMfXMBJk10zNFF3x/wiAoPEVLePl981jav2l7Vo1RIRj6Fzqg4/FPjuGzbh3lcNoZb3kF2MkS5FyM/GkJxhYmsWR6/uwKFrO/HKPzusqiREVtZDSOh5c/MhMguRqsA88bweHLihC1ObM+Ax1N+oTQRDqGhbazkP33nTZlQ6fNz+6aMod/jqeRwcLBgwO1KpY08hg0/duLvN+0UCxTx+9/v7cOfozPrJyA9nFvG5o5P4qa39eHq+BP/s1RFHRhwclgEzWoTpoo877prGgR0ZHNyRRf9k3U3YXASg9sxEXwrbj1Vx+92zpj2jt4sW+P6jZcwOZvC1f7sdT93UrYhJx3T9lAWexRId06Fq4Ry8oYjPfmgP3vx7+9A1UcNc/+oISVIJmQ1Vy2V6OIMfvGYYD72kH6Wir37fM1LTLXR22uOEVDoSIiSLxZT6fDE4U2CHMzCb4gxzYYy5sNK2vUOFiz2FLH58aAy//YQ2aG9L3eWXHjmM2Vp9pVS/mXa8loPDRgYtLuWsp/r8L79rBumaQN0Fr11w0HEp5T2k6gJv+NIkspVY5QsRvEgqYeiBG4r4zIevxNM3FdF3oqJaJUtVGiyBIfJCWpI737sL9YynqietQldCItXyoUrLt9+8Gf/463vx/dcPK0LTd6yCTMk4+56Fx9Lf6L6p6qqiPRwuL5yTdbvgeZCQeM+PDyW/a8tZ7niljr87NonBbGq5uzky4uDQAugKnCZsrnqqpMZGyWLc4cKC8mYoAO91X57EM54uY7KXDM6kaoHQdMojP9GniMh8bwr9R/UV5EpaHyIUfcerePJ5Pbj/FYPomqqfIoRd8jFmOqbnZFVVNf7lZ7fhcx/ag7t/egtKxQC9xytInYUEOTisAauL6W0BNH073JHFnxwYxY9mFpMHtO2S63vTi8DyApeFdr2Wg8NGBy061NfffbCiTNGciPXCYr7g46XfmsaL7p3HaH+gt4UCD8ereOxFvfjyz+9EjsZnJ2vquLUKaouQluPgdV2Y60sjvUyVglopNJ3Te6KCx1/Qg7/7ravwg1cP6UrI8Soyi5EmIe6z4tA+tH3dpg5KpVbHf3965JTft42M3NSdB8SyWTWOjDg4tAhritY3HaI4HyH0L75WjWRn3i4lSCkhhYSwt7jxb/q9+rvUhIEIRq4i4EcCscfUol8crWHkijy+/PM7kC5HSiS6am0P05qPk3vz2H9jEf1Hysk+TfYzZ2oKp/9YRYlNv/QLu/Cl9+5EqdNXvwuq6/AtoffH7Yz5pXX8HM45yOmstN4XoY8WTdrSjT5iAx05/OWhcRyr1E65X9vqv7f2dqBUX7b3uLjcHx0cHE4FLXpBJBCEAtX0hSUjJKyNAiDydctCpXiar7v1p1CLKNf3pVaCFwFBpP97oT0siFhokkHjimpkEYwzcE/NL+piArP31f9D97WEJT9dx523FtE9UcNND5dQ8/Xd7/7prQjTHnpPVtYsMqZHkZj03lcNqqrHzofnVbunWvBV1aM4WlXP/eBL+/G91w9jZjiL4lhVm6etsx1DrSYiWkrA6siIw6kom9uaIE3S/5ZsGoFpP3ppH1OlCn77yeNnPGVbyMhL+rvwrO4CjixWl7vbuXVMcXDYQKCFPVWXyuXTClrPF9ToJwdqGSBM6bNKpgoU5oH8IpAvAdkSkKox+LEmHjC6Crp/NStRyQGlArDYAZTzmsR4MT0GCM69s7QCEYk40vvN8znSGQ9+4Kl/0417DNy0NRhYExnR5RDRVDlBKCAKHu5+WT92jIV6fPd1wzh8bSe6R6rrmnaSpjqy0JvCZ39tL573hRFcc/ck+o5XlPfHoeu6cP8dA8qsjCow/cfK6vXapQtROhXX2nE4E7Rmr3mEhrQhezqy+J+HxvAPJ7TNWFfg4dH5MmbDM8Xa6yYj9Bn+vau3IhIS9L1f5vvhyIiDwypQKMd4emcW850+eqfP/QpOJITIBJGHoA70jQOds0DXLEP3tCYjmYomE3TfJVsDUi/sREzqaZpAAeaLwHSfxEInMNMLzHUDfgjkSss8zzpAXCKOBDyfIVtIIUUmZWkfXsAV+aC1V/ENQzpk07ZbYqJLyw2SQo/ZIYDqFQH+8QM5iBRHqctXmpF2dDioOtExVVfVkG/9zGY89Zwitj6xgHrOw+PP70U9w1U1hDxN2jnmrVtAQlVgZLptT+uwMUBr9ppGrej6ZFMmjcOlKv7tgwdbesy6yci7tg/glqFu7J9eWMmB1ZERB4cWQIsNaUX278jirhcVkS+d29FLqmyEaV3JIMJx5aPA1iMMfWO6IqLswn1KqNU3qpis+JxSP65zDuidBHY9zdRzLHQBJ7cAx3ZIjG7S1RKqtrSFkBDJMLqPfGcKuc40gpSnWjJCCFXlsJWSs8K2nJK/N/5F78mXDOXuIMl7offYLjJFhIQcWVPlGNObMji5J6/GhslRNT+rWzJtJ25mNJnej+vSOJyGNetFlP9NNsDb73+65cesi4yQwdkH9wyjVK6DrzCSBqBqCJMzTXBwOAtosclVYmUx/rlX9aGU5eifWoMwsgXYqgRVLqh9ct0DwK6nGHondJuGWi3UZlkL6HmpOkI3S17UCWoBuPYBYM8TDMe3A09cJzGyGSgs6G1Yz2JLAlQiHF19ORS60oqUUIWkXVDbJqQiDBZtJwfm+Yjo0C35/Tkc1RWea9M4LIlldRdnA33jtubSuG98Dp8/2XoKzLrIyPuvGMaV3QUcmC21QkZCc3PFQAeHZVCci/DPL+/F07uy2DR6btxX6UqYSEIlD2w6BtzwQ4bNR0nvAcx3Ndw92wl6TnpNeg0/AvY8CWw+yvDYsySevEaToo65tbVupJmGKfZrIhKGsbvUXwG0n+MUR1AT8GsCKDg/G4dTsKbeMH2uUoGHjz51clWPW/Onjyxif257P2QkWv3OUzBC5MiIg8PSoGpE31SoSMi3nl9Ez+y50YnQyYLaJUQIbr6H4eqH9e9m+swd5LmdflGLoKf1I6kq8JzvMmw/CNx/i8SxHbpKQpqV1RASqoJ09mSQd0SkZZA4Nl2KseMR7WvlvGwcTsOqg7HoazecSeHRmQV87uTUqh675pZJKCT+aP8IWMCRpZ5sCw9ZK9NycLgckK7pMcsv39aDWoojW1mHf8QSoGpI7JOYVOs47vhnhmfdp6sVJC5VZ5LzuIhbrQqRkp5J4PYvMdz4A4ZKVreHeCsdFgZE9RjprI+O7izi0IkfWkU172HowCJ2/XgOpa7g0thoh/OJFddrkmAVObDTB7b6wHYPSjT+6SOTq97MNVdG6Pv+qSPjePVwN14z2IWxaogFCSyTTkNvrHb2Pzs4XL6gVkzvTB3/8uJuPH5VHkNj7W3PUDWCplvIK+SaB3VbJl0Dpnv13y6Yx4TUcgUiQ6k6cNP3gb4xhntfJFW7iNo2cplLJhKscp8rIqJNyhwTaRV+KFHqTmGuP4WuiTriYNlsMYfLD8tqRuhaod8DDsYM/1ASKJDeLfBROjqDPz00uuqdtW4x6WsfH8cH5j34Hkd2+buGayn7ODhsdFD1o2shwnh/Cnc/vwuFxbit5ECN7Aa62vDsexlu/YYmOXPFC29GZqHIUgqY6QF2HABedidTUzakI1muQhLH1J7JqsqIqoo4tAzKsJnanMHhazqVlbyDw2lYtnhA5KMmgV+dAd47KfCBKYFfmeV455EFVOLVfxfXTUYCn+PP5yXurQGbfSzXrpFY9s8ODuuAEVySGI9uq4liv9CgxTZXjvH1W7sx0ZtC50LUtvYM7RMaqS11ADf9gOGZP9ZtEWrNtNQGOY+wxGiqX48YUxupY14LapfaViIfmVyAXEcKEelEnOZhVdDTQVBVkexitGzCr8NlibOeIegPgz7D98ox7q8KXJXiqkrSwyU2p9ZWYVs3GSlyhg4G/ON8pDbQXyF0cr2v5+BwOlRuyFyoTKOiFFcGUamqULHunVN1ZZt9vkAjmJS6W5gJVZpr13hNX3WeZUKEWjE0uvvgtQX84MZOZW7WzvYMiWKpBXLtAww3fh8oFzQ5uZitv4l4kMCWPEpu/z8M2Yp+D82ERBqDMhKsJj87rBqZcozD13VidFdehe2Rpwl9fh0cliMjvvnj5xYiFSmQYppMeOsgFeue5aKP7daA4YuzMd6cA+4oeDgYyrNt0Ll1b3K47EALN6WeTg9n8MNXDSqzKFpoc3ORilnfsm8BwwdK6B6tKqJCMeuU+XIuFmMiRfm5UIWaHbquU20LeVIMHSxj6FAJYYpjsSelvryWnBRKMRbyHr5yW6+yfE9FEqKNVRFyO929j6ZmtKkZtWsuhQwSte1FoHsKuPXrDN94lVTCVjJhUx4mkVAVkUzOR+TaM2sC7WOqiDz64l5la//M70xh9wOz6D1RVbbzwueoFDzUM54L0rs8seQXi365I8Xx9cUIX1iIsLMjDdmGD8e6yUgURUgzhqoE/mYuxMs7PAR0slh629xZw6GtKMyGSoD3Tx/YjfFtWVUJoZPs+DaO/TcV8VCpX2V8ECnZ+dA8Nu1fRGYxVumn5U6/bX4aRETotenE/dV3b8P+ZxcRBUy1i6hKsv2xBTz76+PY+uQC5vtSKBd8pEKB7tkQf/f6ARzdlMbweL1tRISqCLM9QP8o8IK7mBKv0u1SCkOjbaX3QP4nt3yH4e7bpcrC8eoA41q17yoi64PSK42TDb2H7/7UJjzyE30YPFTGwJEyBg+X1XeHSD2h3BWgluUuUO/ywZLrdWC6eZ+eDdW6nz77er8qrFs+3dvbi47OTmTjED8qx7gm7eHmDMeUWLJc814AfUs9j4PDqkGOnvMh7nnTZjx9UzeGD5XUhAC1ZdKVGLmFSFldz/enlUjvwI1FjO/Iq+oIkYSBoxWVPFvLeus+wVJbiHDnL+zC4y/qRddEDfn5SG1HlPZw5JpOHLyhSyW8UqUmuxgjG0rcc0sRX7m9Fz1zEbw2neTpvZCZGVURXvI1hmzZjMpegosInfTqGWD4uJ4EOrEN8EtCEREyN2unw+plC6Yna+j7QqR6cmtWfV4P3NClKiYzwxlU8776PPdQKKDHVJVxZZ9Lh0scDwL4YvNboNbGzhTHF+cj/P5kXXVFUoEeC6dJNt/3UalUMDMzs+p3vi4yMjQ0pG5xHMMTAtOxwPFQ4g10xSm1w9lpeB/xF/cJdWgH/EgoIvHgywbUIh+crg1pErXSiZYJibEdOUVcDj6rC1ObsurKb+hQGVGaI0qtkZQwoDheww9eO4wfvXJItWW4bIgBiRBRBSdMeXjiBb04sbeAG74zjbkMw1+8YzMydYFsRbYx40Qv4C/8pnZVneu5+MSqqwHpXqQHbD/EMNlPAleJ/nxWBd9Jp29oH6jvT3b3lVi1b+h7U+n0cfSZnXj6Od2KmNRyHnpPVpUeipKLiZQQOXG8ZEPiYQBfaH5jOaMNed9YTa31fR6Df6HJSH9/P3bu3Kle2PM8xEKgAxIP1gT2pDhemOOYis+ojhAZ6dm4x87hfIIWeSIRT93cg1rBX16oyvSCbCsm5D55+LouHL6+C1GKYfBIRYlN61lP9cpXQ0ropEyk6Puv36S2J1URZ0wlUEw7XX0SKRndmcP8liz29/g4NpBCcUGoBbcdsO6qZLV+/f1MaUYudTBoszaq8JCvyMnrA3Rn0hArhd45rAvMeJFQW5OErovdAQ48u1tVTWYH0/AEVKUkNx+p7430XAtng+ERAP9k3xJVRbanOT4zF+ET0yGuICJKbZsLTUa2bNmiXpg0I/RfSsWEEKiAYTKS+MkOX0laTquO/BKADXB6dLgYwKUEiyUOPLuI+d4UUrUWL/8ZlFiUiEGl4GPfLd04enWH+t3m/SV1VVjLGz1JC09HJ+OTewp4+LZ+ZErLeISY0cmOuQij27M43MWRn6ivOIK2GpBBGLUziIh0zeocmI1w1UrvIUwBnZMStT1plLYE8EvSjaKeD5h9TK1ImgyjNieRePreUZWPCMum/WVVIaGsG0dINgyIjHzevpmcqTR/aKKGiQgoekyt8e0iI2u6HhsYGEA+n0etpj1RqE1DG0JLwRYPuKcS42/nIzWHfBqcxZ9D26Ai1yu6BRMHq1+VaBKHHksjjVObs/g//2EXPv8ru3H8qg51xUdVlFbGbKkiQ+ZR1ZzXkr8JbXdmNkR2LoL02uuyShMzm45rjQXpRDbSwkDVkXQd2PlAjJjcVt3Z5LzC+pAQWaeJGzJNO3RdFz7/wT349ps3IzcfIqjGLuNm4+CUAZdBn+Nv50LcU4qwxXiK0bpv13+Ltbogt0pGTvl4FYtFxYaYUTANDAywXC6nNiLwPMDz8PlFCdL0NZ1ruSMjDu0EEQU6IXZO1hAFa7sioxMn3TqmQxTHqkq09w+/vhf3vHGTKk8TKbH3OSsYUO4MVnESluCcKQFgO+3LaRKHKiNX7NNW7/EG+7bR8S0XOXofraP36QjVbncVfqFAn3Vqk9LIfOdEDd9+y2almSLhtjsmGwbJGYT+UZUSny8Bnp9COhUoeUYqlcLg4CBLp9OKD9Dv6HYaWjoztkpGTvl4hWGo2jL04pxzzM3NqSoJbQTdka5abs4yNeLbpC/zzVSQg0PbQCZjNIKYqrZWxTjrB9yUIHtHtMfCt9+0BZ/58JVKvNc1WV/+2yS1aLTVVyf+wT2GVMZvKxkhQ7NNx4CtRzZeVcRC+Hq0d9N9de3V0iatjcPaQN8/ao+SweD3X7dJ6bDI0VW20bjP4YIhZV9YmMX75ixH2JQBRRxgYWFBlkolVKtVLC4uJrygCS2didb0VbaBVHSjF52fn5dERujzdzQUeFGG4Ve7fcwI2TyoTGQk7T5XDu0E+YUM7y+psnEtv/5SABEaav1QReTY1R34+/+0FyNX5NXziyVaKlZES6Zrq3F6FbFU7qFBytfjqW04dxMh2vk0Q6aiXVY3IohgVYsc/Y9H6D4Uodbh2MiFhjStG/LVufstW9TnMF1qX6SBwwVDsl7TmW1GAL/a7eFFGeBwXSjzRipKEAGp1+uqXUOFinPdpjkrrGiFSAmJ2yk455d6AnR5wNyp59iUq4w4tBtk/U5XYjSiS26R7agG2JNo74mK0oB86b27FNmg12i+4iPiQoZQT99YxKHru5Cfaz1sTKXNcoauPh0vKU4jJDbN37aIVkr3J0Oz4jQwOAKU8xuzKmIRB0CqJFWrJnaXNxcF6LtA4+0nd+dx11u3KlGr56adLnUk3y46Nc0Jqdb1X+5Jod5k3UEdEVr/l6iIrAptu6ygJzoaSrw8z/GKHMcxMp869S6Z5rKPg0O7QAx96+ML6ivTzqsxOsFSD5wcUz/7a3uUGVT/0bLyX6Bx3qHDJYzvyOHbb9kCvy5XF85nLM3T2QDF4TxqKYkZL8REVt9mMhHm0hHmA32jf9Pv6G+T2RCz6QgVXyidCBEPCr7rH4MKlqtv8G8ZvV8iIV1HYqQWpboSd7jwoONCou/9Nxax0JM6r5lQDucEp1B9Ws9pXX9FnuPlOY4jddE+AtEOO3gLy5Le3qnt4Ik5nbahaVcZcTgXWOhO4cofzmDfLT1qRJds2dtnIMaUSG9mKI3P/MaV+Fd/eww7HplXQ/dPPrcHd71tq/JfII+Spdo4S0FF+vsSpYxE5McoZHxsjTrhnaijrxygO/SRjThSMVdeDmQpFXKJqidQDmLMpWJFTKYyISYzISqBhPAZescCeJdJ+lM9z5Efi1EYE5jfxBUpcbiwsKJWmqhRGip3SC51nFF3pHWd1ve3FwN8rRSrbki7rn3aQkbowmR/KFVI3qvyHo5FSwblZdrxWg4OpyNMc1Uivvq7Uzh0fWfbe9WqBD1WU/4KX3nPDuXYSlWQ0SvyqnXSChFRUf4esJgVqAcSnSWOvcdS2DTpY3DaQ38pQKHCkakxeKbCc/q5nBlbjZhJVRWZT8U4ma9jf08VhzuryE/VMcNjhERkqHTK2IbNNiMha3ZaIj8aY3qn58jIxQSGtpn4OVxQnLFm02Gl9f3VBY7b8x6+UZa4uk1sZN1khE6OZcWWGP5Dl69GeZeoihDy630tB4elQBbWCz0BNu9bxNDBEmYHMsiUWtdvtAIiG2RuRom/E9uyiiyQARRdCS5HRCwJme2Ika1y7D4RoH/Gx57jAbaOBUiFDJEnUU1J1HyBSnbl/EumDN8YOusehsoFPGeioKslHVXM+VVU6nXMlitKXJYJNm4xkvZtYXQZkzmH8w5pnI4p88kZ0l3yWHLNpvWdChD/vtvHXZUQ5Xak5LWrMnIykvj3XR7uKHAcqi9ZFSEU2vFaDg5LgeyoO6bq6D9WVfkzmVL7d5M02R3ZheiU350N/5e9N4GSLDvLA7973xZ75FqZWfvW1V1dvas3Wmqp1ZJogWQQkhAwwwEfwBb2+Ax4DnDGmDm2Z8wx2MwZzIwxYIYBhPARAmGMEBJIQgItSGqpF/Ve3dW1V+W+xP6We+f8/30vMqu6llwiMyMi39cnOrIyI1689+K9e7/7/9///dSfZr5ghKn3nPRw78sZ7J9y4PkCLUejllVYyq19zNbt6IiJkBCcSGAom8NQIQ+lNOZrdVycX8BCvQ6b/ABsq+863JLRXW5asZiV0gJyh6Souh1CGUKScsSeRzGOjjRXHgjN76dZO2LhwwMa/6WisbsDR7ouMkINcmYDjSjQqJPRmQb+x5IFKghQ11fFppGRFJuGJIVBJmjbvSTjaIitMVmOcOiig8e/mcct51woobFUUFhaYdHeqT0NLI0gClnLQqr24UIeg/ksppYquDC/gHorQMax+yp1k1TV2HWNICfWJiBOsTmIPXdSzUhfIB8/mlcfDM3zpBf5gaKF369HoEC0F/9+vbLldZGR9xUEHh22Md0IUVXAPhts/X4xum5UhFBa5z6mSLEq0IrM2uaW8rQirOQVV8c88u0c3vX1HGtBZsoR59HFFrRToXL7RhDAEgK7BwYwlM/j7Ow8Li0uwpESjt1Zs7XtAtnBOw3ND7+Y5gS6Acm3kHqM9AW8OKMxe/XByDgjcocn8N4M8MeBhVs9lxc8zZbEmXUc/ZrJyF2lHP7rLcOwpYbO2UZQF0dLghv7vZfXsX8pUqwaNNlTS/PtAqVlZgYi5BsS3/O3Rdz7iodqTmFyKGKSspUrRbovldao+T6LWY+N70I5l8Grk9NoBgFrSXqdkJDniyQLgWZa3tst4FRmZB4pIekLFK93ED5VMkYav747g9HT8/jq3Cyy1Lk5jFZrunoF1kxGdmdc2NkMzizW271pEH/0TcaD6x5UihQbAVu5Kw2vHiHwtn5WYt8LCUwOhdh/2cH3/00REzM2ExP6vdzGYA3doX4UIYwiTJTL3DvqpYuXUW/5yLlOT6dsTCkpmJCw/XOqUugapCmavsF1tZ400rYgkbEtfOn1c/hK5Q3ZnDVhzWTk01ML+PzFeTx+YBRRrdX+fQSNCw3/RpqR4f79vlJsF6iahbqFkqj0lQcGce62whUC080GTYFcsptTuO/lDN775QKyLYnLFA3R3TEoJ9N0tdXCYD6HO/ftwcnJaVSbzd6utokPjNJz6Sq8S7BSM7LTz0V/YOh6R0E96A4VM/jI6ckNExGsVzPyQ0+exKOnJ1EJlgf9BweL+NfH9+IMEZRrX4Wj69/NFCli0GrY18gvBkxEamUbF48WuNvutx8b4dB9bjFYtQHZRkGZjumBEI8+m8P7P19kgepsOdrWaMiNUPcD5D0Pd+/bgxcuXsZstYqc28OWrSItIe0mkIjYz1ho5m1uMJmi53HdeTtvWVjyffz8C+c6cozrIiNTrQB/cuFKTctfTS3ieycGcUcph4vNa3Y5vS7DSpHiRqBVL/W6yC8ELFAl8zGynD53W5E9P+hRLzsozPnwKuGWEREiHFNDEY6f8fDEV/NYLCrUM6priQjieZt8SDzHxvHd43j+/EX2JMl5bs9pSETctZfcZ0XqPN4VsEONRsFGvWyndvD9gWvO2zRSTGRd/PmlOZxvtDpyoB3t7flbp6fwWw8dg2q0WMl/FdI0TYo1gaIclHKhKEitZOPUPWWcO17EpcM5TB7Kc5de0omQ+Rg1rCPSspVEZK6sMD5r4/s/X+RZnnxDupmIJCCtVysI4TkObts9jm+fu4CGHyDj9paolXRCyhHcp0akZb1dARKRW4GC21BsEJii53HNeZvE8XAsfHpysWPH11Ey8kcXZvELC1WMeg5m/fDq6EgaGUlxc8Q26DkiIQsBpvfn8OzbR/D6XSVcvKWAVs6CV4v474WFoK0V2ErNAK3IqznN5mUf/HyRq2dIrNoLRCSBISQBsp7LlTbPXbjEIldrA103txoiAoIsEGREanjWJaCoyO5Xa9h1uo5moaPTS4rtwcjVn0rjM3u0IKEAACAASURBVM3xZxdr+Oj5mY7tVEevlsUgxP9zahL//r4jmGpVYC9HR8S1DipF94K/Oa1jQqm5M66IO+SuxJX1VBuBgAw1vIpiTQilXr75xBheePMQpvbnuBsokZPC/PYQkARtwWo2wgf/poT9U7YRq/ZgRJoISdMPUM7lMF4u4fT0LIrZTM9ER2QIBDkZG551wQ7tdGjAz1k4+NIihmbqmNmThaWSTtrGbE+/MWKeorvxBs0ICVfL+Qx+8Vuv8ZzfKXScuv7umWn87C0TGHYdLATt6MhISka6C0QqZEIymGhok4PnyITgQUOJ+BkWlCUR8b/l8muwYqARCW0xuHrQWTm9XT0c0ZYyCwraBpbukrhwPIeXHxzC7J4sp2hGzzXM54guqJrQps/Mw89lcf9LGTYz6/UyRvId2TM4gMV6gytuesWDhEhrY1AgyEsmsSm2F6Tdocq2wVMh5koFNG0bUilYWpnxhscaddV4s0xSeLxZMZak6AqMr9wJ+q5obp+u1Hmu7yQ6Tkam/QC//Mol/Mp9hzE3HyTaEbKu79+OXV0KurVlTDaS54RIRNJCIC1+joREGP9snqV5CAmVPKTg5ysISPuwxTVJwrVjKPqKX9GKtnBZ4eWHbJx6Rwa1XRJ+TiK3GGLkfN0MVl2SOaDBc7GgsGfawRNfK6Dhao6S9DoZofRM1nVxZNcIvn3+Ys+ka0i0Whu3ELmpxci2QwOtksDIKz5aM0W8cHAAQtC4o+KHZlJiKfNvW0X8sPhZ8bP5ewQ7iuKlDlmLr1wYyfRr3npc0XaGtCJDeQ8/861TPNd3EpuS1PvouWn886PjKNk2ahHHT3d13znuL4j4Zl9JOphkWDaTjlDaCGz62UYoJQLL5t9FVxGNZSynZZJVTDseorAyBsL/X3OzNxK6NYHsgsKFh1288AGPhYjZWdKK6DgK0l0rJHZ4tTTe/GwW+abA5KDxEul1cLomCFDKZTldc25uHnmuruneA6NrMMgKVMctyM6OiSnWA7pfbWD0hZDt+VslzddPJCyEwm5HP64eLWQcKWEiQiQliuCoEHYUwlERnChc/p2K4teDyYlZKKWRlE3GrtiwtEIfQ3P6uaU6PnKus1ERbBYZudwK8KeX5vDPju7G65UG/WpiMz5npyKJeEhlyAcRDyIWTduFbzlMNHx62A4/U7QjiXAk4Js6TtNQJ1oLW2cURkTEblBqRuPV7/Lwynuz8BYVExOOgnTp2FLJKdx2xsPx0y7miqoviMhKBGGEsXIJM5UqgkjB7uLoCFnA10ckquOSJ78U2wiKihQFSucijD4XcISExhQDfdOoVRL5iOIxjJdBsaGdjKMpREZcIihRwM8uPYch/96KQkNQpEklrxznUmwYuThVw2RkV9bFb79+me09Oo1NISMDjo1Hh0tYXN7hvek1sTHIdohTcwqFyYaTQct20bIdvomDFcQDbdJi3kOrCtNFaHvBniEtEqpqvPy9Gbz2rgyyc4onl25Jx1wLNNj5jsaR8w6yLYGlvOo7y+sgilDIeBgtFXF2dg52t5qhCcCpaVTuttAYksjOpnqR7UaYExh/OkB2TjNBXMu9kYjjKZRiXdXzNUkL0zhXdzwmLiaSojl6QsQkE7bghQE8JigBR1NozDMEx+LnFBsCBRNO0gYmGy181/gg7i3n8dRiraNndbVkZE2NH37m6ATuHi3jldkKHO4ZgT3r3sMdCDpj1lUhSYp41L0M6m4GTdtjAkLkI4oFpUkulnOuXUA6rolYI0Lk4+R3Z/DquzPIT0WwAnQ1ESEQESlVJXbP2Khldd/23gjDCCOFPCYXl1g1fw2/oO2HMh17546k3fG6AUREihcUxr5toiKdvDfaKWIdXdH7LNG9VW0HS5kcv8bmtE6ADD0CHzm/CS/yOYqSiGWjmKCkWBPa8/dSGOGWwQL+p8Pj+ImnXlv917gK/rBaMrLqy+vWQhY/dcsEpiuNhIgQDq32/TsVIo5eEKGgm6XheGhZDkLLYvLRcEwKhqIivDIg8kHCr24lHtcA+4fMK5x7s8dEJDejDBHp8oULDWSVuPfMvimHq2n6FT5HRzIYigmJ1W29awSQWVRYOGhh9pgDbymNimwrOEUjMfZMC/kpxQL0rVCZtlPM0fL3T2TDt100nAx0Fqw1oWhJNmghE/o8vlIEhf4t4ghzmBKT1aA9f7Ndh9J4qdpYy/tXdUV0PE3z2/cdRsGxcalRX+kzkpKR6yBRlJPmo+aayEfdyaLmekxKWJylAYtWBkrF6ZbeBKVmFvdbePm9Gdh13fWpmQQkXHVDgdtPe/wbJfq/K+lwIY/ppSqLEDsdHCFFvlKKnzVLCt54MklUK1c82h3C6V7wgYtvctEqSRQmo7RJ3nZCGPfb0vmI75Nt3RVO30TtBRqNnU1O72TM36E5hZP3G8j7TeSCJkdQaAGYVBOmuCaOrPwluTc/MnTdZr7rRkfJyA/vG8Vbxgfx+nxtJRHJppqRK0EXvxNFfLPUnAyqHpGPLOqux6RExKVvdOP0E4h8TN7lsNiteEn1BBEhNDyFXfM2W79Xs/2nFbkaQRhyMz2qqKE+Nra1sUGaPEtIEBtRJE8KOJbFpcT0TA/Lkkw4ktcSSQkjBT8KWVRL0ZowDJmyFGoC8wcdTN3pILOQEpHtRrMsMfFUgN1P+mgObk1UZLXgaLO+UitHerr5bAnzuRKcMEA+aDE5KbQaHDGh64kqDtMKnSuwb+U/LtZ9fN/+Xfjhi/P4gw5W1XSMjBD5+MUT+9BoBixBWjHPHKAxpFOf08tIhFVU5TKXy6Pi5fhBYlQrJiBe2J+dLmkCj1zBg1cvaERWoulq7J62UKzJvk7RJCCtCBmf5TMeKs3muskICWKJVNiWRDHroZTJMAnJODZc2+ZqHSlN1EOs8KGhaAkREiIvtA0/DLl3TqPpo1Wv4xuPW5jcrTF+mkL11/a4SbE1YE2bYwzPyBGXyvO72QyEFoJunNohYrKQKWA+W+D0TalVQ7HZYHJiR0EaLVnG/pX/oLPXaAX4N8f34o8vzKKpOpMq3TAZee/4ID58eBxZITDs2LjwxiZ5+6//7v6HYBJiqooo+rGUMSSkYXs8iDqsBu//VtvURyTMAn5ewAp6K7RAJbzjc3bflfLeCHQLU2RkPWhRFENrFDwPAwM5lLNZrtJxbct4T8QpGiI9UaiuOXeJOFXj2TYTmKECGedoNAcC6KkQr33Dx+mJAPOliElixk9JyXaA9DuX7nVZL3L7HzewuK93Ju+VxIQKAabzg5jNlVn4SsSk1KxztMT4Ne1oUnJgpdcISUFpnj86WMTPHduN//2l8x35kA2REQqt/sa9h7FnsIBmtYFzDf9a6vsdqRdJauPpQq56OcxmS6hk8sy2SSPiRjvLqYk6rFJkhDus9pDmkEzOsk2JoUULvr1z2AgRhqzjcBqFiINcRdiaGu+RvcRgPofRUgGDuRw8x4ZSmiMcjTU4NuoVKRskKy+qGvMs3P+Kjfte8nB+LMSLB1v49pEWpoYilGqSy65VSkq2DPQ9ZecVzj7iYuB0iIlvBahMUPuI3tJVsela6PPxkG6PxuyZXIBys4qh+hJygWmTH1jGsXqHXWKZmJA8l/yCxoNao4Uf3jfSMTKyIbr3708cwLv3DOPVuQpqkTJCsze+7EcAPLSRz+kV0IWcuAZSXfxCtoDpwiAmC0N8gScWyLKH2rR3CnRlWCEwc5uDxrCE3eqN/W65wGBV4r6XsxwtiHaMn5JgS/iFeh1BqDidcs1XCcFEgx4UAdk7NIhDoyMoZbNMJPwwYmLTqSueCErD01xqPbJk4fhpD4cuudxBeWowwnxJIeNLE8VKScnmgwhiAEQZwXowtwYMvRa2Uze99hWImJjQOE0malUvz9FsqtKh6htaYGbCIHaA7b3j2wA+D+DF5O103JVQ4Wg5j6VWiL+fr274A9ZNRh4aLOJ3HrwFF6tNlgfd4Ev5GQCH1/s5vQDNF7Dm+nbfcjFZHMLl4jDmcmUmJSSioot7R4+NAnCrCvNHHSzts3rGNbOR0dg96+CuVzMIbL2jUgGkFaHmeXUSsV7HjZWiHY5t4fDoCA6OjqCcy7RFp5vVbC9ujYSmo9nzpVy1cMfrGRy56DBRofQNTRNekKZutgRkZNgk7YjAhQddNjUcez5A5Akoq3cn7MQsknriVLwsFrMFjphQZCQX+Gy4toM0JUREvnDFb0jsGyl8754hfOz8LGb9jRVcrOtM0sX13x6+FROeg6mWf7MQ7k/3ux08iZ+obGw2X8b5gTG+aJMyMu5Y2QX7uO1IXDN3W5i9xYZb0z2xciUysm/SxvEzLlpOb+xzJyCYjFBkpIF6y+efE3ADM6WZiIwUC7ht9ziG8nkWmvqmF9WWnKa4kTNHSWo5hcGKxaSxWJd4ba+PalYj10oJyZaACIkPjn5evsfh8mtDSKRJ2fT0oem4mZ9io8mFbBE1L8tEhUqE2e21BxpLbhCXAfzJyk3Qd9qIFEayHsZdGx+/MLuhT1gXGfmxA7vwk8f34rXF2mocGn8OwOC69q6LwSkZbuAUsRbk/MAuTskQPO6VkPbLuBpSmZDu7K0OQCumHtCOUFnvoUsOjp530XJ3FhmhNM18vYHaCjJCvw+V5s6++4YHccv4Ln4dlQBjmzIjCSlpUvrGBm49Z1I3FCGZGYiQb8qUkGwF4pQNuSxP3u3AqWuMvBwgyMq+uW+SaAlFvOezRX6mtE02bPV76mYJwO9c/UsKRCy1AjwyWsar1QZeiM1Oo3VMf2umc4OOjX9z+14sVVurEbVl+7FjLx01XYCksD47MIZTQxPsFeLFLn8pDbk2gpxA6UKE8rkIfqE3blmaxNxAQO6wEtKku+rKoVXEZb/U4ffAyBCOjo2yVoT+LbrAl4HLxy2Ny0Mhdk/b+Ik/L7NjLmlJZGrUuiWgkn1KwXpLGi98MMuVNmxM12eBAzfuKjyXK+G1kT24VBxmouL1b2HCwPX+EGqNy/UWfvXOg/jKW0/g7992J06/+z48MLg2R481XyI/f+se7C3lcbnpr4YBHuonjxEde4V4QQuzuRJOjuzFTL7MFyWlalLc5PxZ1K1XoXwmROT2jtre0p3tt9FLiA2A+TlQilMzh0aHOSpC6RsSp3YDEVkJ+q4oIkJVUD/410WMLFiYHIp27He41WBCQg7LDY0Xvy+LpT0WCpd7x+RwNdCxqRo16aOfL5ZG8OrwHlTdHJcDWyza7qvVy8j1/kBBiSrpxJTG7aUcjuQ9HCjn8Vv3rq2QdtVpmjtKWdxRyuMXbt2NKFAIVpeGeBeAD6xpj7oUgllviJbj4nJpBJdLw7yjXp+5pG4+BNy6Zt1I6AkO6XYzSBBJIX9K1dDPOwlJNU2taUqfokjh8K4R7B8eRIuqZHT3DrdEPOpZjYGqhVvPujg3HmB6IEKu1T8pg64GacQagF+WmDnuYPBUhMKUYp+h/iKFop26aToeFjMFdm/NhS1j7dA/AtccgP8PwOK1/kiEhMaDeqRYRzLbaOH2oRKiKMLfzlZW9QHWPeU8xjPuDR/v2jWATz5yG35k3wgakcZiGK7KdwDAjwN4eI0H3VWg4ZbES64KMZsfwJmBcTYtozCdrTtXsrhToDxjBV8ftTB7qw232t06DHJf3Tvt4NBFlzUJOwVtzUithkqzhUhpHBkbxf6RITT9oKuJSIKEkAwuGWHryX0++5HkG6mGZEsQR0iolH/yHgcjL4UcIaEUbT9GqRxl6krnc0WuusmGPvJBk6tvOt7gaetBB/ClleW9NwJFS5tBhO/ZM4S/nlzExWZwRa+paz3sLzx6+003nJESi0GEJvWXIBa4+hN7Rw+c5OuChltjTiZYGzKdH2AGnOXQnEiJyDpB6vrhkwGXAVLotpsHJhZGOqSW13Eb8i7YqS2DZutn0oSQPmTv0ACLWXUPEJEEpBWZK0cYXrTw/Z8v4Xfeu4ClvEKpLlNztC0A3d/Unbs+IvH0j+bwwH+uITun0BiSPWV+uBpojpIoZAOfG/S9NrQHuysz2FWd5343ZHjZ47PGXQA+sZoX0q1ViyJMNwP84QNHMdm8uYzBplzPzbCoIxaprPHepZffs7a3dA8SIkIi1SQaQuIkCsn1WS5wa0Etx0sSA6dJyBpicZ/d1W3gqfdJI6MQxeWJO4uACtSbLQzm8zg4OszdOlUPEZEEREhmSxEmZm285ysFfOydS+yma0fpfbwVSAhJbUzimR/J4U2/WYNb0fCLvVFRtx543NvGxrnyLiYmexanYVMVGhOSnsXda9lxqrRdDEKUHRu3l5ybvt4m0clqsI4TeCt1Iu/Fs07DrbmYJE4N7UHd8dr9Y9JoyMYROUB2TnMeeeaYg8xi90Yc7AioZRV7jEhFJk474wqgMGsrrpI5MmZuY6qc6Tax6mpBjqzTAyHuOenh9EQWX7mzjrF5O42ObBGIkFD/mrkjNl74UBZ3frQORe0h3P4cVGkOsdhtW2GqMMgk5OD8JSZfFCXp0QjJvWt9gxWLW1cT9NhMfXPPRkVIIR1IC6eG9zCr3QmN7LYSlO4IsgLDLwUcsqWeNd0KOxSoZBXqGcXEZKeA9CLVegtDuRz3mmkGYc8SkQRKgo3QHnsqh90zDiq51JBwK0ELjvxUhPMPunj9cQ+56ajvV3dU+EDVNeRJQhF2SfrDKOjV6Dr1p9mzWRvfTDLyyCZue9NAERHqrvvqyF7UnUw/141vK0jENnAmwsgrIVrF7r0xnVCwxmC2HHHPkx0DpaHyEoVSFlHYH60MiARXs4oFrQ+8mEGdBMlpqHNLQSkzaqz3+jsymL7d4fRNv3mQXAu0oCVPElrgUoWN17uEZNPm9c28DN6+idveFNAFs+Tl2D/Et+x2DXmKTYA0To3ls2FXV9NQVoacVy+OhLB2UGSEPEUKroec7XD/iX4BpWvmixFuP+1h35SdRke2GBQdoQobLTSe/eEcarskR0d3CiFZzOR5oUu28l7k9yIhedtmbXizLoEhADcv0+kSsEYkDLgZ0uuDu2NPkZ5lrr0BDYQekJlTsGuaK2y6EURGyYH10kjIqZod4+RJvUZa9CX1nwU+lWsPVCTueSXDP6fYWhDxyCxoNMsCL34gG3uS7IxWC1Tu27QdnBrazTqSHkzZbFoH/s0iIw9tctSlY+DJJgrQcDycHpww3WVVmBKRLQBpRWhQylQUd/zsVmRbgi3Gpwdj06wdAlrF9mMpM0VHlnIKx0+7XGFTy6SEZKvBgtZphenjDl57VwaZBbUjUmY6biVC882ZwQk2SKOu7j0EqqgpbsbubtbI+h2btN2Ow3TV1bhQHoVvOb0sLuo5EAHxqgreooZyu3fvncjoRk6PB0xMUsOs3gcZ2A0tGXdWinilVvHbAA1O0Zx+u4epHaQf0dzp3aRsLpVGuMVID8HZLCPTzfrq37JJ2+04KD1DpVeUoqGcXkpEtg40qYsIkKHmbpddu58UPQsFXt3rs8aARK0pehtEPnxH48gFlx1Zw75x7e4hUCqwaVjgye/OIMwIuDW9Y8g+EZKZXJlJSY/NPZsSbNgMMlLsjUoa4yUynyvhcnE4tvJNsZWgVZDV0sjMa26i180o1CXOjYU4Mx6iWE/txPsB5B9D3X33TTr8c4qtB+tH5hQWD1o49Z0ZODW9Y6JUljY+3ufLu9BwXLiqZ6LyT2zGRjeDjLyTSN8mbLdjaOtEbA9nBsZYsGqlZGTroY1IUqjuF6+RcDWwNUdHLNU7HYfXAjomS+2cNgcUDck1BQ5ddPi7TbF94HTNoy6mT9hGP7IDyH4yD7VsF2cHxo1RWm/oRx65URff9WIzyMhjm7DNjsLijsMaF0vDiKTk7oppemZrQZGFwmSEy/e6uPCQC2+hu1emtL+lmsTzh1s4OxagXLX6KjpCx0L26E2XrO93xt2QpGrG5ixO1UQ7yEamqyAoQgooG7h4fywe2yGBKlPJ6XNjPZILuL2jH+l4ie9m3H7fuQnb7BiSnjOznKsrsGYkJSJbCwrNFiYVFg7YeP77s/zZVg94y1GJL7mx/v2JJruxWn0yYBIRoQjBfCnC6YnAdLXtgv3aClBp71DFwkBVwnfSVM12gcYEr6JRmbDQGLZMWfkOghsG3Ii16mZZ0NoDR/+OTm+w02RkH4DbOrzNjsJWIVq2g+nCIGyVDj5bipjzFS9GWNpr4akfy7FojappekFFT5P2YMXCs0ebeO5wizvBqn5YTWswAfnWsSbqGY3sDipfDi3Nxz5QsRDcvJdXik0EERDq5jt/yGJjtJ0ESs9QlJ6iI5Qo7YE7sONBh04f8zs7vL2Og1jnTH6A9SKUnkmxNeDKmRAoXFaYutPBkx/Owy/F7os9VMlgIiICn32gxpU1tKLuZUJC+z6yZOHlAz6eOtbCvkl7R+kn6Pjd0KTgIpnqRrYVZDViAXNHbX7eSeXWHLEPAyxkChyxd7u/uuYIgIOd3GCnh9EPdHh7HQVVzFS8HGZzpdhPJMVWgKIetq+Rm1U48zYX3/rxPCJPIDvbe74CRKqIgJAB2n97a5WFrflmb3qPcOOypuBJ+K8erHH5MvVt2WliTurGTBVSKbYXIr4m6Qe+AnfYAC14QtbtLr/kgdXl6Oh838k7kEp639PB7XUcQivM5ge4hXOPqJZ7HkxEmqZ899V3Z/D8h3Js/UyK+V41OKK285SioXTNn7+lymW/pCfpJUJC+0r7TPv+399SxSv7feydspmQ9EXqaQ1QTMokd2hOS7a3D9QSgrRju54LuNX+TjBAuxoUuSfdyGy+3AtmaP9DJzfWya+7q4mIpRQ7rJINL0VIUtHq5kPH/U3I8v3kezJ45b0ZZOYVewn0+kBDIeSRBRtfO9HE599UR7kqe6ZvTVI5Qw6kn7u/jq+faHK0h8zcbEWT885aklLTNjr2NEuzfSDy0RiWKF6IMPJiAL+4cyNVUiuuriENSZcX2t8HYLxTG+vkN/6+Dm6r47BVhJqb5SZFqafIFoDK9ULjH/DqEx5OflcGudmIyUk/rHjMhA6UKxKfeaiGbx9tYWzW7vrIckJERhYs/N3ddda+UNM4GQkmU4LCBDuQpyfeMSkf2XowERmUkD5w9NNNyJBaRey0s7AMmquatsv+I1b3F1l0bN7v5LRwbwe31XGQ3TjZ7qYRkS2CAnLTEU4/5uHke7NMSiy/vxqv0bFkAsFlsZSueflgC+NztpnUuvA4iWd4gSEif3tPHZ98cxWFhuTfpemJFFsNvk8kUJ0wpbz3/U4Nw6+EaA7KHc0KpdYcxV/ycr2wcH5vpzbUKTKSB3CoQ9vqOKhqhtIzFBlJK2g2H4mh2aX7XLz4fVl4i4p1I/044dEET+JH39b4gyeW8PSxJkdIiKCoLjpe2pdSXXI66TMPVw0RaUpu/JcEQ0grondoeCCS/dmhuFtBJf3VMckRkbFnfDzw6zUMvxyiPpIKiRHLCqjYIpQ2O4R3Me7u1K7ZHdrOD8bd/LoSUmlUMnkEls1udyk2D7TSoe6bs8dsPPeDWSYh5BnQz2I0msRpkqdS34+/vYKLIyEefi6L0QULc+XITPbbNJ7QBEvpl9FFi/uvfPzxKp483uTUDEVEEsJEryFCRRbpUguoHcRIBAQfe7QzM1SbD2HcVUNXIMyaUpnCVISRlxRHQiae9qGkQG2X5JRNmiszflh1J4Oql0W5WeVISZdiL4CjAF7d8DF36Pj+5w5tp+MgVkkkpMIhr9TkbDPBFRpVzWW7L34gy6uf/NTOaAtOhKTYMBESEoW+eNDHE1/L4/bXXSYpdU9vuUBSx1EbitI8d9hnbcvUUMhpGqlwReSGvFMaGYWWq5FpkeBna/d1O0Hnop5RiOyd06RtrSCS0CoJvqepuSWdJ6GvJA7a1KZCC8H3fOIfJAOzIKFoKTkvl85FGDwV8s/0nuaA5EoakQ7PV0BJyfMWkZEux08C+JmN7mInyAilZ+7q1nOVCle3DjIyls7PfSiLpT028pPRjirPU7E4dHzWwnwxwh88sYi3PZXDW5/OYWxeYr6o2MNjsyc82g9Kv5RrFiaHQnzmoQaevK3JZGh03vTUuTolQWLchqfR8BQKdZt7tuwU0PlKu/ZeH0xEigIDpyMmFNVxi8kDkQ0mHnHkjxpekvhUBqaKjkr43SWF7Dw9NFfSUcqWxgk/L1AfXh4cUhL4RtB8RfKCwHJYR0K6xy7FD3ULGfnRbj1DYKKuUHc9hMKChx5ogNKjMP1mIlx4wMW5N7vIzu1c4pcYo7UcjS/cV8drewI8+EIGt5922U5+KafQ9DpPSmhzGd+QECJDn7u/xiRkthxhsCKNh8h1xjMrEkxGKIqze6az+9XNoO+ACCJ9J7KbRD7dAm2IgxVoHP/TBpfekq5DW7EfTaw1FTFpEVFMSPihISLzmsgRCD0YcWqKVYEi+VRVQ49Cqw5ldSqR0XHsBvBmAF/eyIY7cXT/cHOOrzNQQjK7TIeZzQMREXJTXdxr46X3GZ0IV87s4HGH5jWa/Cklcnk4xCceq+Cpiw7uOOXh6HmX9SQ0CdYymvujbARkXkamXZRuIOLx1UN1JiFnJwIUaxbG5i3enxvNtRQ1abmKSQyZf+0UOJFAPauwUIzgpGuVN4CuBL8ocPTTPvKXFSq7LY5sULWcFV113QoTKYkcIHLNz+nAu36Qx0hE85ftodSsdfvu/qPtJiMPADiwwW1sGsg8htxWWxzmSsOwmwGKApCJGQ06L34wA7+wc3QiNwMP1cKIW+k8nRsLcWpPgLE5G7edcXHkgstpE2rSRmSACYPUvOKM4udkuKcVPL2GIhj0TKt48sYgIrNYUDg73uKOu6d2B0x+PF8Y35ObkJCVoM+aIcHtDvru6DxND4ScQvOC9KK9GnQ/Fy5F2PN1H37JkAtK0RhNUco0Nht0hpuO080pmgQ/AODHDE1dHzZKRn6+M8exOaA8l0ToPwAAIABJREFUW9O2EVp2L/j89yRoleTWNEdEqMEVrZ5SInIlEn1GuWZa81Mq5Iv31vGN402MzVlMTsgNlVIs/GhJfnZiIzJCZGkWx1LLexKZJj+TIPXCSIiZgYh1HrmmZKt6gbWXqpLO5OJoxNERirb0u25Ex1GlC6MRa0boO0hxJfycwIEvBuwZRFqRVNuxtaBFtG873Kumy3UjmTg68pvr3cBGyMjebnddpS+P6rQp1JWKVzsPIh35aYVL9zk4/ZiL7Gw6Ut0IydmhST/XshBK4NJIiDMTAf+RxK/0cELwKp1EpW0yIo22gXQoIZWhSrTTOxlfsnmZrC0TkPV8E0SCSPB6fleIu171MOf09z1DkSXS7rw+EXA1UYoroRzBrRxGXgoR5ERKRLYBZg6zEEnL9Krp7gjJv9ouMvLTG3jvFkGzvz/lLtOhpvOwW0Zlf/qtHmtESOSWGketDjqeDPMNiXzDvCWpcqHeMHVPXVH10k7TKDrv0ggGr5ocNnru6e1EcM6MB0xG+h2ksyFPmIujAfKN9MK9AhpoFgXGnw1QvBShVUrDndsFcg2necy9WqPTfZgA8A4An1vPnq33CqN45oe7/cwAsYgqxabAW1K4fI+DxYOW6cKbnuoNgQmHMhESMiSjVA1FUehBP1NKIdGMbNYqlcjRqd0+a0fYb6RPwVb+vmANz1JecaO8FCsgzbW46/mAK2PS1Ot2waRmeqiNyb9c7xvXe4n9CIDCej90K6FTQ79NAw3oS/viPHt6kvsCNEFPD0Y4ud9nE7d+JZgkXF0oRHh5v89kLyXSV8IYFkYonY1YxJre39uD5LLUvVOY9HYAB9fzxvWSkXWzn+1AOs50Hpav2TOgustqV9Ok6H2IWNT53OEW6hnNEZp+A1ULkQ/MK/sDnN8VcDToRqAoVOiQS+jO0U0EGcFtHcjEkDxCUmw/eujS+4X1vGk9ZORDAI6s58O2A7K7mwz1LMhdcWmvhdqYZF+RFP0B+ibJQv7sWICnjjVRqvVfdITST3OliKuZiGzdiGCQq2jgGrvyVtZC6IidYVtO7Q0uRuykmqZotg+6rRfrqTH2xwHsWeub1nOZ/dt1vGebINjFjvrTpNNlZ0GWz1TqR+HctKdEf4EGP6qs+fJddUwORn0l7qSiGXLBpd5Bp9kU7sZkK3QlWnkL7/rds3jgU5NY2OXxv6n5Zr+CyActMIiMqLTaeVtBWhEq76V5rId0I4RfWesb1kpGDgO4Za0fsl1QREZ0ZAzPUiFrR0FDMTktpiSv/0CTc74pWMT64sEWSjVr1cZp3Qw6rlxLoJKP8OzRFh/jjYgIRUXmJzK47atzuOez03jLxy/gnb93Fo2ihVrJgez+6oZ1gUp63YrmnjKhl46b2wkqwCCPLJrDeixCuWbbj7WSkf+81g/YTtAXaUdRL7LKroeAaYbFZzVlJH0HGviIhDx5vMleKKSx6HVCQvbljvTwuYd8nBlrcVTkeiAiUhl2MfZ6HY/+0QXMj2ewuMvDI5+4hPf8+mnWUTQLdv9pSLRxXc1PR8hNK+7AnWIbv472HBZBi57Kl5EJ2k+t5Q1rObrjAL5z7fu0faAv0lERPyKZ3lSdBEVFCpcUnKaG7tr+TSk2AooizJYifOahGrvBkr6iZ/UjWsNxcqg2ZvHcxAKEl7thqoXSM1ao8fjvn0Vp1ke9ZLNeZGZvBvd9Zgpv/dgFVIYcqH4bV2Jvm5EXQ1iB6cybYvtA0X1XhRwd6UHe+6/XUj+yFjLy2Pr2Z/tA9dm2iuBGAdS6C4dSXAt+QWLoZIDCRYXaqJXqRvoQFAkha3mqrPmb++oYnrdgRRs3V9tyaA2Zy8PXPvD0M3jHR87BjQQqg9dPtdQGHOx7oYIDz1ewMObx6ygKQhU1REhIP3L8q3OY3ZPpm3QN3cONIYnyuQjjTwVolmQa9dxmcHVbGPRqXH9gLcUua5mh/8n69md7QXYx2aCVJmk6DIqGUF+aw59twq1q1EelCVmng1dfgRznB2oSf3ZPDZ+8pw5vyYIV9lA3Vq0hMllo30fj+W+h6ga462s1vOfXTyHwLCYdV5MJStH4WQsjFxqwA8UEpP03TWWvFnxP4h2/dw5jp+uoDLmbmq5Jtt3MW1gacZkc0YPSRtVBh6M4nUDkmsqig3/T4hQsdd5NsX0wepGI5y/VuzPYP1/tC62fOjKxmte9G8D/sqFd2iYY22yNipdPbeE7DOpXMXA2wuiLIZb2W1g4YPPKmcK76YnufdAUt0SPQOA2W+DYHT6GmwL+ay6Ep+POrV2MmIggDNF45uuIlhYgcwU0ijYOPFfB0OUmXnxkCFoKOK1lkXsrb6M04+Mtf3yRCffVkz1N2PSa0fMNZGohnn37KDL1yEQHO3zdE1GqlxzUBh0MXWzi4HMVHHpmCfteqmD0bAPZaoRG2cbiqMcalsQLRazRpZf2vTZm4cAXfRz5bBO1XVZ6C28zqMFrLmhitLaIyJK9OqhSZ///SFz6Zi9cLRn5PwDc0ZFd22KQ6McNQ9S8LBpOJu3e20GItthNYfyZAFZoyn0pSsJ20tHm2Zan2Fw0NDCtgREJvNOTeL+0sRdCq1taQrUEwtMxIenW7GdCRFSExjNPIqosQuaL/HsqXW0WbRx8dolJxEvfMcRkhIg0jfdTh/J402cmuYKGog/XmgLouqbJf/erNVSHXJy+s4z8YtDRqj0iIvT52UqIt//hOTz8Z5dx/KuzOPzsEqePDn17CUeeXuR0EkVxinMBHwNFdRolG/Wyw6SJyBZbHFxn6BMRUNslkZtVOPHxBrQtUuFqF4DIyFCjgnKzyg1fexinAHzrZru/miN0ALynV88DNyTTEQqtOhYzPeFg31OgAa4+LOHUNY79eRPjT/m4+ICL+YM2GsMSYUmw4yWv1NQKcqJj7YEwP9PASxEVGehUf7KFoNNPgaw6EUuuOTPRwyEBPGwDj9gSJVvoltKiWRfC0jby72wAgUTrWx6skciMIt1EOkkjks2B3IWaLzyDaHEesmCICGIiQdfk7O4M7v/UJGb2ZfHlD+xGphoxUTn09CJu/9Icp3DEDQ4sciT8jIXHP3IOkwdzrB8ZmGp1RNRK98Pc7gzKUz6+/5dewcSpGqdmagPuFZodet3ouQb2vlJFZAne56VhF4ujy+mcmfE8lna5iMoRBHWGbmr2DzHiVIEgB+SnNO7+SB1uVbFuJL0Htxc61jsWWg2o3qqiuRbeD+C/3OxF4tR33nuz17wVwBc3ay+3ArQqCC0Lp4Z2IxIWk5MUHUY8QJJ+xG5oNAckquOSiUprQHJKhzwLlG1MlWhA5chJZAbFMCvQLEvuAkw/EzFxqhoyTK3mNwNUSdIsOViKNAqVEHsdgT1Soiw1qF/vASkxLDUirVFniQglOyFoFrMyEbSjdPNLWdF6MguR1RB5RdL/7QXtoZQsVlW1GpovEhGZg8zmr7lbdB1mKhFff5/9hwdYB3L0Wwu45ckF2L66pp7kalBaZPhCA2dOlPBH//IYvFrUJjXrBX3m/LiJiHzo353E+Os1zOzJrspojTQuTlPFkR7NVW+1kovnb9nL5Kt6SGNptw23prjTNpGOZllg/1d87P/bFiq7rTSa2QXwLQelVg0H5y9xVKTHvxLqSz50s1TNasjIzwH45Y7u2jbAC31cKI9isjCEbOinOstNBkU4nIZ55nJBywzcOk59JjbHIo6QkFiOKnS4382YxOxhBzOHPQR5gcJcAK8R9V8Z5TaAxJmUXlga9VB+ehEPLvr6znvK2NVSwhZJhEOA6HrdxAW0JZRoexhrCaW0lh4g8hD+czaaX8pCLViQAwrC1dsWJaG0jLAshJMX0Xr1JehmAyKXb0dErgW6JolA0CROJMBtKVQHHE51iDW4rA5fbOJr7x3Hp/7JIZSnW8gvBFcIX1cL2geKsJRnfHzwl05i9Fwds7tXR0SuCU0Gdi3UkMfp/B7oTISgrGE34yhkHLGktAwRlzQi0h0gMrJ/4TKG6hW0bKcfDuk7APz9jV6wGs3ITwK4q6O7tQ2gYcFRIZYyhVjImtKRzYS2TN45zJlIB0dFHIqMCENKrPjf8e+EFnBrGsVLEUqngPEXfJz49mUUqi1M7c+jOugiW4sjWiknWTNoYg09CwtjGRQWQpz43DTe9pFz+I47SijeWhStWgRfaPg0EFJjOMEpmzgjIDgsYm4ZbpRBbEXoQMDZF8DZG7B2hAiJXrIMIdmqyDJpQ1wX0stALS3AP/Ma/FOvAFpBZHM3JCJIUjaOuSbDjGStxVob4tFJonTNgRcqTCIoStIoOchWQ9ZrrBaJRmTwcgsf/OWTGLnQxNxGiAjMvRI4NlzZgsppLOQLcOsakpJYVnwv2mnX4m5CYNnIBj4mqnOIpMXzVR/gGwC+eaPDWA0ZodKcA71+LijvRiVSLdtFJZNjYpLOalsIseIh48eK31HEhCYF6vvRKlrYV5nCoVfncOTrS9j7cpXz+pcP5bl6Qer0q1sLuOusJ7mU9e4vzHCflRMfu4DSmwagf/wAGjO+CQLQlyB5taxpjifOTixEaS34H5BM4pmkSEPpVVVClBSc21qw94aALxFecKBbYtNJiXAcow3xAyYhrVdeMPqQTAbCcW9KRFaCSMN6B33BFuqSq25u+eYCi0tfv6eMxREP2Vq4qu3Sd1QfcODWI/zAL51kQers3g0SkRVQUmKgUeXjnCsVYUGZKKVEO1qZojtAZGS8Oodiq8Hygj7BcwA+d6NDWQ0Z+acAdvfD+aD7zQt8LGXyzDjTjr7dBZrmKDy5d3Eaw40lLJUyXBFAJZQnvjTLq8Tzx4u84kyxetAKuFGw8Nh/PY93/P5ZXgXP52xkPrQb7rG80EsRpBSx+aYwnZyETJz+hWUZRhEXxsfUxGLGoqXQCIXQDQm7rOHc0tJiOBLkmKbmLCiKlNB/doeICWlCPEM2VKOB8OJZTsmE05OQrguRyWzLzCpMPgu1souJ12rYdbaBbz82glbOvmmEhCIijaLDfXDe/dunWbMys//GDrHr2EMmJOVmDb7louLlWCCZontARJ8Wy6VWHXsWZ5iU9FFPNaqm+fSNXrAaMvIT62kH3I2IKDoS+lzeO58tmXK3fjiwPkHL9rCrtoCJpRkmJcn0Rz4LlMs/8eVZXD6cx8VbCsgtdbaMsp9B+gdKzbzlTy4idCSqloQz7qH4/gmARcRm0tNCCaIaoLAHV0CZEyzi8xyrQZIMp45DD5K+ByIz2oem1I29NxDOLT6csUjLvBIIBaJFC7oqoSMjGBIrI2XXA71IWhC2A+l5nI7RYYRofgb+hTMIzryGcOoS74rMZrviehCxe+vouSb2v7DEJb9Jee7V+ydibfbcRIaJxxP/7xmc+LtZ7omzGWkTFfsskTDSWB143CojDYt0B0ioSgvkAwuTHLkPZV95vXwVwGdu9ILVkJEfiLv19jxEHK6k8Fdg2+nqoIvQtF1etdGNSFEr+p4SJCZTVCVw6NklnHzTAKrDLrx6lBKSVYDC//tequL2r8yxliGa9pF/27DOPb4L0Zy/rAeJa62FkYowFRFGPpEkxoRYJhAU6hCiXZxtXkvv0g2L6oW1PaxgHwqEczCAPRZCFhSkZ7amfQndkpzO0dQ9tyWgasSDbFjlDESyKqQGYY0GooVZFqYG504juHCG0zEQFCUxotVuAu02pRvHT9Vx69fncf54CZeP5pFbCtsEhP5XL9tYGPew/4UK/sF/eh0nvjLHbq6U7tmMihbBCzKLCUixVcdCtsCr79R7aftBUeGAo8JT7CtCEZI+G9k+c7Oq3NX4jJzt3P5sP+hLJ8a5Z3EaLcvBkpfjaEmKrQWt0kjHQw/6Pgp+HfsXJnlWMyuCK0djCmWTFfbI+QYe+8Nz+NQ/PYzIlab0N8V1wXoRW2L0TB1uI0K1aENkJdx7StBBFI93OvYOFUmOBpoJiTAyVg6asFmYIS7mLwLsoyWMxbHi1zOf0dr8QVVNKkc4SttHfNjHAhHVNXTTgq5YQE1ANaQmMkIXhCxK+C/Po/HUPCQVwTRbUH4LutWEpuco4iiJoChJe6juwu8/3iXSfAxearIY9ZP/7BBeeWAQmWpoFkVxSfD9fzmJBz85CacZYWp/Nq5u2bxj4lSA5SATtnBw/jLbHTRtj+0OJLeq1/GXnGKrQKyfFmPjlTmM1BY4KtyHS6zTN3vBaiIjwwC+t2O71AWgCZAiIpSba7gZdmZNIySbDyIgxP5JlGVrBS8K2O54uL6Eicosp80C6/pGUxwhyVkYf72OyUM5TB7Mc8lviuuDWt3bkcb9n55CYTFEsxbBu72I/PsmoGu8UideQTIQCSETVzptIiTtTIowL+T/k58IcxSjcI2zNyx4Xc7nCPMuDalYPxJHQoRWgpxbtTUYCmuXgj0ewd4Xwj4QwD2uBTJ1VP/sVUSz89BhA5qahNHnOK55cBSkN4ZqOpVcVVMJcdvX5mD7poKFrOYf/ItJPPrxizj29Xl2g6VqMblFAQqOkEgLmdDnMZDGPiYh8UKA7kGaICV0msDZRIh4LiLyQenpPUsziCyrH0zOroWfpYzkjV6wmsjIn23a7m0TaIykC8CNQhydOY+zg2OYy5bYiyS9+ToHzWkxC6GUprQ6CjkEWfAbyAZNOFHEA6GlIs6XUsj4ZiXXKlb/k7GUShsx3xQ0Ge59qcLGWY2CDT3tI/vIEOyih6BSZzJBhqWsuzC2ZojicAh9GRZM9EPFARBplCJC05cgWJfJnEXFDV5jj9M4ehLzGHZME1CKEjtsfSTQlFCWjEmMKdH1F0K4Rwd17u27Re0vJiGGMj3feJEieqQBIdL8lo9f4L44dFYoZVMv2eyySqSls2LV1YHuNxrzdi/NMAmJpGRPi7qTQc3Nou54CG2b988QljSd00lETERsPv+0GKPvIxRvjAr3AZ4H8OrNDmM1ZITYzAsAbu+ns2MIicmfHpi/zGuAuZwhJJbWqQvJOkErKrqhVNwPg6If5WYLOb/JpdXZsAWplNGFCMnPNBBihTLyRkjC81aanrkpuHeQJzHxag25xRAzZQHnQBbeXWWl5sl+05AQWogRUdCxJpWyZ0QlpOEf2tT5xtERwx604qIaKbnXixFB0CuFFIplI7QxRf9M0jhcqEMXCEWypDYeJpo7BPBxUBExMZZQiey9ZV3//IwgVoQ+MLojQhK4koWsyXW7sMvj5+12Ow3j+88QTcX246VmjRcHJHCtux6TE0rl+LbN0U26r434P70H1wM6b4G0+bwTCaEHLY6j/vW/WpWD+2q77/wOgF/Z2P50H7gvh7TbhMQLA0wWB9kCm6Im6a12c9D0RCsqYvm0wrWjiFMveZ8eDQ4Fu1HAgy69js73Rko8uXwjMrbXfWIGdFNQBQxpDMiinCy+V1tpEdmCy0r3vFJF4EmopRC5tw3D3pPR4cWmFJKtwTQZmJEUVcvYcpVYhdYiIRk60kJwdoQ0PiaMImMhiVZCK0VKVm16EBHD0VoxpWEqI+KASFK5xk0UNQyv4aSPIlYqDP1RCyG840Xl3VqQrZerwhrsC/fJNiK7O69ZLYyDjErKuLXm+7fYqrGYvGW5aDouam4GNSfLERS6n+m+pshmKoJdPUgfQmSO5pzh+iITEdXfHeVv2pcGO52MoM1SqV8NsGdpmifSi6VhNGyPJ9E0SvJGmIiGbGtviHDQgyIfGXqEPqdgOEoiZVym2yEII/BzuZKmi05Kh0HHyF1XcxaKcz4ytYgFvHTQ9G8kxS83QL1oc4O18VM1Lo/GDBmT5YhUyGVbVaIdcX2H0nGnPKIp7LIKTXkZy4hDjDpVGY0rvTQy0RSzOY6HJAWrsl0DHDuW6NhULf5RKESsdjV/NG+n12tfazHmSOdEUTSfXgT6jIz0CjTru5anB0qxkuh1oFFhTUnDdjly0qSH7TI5oQmVUn1WrEFJsQyz8DVRKCqtptQMLdjovPW5MoeyKk+v5oWrJSPzAP4UwPdtbL+6EzQI0sRKNxW5FFJKYaowiLl8CYGQfCPuxJvLzBEyrnwxDpWU23ZVgFyriUzg8+qJUi9EPmiCSqIkm9lPgeQKNCFbgYkS9FNjLyIh1A12YSLDxlmPfOIi9pyscSUMNU/75rvHcOZEEQNTPof/r0dIaDtUXkolvYWFADPDLqxBF87BLFQt5PpdMwrGgh6YKgptkiix4wjLOaSMUyVMQ1g9YqSNMiYbsdCV0zmGjRgRiCnI0XzrcDyFXiJMdofCKFS1KyioEmtdqSSH3xZq2BMZiC6NIuxE8H0dhzTpC6XSYCrFV9LoHoiY1Cid47gcRSEik5ATU6GjdixBSSLClLIeXzQVMyKOkOwA/F+rPcTVkhHCv+1XMrISTdvhtM0+rveuYbowwDlTmlyJ8fdz1Q2RjSgut6V5hEKJZL7jRuaZyAc/4tQL/Z0GHNJ9+NZaLqWNgWzNqX8HpSBo4qb0Rb9A2RLNvIW7vjCDt/7RBQxcbrLwlI5z7PU6Dj2ziE/95CGcfGCQqzKuBzI6K876OPz0Inu0qDkf2beOwDlWRDTTipu6JN86FcioOFejY6+R2NFMGa6nY3ErZGwsopfrgaGMVdpKWpgUiMa/SEqIRaxMoeBJKCSbsMfvUCKmNiBHWPdYQdv7s4I8UWRx666tFDcHL05W3O+Umh0IKxisV7hSjkqHaaJNoiaJODYhKHRlUMRZ9rHuhC0kuDJGcPq/1FzEWHWeo8fL+pC+RxXA7632INdyl5Od618C+K5+PoNihaiLVv35uQazfrKQpwelb2hIpUhAL6vLddvnQ8QDBNopF48fgSEdYcD5YFP1okyHXWEGl0R4utWg1AV5NNDjwrECCv1CRjSwOOKy9f33/Z+vchXG1ApbcKq+IILxXb95GvNjGcztyXB32KtB3yW9996/msKelyuY35WBCBSybxmK6wm50kUaN7O2xQhX7BotCAUolKRmvSzt0OZViLM4bUJCKmWmEJFRkiDJ95BIRMmkMFgaOhNX27RzNu3kD22DpyVO8ACqGcLd7yH78CAW/+ACJKWY0rB/12Jl1ISuGBo3KN1NjeNZoB4L1WlBR+TEtx029TKTsln4yFhA2+s+J2ZctPlYKA0z0KywKJjGUxpnG7GZ2Q6J+f08rR1X++K1Ljn+Rb+TkZUwpabgmyu/1MBwbRFVL8fOrVXPiLjo70mOtBtvorYwLSYfOi5usJViokERDnqmECI/Qp9XOnQ8y+8R20o+rgaJAEszAcZO13Hq7jKnbPpCzBr7epDLLAlOa2X7ipJPSstUB8lqvIFbvjmPL9y6D4X54A2pmtARbK5121fnWfwaLQZwbynAu70ENRcYwsG1K0kuxtTXSmWujyQ6oqU0alYok0zhWmrd7t7Lb4yN0VbGQFb2+5UxBdHx7zWrWcVyq8O4QW5i76oT25JKKLL3lVH99DR0K4Jw0zruXkBSTQfEFXIcBVFwQiNsT4TsNJYkWhMmJ5bDWpTAooWO3SYoop3m0V0ZRUmiyVGc7aTxkyJElMYiC4PEtiCJHO+gxCM1EPtPa3nDWsnIMwAu9EuvmtVAr4iUENsdqi9hsLEU1+IbwzRiu2QvTzcROKcaM3xsDUFZSTiSnxPSkUQ1vDBi7YvLj4CZOj0n/gFmwWxSLsEWplzWC5pk971YwVPv2oXIljxRdwpUudIs2GjmLFiBQmk21mdscpmpifg0WXBKpONaWhj6HfU+Ofb1BTzz+C5ugJetRm1CkkRFjn95DvteqqAy4kKfbyBzb5k1I8H5BudVkBTcSvNj7PlOpbYmxsEGq0k5rzSZGhn7hijzfvo1Ew9lzNKuaFwjxHI0Qy+3s2G9CEVEWB5igiHGe978g+4YokThUgj7cIEN2hpfnYM97vW858hOxPLYhDZBQTxGGt2JbkdbiYgQIWGCYtkcOWHvDU7zWO0oChMT7ruoYnv9rRtn1YqIcjuaHPism0uqCOnftJ9cvmv3TdfdteKzJga7eqxn1vm/AfzS9h3j9kGxMNOs0Dha4jf5ouQbh3KkrDA34ceQ68ipJNMyoWmxMk0f30BAe6W5cpozOfXk5/hVbXNL0RZtJuaXRDjo4cYmYjY/h6zz8MKQf6bfUZpFxtdHckPxKgW9d8PQhHzguSXsfamK1+4rY+Rcg0nEekDv8zOSO6zSz6RFIW+OPSeraGUknietRUuxNmUzGpglIEOs2746h6FLzbYPxbVAVTK7ztRx1xem8cUf3ItstdF+FfGCyBI48vQi7FAhChSsUQ/ePSWoWsvQDZ104dWIjT5MT7zYR0THkRHZbjyjV4z1cRyDCYaK0y9xtsYQm+R61onypB0G4f9FRgOrEUdV4vcbhmK67pF6loqlMpJJVOMrcykR6TPw+GOt6D8FzVo9o68wBCVpFRHGCyQ/jpyEsUcHaTKSqASZKyYNkhhXjbVYQZSvP96KpLAr/v2KsZYXdmZBR/tJ0WTSf9D+UjSExlpuvRCno1Lgf1vrKVgPGfkPAH4BQGEnn+9whVmXxWZBdTYLSgSdyU1zxc0Tl8NGcepjZSRjJdq3QnwjrVSjs+GQjuJn1RbVJpoOJhx6WRhmViXm80LLumJ10sugVA3ZZz/ypxdx9kSRtRXlmRYc0o+oa8dDaQ6mKAq9lx7UkIzIh1eL+L0jzyxh9Gwdo2cbGDtTR2na5+1RROSr75vg6pYbVbBsCNqQouQzVmY+rgb9qTrk4P5PTeLk/YO4cEseu840+A9TB3I49o15HH1yHoujHtR0C9lHhuEcLkDPtXhLRm+aJFQMV+DICNt9tBczzBLavWaMEsSUyIjlAV23X0W8wiRaVDsWYvQlWieJHJGQ8Njz1URg2gb0fJ2yNYkJfy/48O4saWdvRkQLAWQhFbL2K9iviL7zKwiKSdUktgEiFlG3vY3iaEkyFkexUDZaYT2QLLqWI8btJeAVnwPoK9IZGK7VAAAgAElEQVRCUqv2WOski7v4ORlvk5RTYumeoo2/BvDkWk/Heu5uGq0+DOCj6bk3eAPLJ9O0MERG+1fkOZkUrBCPJswb7eeVrN0M4CK5QeJQ5LVyp8uEAzEZ6v9BW7DY08Puk1V8z6+9hm+8Z5xTG0vDLhMN6gOCuH5D2WbKpegGRT1ypKFoKeSWAq5Q2XW6ztU5lI5xWhFX61D6Y2ZfFplaiLd/9BxHLZ576wgGLzfZRbOThIRTL2WHmwDuf7HCP98wEqCBZs7G4GQLj3/kLD79jw7yvtJxU+rqnb97lokapbKIHnhvGoC0JZmbJgtHkawi201kjagDMh6wEy8RQxLiVuZ6WZmTEAmT4Ul8WWOJqpBkp7osjo1Fq+aDOKUjlgPs7Sgh+7war1YTTtHVSNh7s8K7bwDVT1yCLKZC1p2E5bHyjQsoEfuZODq8xpgYL/SSNNEKIrIcaV65LSyTEVxfp5Is6oiap+TjhvjH63mTOPWd9673A/8CwHev9807EW9MyyyHEt8AsfLXoh1KTFtXrUB8johEUMRjYczD+VsLmDyY49JWAqVWqC8ICT3L0y2uRqHGZURMyEiM/DuomRylaEg0quWV3wcVjOQqIQtC//LDB/HM46OcRukkaGCcn8hwlQxVwFC319V0bqWIDR0PEaWn3zHK+37fZ6bgNRQqQw5A5OpgDoO/cCtABMqPI2baVK8kEpgkjZj0nlFxXW/i8r4cZtLGNz4xFoFcQSfigVubQV/ElWbLr0kEriI2kI9TOwkVEVHMM5avb9oXOerCf7WG2V98BcKhhnmpkDXFzXGtsRbJ72843qZj7QbxUwB+bT2b2AgZoW6+M5t0QClSrBrsiRJqJhZePeLOqNQLxMxxGnaguSqFiEXoSYS24JQIRRJWI0plQrIUcFTl4//rMbz08BBX8lw1d64LtF+zu7PsH/KB/3ASjZLNEY1VH7sEHzP1nkGspWllLZ7Iw3N1lH5kH0o/vA/+uZY2pbQmJqHa6XBNru7CeJ+JtgYkycAQceDmeCJOtKiYQAgkMtjYfkS2E4Nx3oX5jDFHU+ytxjkbpZYrceKMjY5Li5fzNUn6h4MsIEv4uV95Fc2/n4eVCllTpOhWvAzgtvXu20bi+bMAfhrAr6aXRorthNArKmAKpstoElng7EPSC3+dIMJAdurUF+a7f+N1rno5c6LEPidS3dyW/XqgiZ3EqESiHv34Bd5vShGtJiqSgLbhZyx+JKD9pSiINeIic3dZ60q0nPyIrULoM1gJIkWiRRVJ4wMh2y0QhOSSGUNKjAREJp4hWmDZe1UljfCSVoYx1THdS6TgbjWm4Y0w4XJui9eu7dWJjCVxg02EKdQiyrW0d++AaHxlPu3NliJF9+KDG9mzjcY8/+NqfedTpNgq8KrdMtEPLTdGRBLQBF8ZcjkK8cFfPslVLzN7s5zaWQt5SMDiN1egOuTirR87z23+F0fddW3rjRsH1HwA93gJzuEiwqWA4hbaqDVMJpx5CNmWcamMXJERNLyFQycKOsnXyLgGR8URkdgNTcUREG183JN4CrRKYuOG10RI+u+ZtyplTE5ie9f4o02cpl3aoBX7sEEt+MK7swhnXxaq2r8OyClS9DCod91zG9n9TiRg/0F6BaXYCaAqF6pQIcLwvl99DW/5k4uszVhcYzt4ej8Zk03vy+KBT07i/r+cxMJYpnNnkKd/De/estZZSo3opDiLFR3a8AK0qxaN4ZgSyzn1ttRPx7WRQsTWrEbowS1nhLFOjQtzpdGs6pWyQaBdtcskxgRnpL4iOca0SLZ9SXRyHk0Sh9hSI6KKGhAhUQs+sMl+LylSpFgTTgH42Y2eMuunjkxsdBtLAF7fCX1rUqSgiZLErjRR3va1eQxdamF+PMOiU/olVePgBm6wnFbJWmxMdt9fTeMdv3+Oe8fQ7zrV8E9VQ9h7syh+cI/xQQwV93wxpZGkARGxPi+prWF6IU3SZQUFMb9PohXt0q/YU4RqYkTbAl6yR2usZ03+F3OTJDezUrUq4g448WZjmaxYsTqKfVqNubzM2KwfaT65YBropYQkRYpuwYMA5ja6L50gI4idWe8AcHu3nJ0UKTYLbG7kSNan7H2lihNfnuWKnUu3FLgqhggH+52sLESJUz0kMCVX1Lf/wXm88/fOsmCVqmFkJ9IzMaIZH/kndiH76DDUDNc4y8TlVLGbh7H+MDO/bJeQ66RDnjCWvEK0TRmSqT/p7qV17GpGpiCSgh0i1nzExZGGrJhoCtXxiqT9nohFs/zxRv3Kjq4qYR6xhoW3Ltt5I9WI4OzPieBMHcFrdcjcjnW2TJGim/DTcc+6DaOThhQ/GIdr9qeXSop+R5zzwPyYx6W0D//ZJe6Q+/yjwzh1zwBmd2dYs0LiVLcVcUUOaU4Gplp4x6+dwp1fmOGUj5/trJU9gSIH9p4sdKRhmEfSU0aubITXbpCXUAjEr2KfEBUb7rH+xtAGTbaoy64g/E4pTThEx2Qq5i/GAE3S53MkRnAvHG3M5oU0URqdNLAhWiJ0u8tvbAkfG5nEcRaltchbcG4tovHluRuawqVIkWJL8LFYN9oRdJKM0Ej1KIDXOrzdFCm6Fpy2yUq0shn2MXn8I+dw9+emcf62Ii4fzmN2T4Z1JURGSBtCDzI3I7t38jcRHW44rOshrIkM7MN5rZYi7gZDSlWTaomlptQUz5bGiFUrodoZFKYUkmMcUivNHEOYtv5sQGLqdrUUsfCEMynSVCsRQVGKOAMxFCIP4H4+UrS7z7Q9RowTPBXXqCQYE1flGImsJGN4fUXpDAVwmpF2dmeEzFusiUlTNSlSbBuejgMQHUOnScNZAI8B+FJ6jaTYKUi0HvWyw+6pVHFz5xdncMffznBapjrgcPRj9FyTq29m9xhTs04TEZrPo/kA+TePwDmY19GlZiwAMb6mLFdXsTqV2wJEsfNkzDPAgY42YVGmeyKVtWgtVZJm4XLdmF7oZVNWlqAIUzWcmKsmZbtKJ+pYoeJdkFA6FpkI0yGaVS1ipV137KNGfq706WElhHdrno3c/FN19h9JkSLFluNSHHjoKDbDzvDLAD6QXh8pdhzi0hQSo1Lkg9IwhIEpH8W5AEsjLmpluzPlu9cCN5ezkLmvBIQRVe4KE4AwjXgT/iMoTqMi7p8rlo3YAbmCBWjFGRbzgkjE/u1x99VIGv9XI3rFcsM8fo3kdAyHTTgKQtESDs3EXmeWSfZIwVkc2e6hp3lfudqGgjlSLLvum+20IiGGXXh3l6Br4Q2FwilSpNgUVAE8HD93FJvlrfwJAD+aXgsprgBVmS6F7IGxU0LsLHTNW2yUlnQA3RRwVMSHe1sR7okin2OZqGfjEEwi0TCZEt1uZ0diDtZ/8J/iGAlX5yq0jVLjWhppbFfbPquJ4fvVA8mKJqiIrV/bnq5GuHLlq02+x2Rq+CO0jgW0y8kayjepmkLm/gHuRKybqedIRxFHwkgArRtRmgZLcTUuxZUzZzfjzGxmo4ffB/DAJm4/RS8glipQ+iA83YB9MAf3ziJ0NUwHu06CJnJfIfMdQ7BKLuDzRM0pGh1rWAWrMURcpSvQnspJsGrmfyRyVlasmnCFaYHHQZB4uEg6MpJ1mdkA4irdOFixwkRNy5VFwWZHYrOzZb+z2FVNiMSWJLa1VUk74dgxXkMvBHCPFZF5YADRrN8RQ7sUMWI3u8xDgxB5G+GZOpeJJ19Rih2NKQDHAby4WSehU6W918NFAE8B+KHN/JAUXYakUWszQjTlQ7cUnCN55N+9C+V/vB/ObSXUPzfNIkT2jEixYeh6xNGC0ocmTITB17G9WUIngMS9LClSMdUsnMQREknzuyvjHmjrQmRMV5Rot3eUSaM7U+Srk88x4hJTLwOh4k+NbUV0TFXazricRxIirp9JHF+Xy3tUQqEQV+3IvE3CE938+oKQnpVOlJ0ARdZmAzj7Mxj+V7fCu6OghSuFWogQnm9wpES4Vnq/7kzQPP5mAJc38+i3ourlvwN4K4BPAShsweel2C4Io1uIFgMevOxxD7l3jiJzXxmZO0sQIy7UYgB7l6ezjwyL+l9PwRp1069ro4iFq4VHhtjsLLzU1HFLPLEyMyTFcv99tjKjaITCcuv/OCVC8pDEAY20I8bEnbv1CuMCT0UyiDUixu9dqlh6Kk3fGbM5joqYcIpJCxkuZPYg7k1jXOSlyQrwpxkuJPhD6P9GwmLKhqksWM0H2j1egHM0jyAVsnYGcVQk95Zh3hzdo6WfPIDwXFP4z1TQ+tYCWi9UEE2FkGUbsmCn5dU7A98E8ETci25TsVUluH8H4C4Afw7gxA7+YvsP8YCkahHUQgCRkVztkHloCJkHB2AfyJpU9KwPdb7JK1vncEa4dxRR/8zkG4zBUqwDNFFnJDL3DnCpitYrYxPm5ErE1TBJx12tJREA002XK14SBxHOp6i2qFS0XVlNY10Zb1pjpZ6Dtmk0H0C7JW+7kFdygINjGMpkeGKBa1xsLAXFW4h7SC1ZJJtoV3Xbl375QlG+Eva+rPbuLsP/9hIw5MZ/T7Fe6EAxyXBPlIBAQ82HQs8HQhQsFN4zjtzjowhOVdH82jya31hAcL7BaTdrwOFrLyUlfYk/AvADW3Vgm52mWYkFAL8B4BiAO7fqQ1NsAmiyIA+JesQrciIi9i4X2TcPo/C+CRQ/OIHcA0OQrlREUNRiZJzIaZmbt2ngE5WPnoOaCyCyqZPmhkBRkbkA7tE8Cu+fgK6Z9rsc2qAWeGw8JmLf03glK0yXPKOobRujMptIjNvjdjLcpTf5G0yrmGVxiOAIikjiL2wcYkiIcU9NYiDL3Xh122et7ddqfEhku1PwsgWbECv+l/TESV7hWEJmLN18csEkiKyU0W4EccTJkNr7B6DqkXHIDUh0HgkiK/aeDLL3DyJzTxnOwQLd31BzPsLLLeimMl+5lVr19wn+ReyuumXYSjKCeCj8kzjk88QmC2hTdBLCNF+jahjKLdPgRRqFzB1FFL53HIX370H2nSOw92YgmkqrhRC6FSWTjpmwSCIy7onqH19E7S8mYY156Ve0UQgTdcp/9xiyDw5C04SCdv7DcA6up2kbsBveYFIoy51ouCLG0ATWrnJKJY5JJAREJ7buMV9oC17bjWfaWpDE/j1eMxuz+Lhlnoh5h0Dy44pldTyXcV+9uHLHmM/L5b8ZTYy2d3uUphHByRpkMfVZ3BCEce5tPbsE91AOzrGijhZDJqHkpEuBM11V0Es+a3a8O8vKe+D/Z+894Cw7zjrRf9U5N3bunu4eaYLSaEaycrDkbOPMEpa3YIPXC/tYbIzxLhgTFtaw3jWPzNv33i74LY+wYLAt4yWIxRg54iRZsuWoLGs0mjw90+l233xOfe9X9X1fnTu2bIXp6RlJt6Ctnu6b+t46VV/9v3+YROWysdAaRGKMJ1B7UnFQy/nHK9nhCv/UG4clZ+7PN/uVn6kr+PfEz/6/AfjOM/QahuOxhhYg63lg1Xvny9IFdZQv9fLRUaTb6kinPUybULbaN/nhLokhuADtxC2EAMg7k85W0fncCtbefzgUMsNx6oM8KrW9htpzpkCNjOXTgb8RQnV908ay77p0RRjyELqpkE6ZRBr4IBpO56LFBwfIGCcerdrJCc0U505iophIYPWiGRM8XgVq8dk7SjEgyfAVdTG3c0ilOAKheUd4GwseUpKJr1B8IUx5DpRT1J4/HVoH0L7ScDzp4T1qsJ5h9Y/3Y3p73diJlKjRN84G3zqWilvrURPkrab1sFuyvYqRPWOovzILhUj/kXZonfXuX0Pm27J9h2SixAioHXJMzvLhrd3/g/dvPBMv80weJ7xt/D8D8EYAv+29oc7gaxkOHX5n8j3jtSy0YUw9CfDsyJWzqFw5gfTCOtItJVCXyBcp+Wpm/MncxC1PFKLBskIjTohpA2XY5sePMzPfx+6fLvOvZ8rwLZqVPkaeO410Z52ywx0GJxIuApmioUdTF7ZrthJjE1aV84ZiImz8FMmuClkE31YXJS5GHpgglqrOiq1atGK1UlrwY4lnCNc5pKJd7g8xPcTriimwSyxigm+gkDgT9T3hMa0URiSFlFvKjOc4eKWWl6HaySGR9ZSGIyRbKug91ETrowuY+LHzkK1mECc7pgnBqIAqxBjmazmwkntUxSUTJZu+oIaRF85Q/0gHva+vm95XG+je1UB+rAfKXCC+Bjv/5Bu9ZobjDA5v7f42AJ84ky/ibMA2/xDA3wB4J4A3nwWv5xk5PMQaCpCuJ7KVAgehtHs0BJNVLqoj2Vp2yAj5Smazg6zW0LOsNXKkjW6cfJ4NiWt+3crIeEi9/fll6n5+xaTnVIeFyEYM77hatqhePS7hM5JEJ4gDmBMq3uzOBFv3wB4l9Vw1RWOFuaKk7mQBXBGljSVp0+SOSSKhXDDECEzgkVDM9xVaiBMlr3Rk+BsV7iqVFlK6hsckCkQkK0b0Vmgqjm1JWMQT4BvSeqTlAkG6cvUEenc3YL2qZjitTm2EgqSM9q1LqL9i1r+nRKt9VXYrsSde6kI5YkO7VuZcM7cuMWTriRl54RaMPH/G9Q+0TfehdfTvWzf9rzfR94hJOw9FiRlNWS48/NzOxGjKvvvbZ8OL2WzOyLcaHhb6oMh/rwFw7tnwop62w/Ci44mnnvwYWjC1JBQgtVfMYfz7tmL0u+ZRed4kyufUfOCZ8URUauYGmTOwyi0InlrOG2Kx4XhE+bk3I46OIe7dGFr9/X0mX+iGYme4+Jz68BLqQFz9384BtRwHvGCA10FabiiNJBI/jFBHpWaUokG6O1Z2GD4JM6ohAIsRWxK+efjYAzNEGarhAaxQYqUsFUFOfAFgC3h1gQ+dHAFLnMp9hH6ipQwbnqkHm2p8w21TE/wwOneu8gscEllPefiWSra/Fd7o2gtm4Nb78rkZo1Mm+tIpzBU+PY0XgDUZjGv0kTdzJOMpSpeMMvn1mklTvWws8MWoS4HvFBxflQCbDnkmmzS8S/qrAdxytrygs4319Xlxbf0RAD83VN1s0CCW7nn0wyMf/iu0X86tovbsOsoXjXiom5IdNWPHU5ieIw/P0uEe21Sp5URwroiMRD5km2BXwYdoJxuX0CStHIFL59TQeM8B0/1KI5xkh6jIBgzDfJHyZROwWyrIDrTZJ8QUhqakH1bc0qGEkciv0CphwPgDKrsxQfabsMmH8EwpYBjc00EQ5DKooWRUF/1XKch4uMBRvmpBGmCz+aDPkZaRf5yEGzEBo7EkXb9gImviHzPQubEwXJCNonL5ODq3Lw25SBsxPDoyV0HzlgVUb5w01WsmPP9DqtfwtofgQ8ehR4YsCcxmSX12Q6hAakKmkT/0oJmT/3htxXr3XKo+ZwrZiR6yfS30v94yvb3rgW/iDytBZuz5K2ULUzZMhB2OjRofBvC7AD5ytr2jZysF/d3y9TrhlNwIoH4WvK6nzAjFRysPZDMPgybTZSRbq/DFhic8Vi4dQ+nCOnlI1sskqZWbfL2PrNlj5qAuKwNmFayDILWIKGwoxLFTEBGJlqfQRiifU0bvngbW/uYI7MzQ4GzDhn+/ywalHVXfBgtAAfNSSZ1PTZGAq+4hsUqIolumhWifDZGRoTWMEWZocAoJmw0VxQ2XINLZMYMUVO7dOa5SKNrKi6mqoQh4KNxhuankC14Srkiogdio3holmsTXKWVviAAeSVDeM4r2pxeHRlwbNAKZdaWPxnsOobx7lJLRUkA5/MxiHxgjsu/izY7tvpNk5DLDRK/tOrlz7ZwFdhVDPhrCIybUytA/2iGfxty9e83kRzvROiA/2uXHH00CajNEv57wOAbgUwB+H8Anz9YXebbr4d4nX1sAvEnC9y4+C17X2TX8FtH1hYcL//UXq2+FpOcx6lG+aBTpjqqXP5IdLcGOJ4ZJqtymQd6TjFTmODrWgJJxjs87AwJMo54PQWHhVB2hnhJCCiCWho4kyLs5lv9gn/GtII/EeHXOcJz68E62pQtHUHnWWNg0GLVwJP4hooxxIGeiX4eUANqWUZ93kT+Fxgq3TKS4YASLNNiXQogeST/HhKeDSCyYrqqSXQ6zCSxaq8VQ0TeCKnKMYi3yTz5PayYOc0ycmM7zYNpJ7BGEVhEMWnkgsXonVm+Db0rDzeqUh0dHtlaDMqbx5wfN1E9egLyVKfYpGQD+H8Ht3zfnQsdWGnMBygiZi5b13er1T7GvY8j0KJDfnTcz8WvWljLq59Wp/sIZk69nZNq5b+GY7v42+g+3kO1tIlvoBnVfWIGqNrSAPW9qOB51fAbAH8se2j3b36IzXowYJdt9+3ECwK/J1ysFMfE+JWcF4WVTh7ZcOs6fMuBJpaZig6165cKRsOEnO+oo76iRt2O30+UQ9k6tzKDr75OZvJlRkYdqC21lKCEgWGs8t0rBgZCLZuUsHe0kooImnIesnoT8nliaS7HynsPw7ZnS+bVhIbJRw38Waxkq10wgOafq+/tickYh159ioF3sxxAkgQZwof9hA6fHcdFBTDdRhMTxRkPM4QjG8aFP4hj9sCx3ieatUoKKgasZQGLU8VWaelGlayRAL1z+jrS5J6BO+H/LzRrD1lsUnzySYEyojALG4guzyu4RlPaMonvnCvvXDKfaqQ/yBUkFzQ8dQ+X6SVSumzB0sBNjhhDmitGmrb7nVluFjKKGfh9/8rkTGC6oskhDjRy7yvgDi6G1nIuVkvXKG2Ony1S6aiIYJfoWTna4g/6hDvKDHeSH2+gf7SI/3mV0sGQZOalYRk+emTXpgwD+p3x98Sx4PY97pOZxVAKnOvysS3PLcKwzSPsJkpwDzjM4dKoZ8loWGFCPY3xYvspCwHk9gJcAmDvj7+ZGDy8u6JPwPPLgeuovNDteCkhHurUKr0xJz6lSyfM95krMTk8SoO2RkgzZQoc/AGLNSx7YZXr45FOy0zMt6UYS1gouTfzvPUc1HHCsQB+8hDjLruFG49Dks/Y/TeYqpnNfE+s3Hw3s/OHYuOFP/3aq7J0widoZmA/KnNSoqw57gZVKccCAXRUyhmF2CgAXkYIWLvZ3HP+eJbh8HKZIhy0weBFVKEfVaVVCUMUuUxtlZgUwJfBPSfYjIUWGQ4mNsopQejgjlMlcCxF+DwMhxmngH1xGSOopKtdOsOfIsBDZmEHSrkEfa+8/5K3ijTc8C4cgkmYZBnqB0eKQCtaxQGGh5rXc1JM7+A+XtO4VZjKiz64vPjLjqOUMlvtMoK6nVL5y3FSfPQVkDm41o2yha/qPtJAf7iI72kF2rBucnX17x0uJQ4FSka/0aesOu1eIqH8B4Naz4PU8qZFWW6dbm8+HoU69hzwhZGmG5lgXzbEOGmNdmMk+Lv/0TlSO19GabT3egsSPnoTw+a8qgOdKIN+LhAQ7dnr/ro0dfhEfTS1oNUPDa/tTwNYMFx7nVIL+359S0m01SucrJtlSonSqZOBTS4MyxsG1M7hmV2WZVIgeGNl2fEYJq4CeYwIpNcg3wwmYM1odeCsYgEFYUyk7TTisMn/AsPVVAM1DtIh/orIBJdat/eURr8Ix6c4hKrJhw7/fyz1Unz1F5V2jlK/0wz6eiJw21BXM/RQPMxf3BCMbCPf0o+mZ6mTYjIxIrM3EIyYiGTyjwmyw0YfERI+ywplMuilGovNIiCksr7KsseF2j5Xdy0VvGn4pWhSHezLNVRqHaowSahXhuwaKa97omeCDs70GWs8CQXs4NmD4ds18Bd4vpPW/jmLsddtA+9tBNO6nidOzycCyrYps5QipospIbGJYXJDkPJsonotC1StJRkTqlENGKWimnRvqZMhYUEUmNVTyreg9I6GCzps5efdXt9QzoTA50AltneAK62MpGhlc1/FELZnQ3gnk2NQ81ZAUn577Ocl8+7QIP57yI731Zfed9r/BoyGNiTayEiFPMrRGHLIy0CFgwuMZlzZx8bsvxsTeSTTPacIlDk8QsemIYYuatngDtecJ8dVLhS8FcNHZ6NHownVhcEEpbT+83Nx7bL524MLvGLs2ma/NmdlRSqZTY6ZLSMZKlFSsCbbMngTWcSZb9rBJhth+13OJi3RSDJh+h0tdNxTBR8XlykpPxsmuBTXd1MOO4u68S/AyYQYsOwt9nzcB3VGh1sdOmPZnFo0vpIaFyMYOD0lXrpowqCUG3nAuifSL8DyGBqgYNjiTcfA/RWcytiVzQiWxJmqgIEm+7CEBPUwEaRT7mRWqm5iWxz0TJqEGJM3E6UCmOPVC0BmjRYU0cUKbxorh6gABNXYCA5gzQJQsxEGSqGcDj6DkidmXj6H5oQWk3lhrOO02bHjy+frNR1C5ZhzpjjpoKYsrgxHLOrGkg5x94pSMDWBZL7hotZazjGQVCRQjJ3JzE6phbTZKN0eLXO7keVStD+tjJ3Tt87VtMpIgnR2l8lUTjLy1c5P7CAuPlJzoIjve92gx+UwdX8j7AiUQZRt5QBy9NWCtajExU8GKIeSOzvSm4bke9wO4G8CXANwuhUjvzL6sjR/p3t2rp/cZ5JNMvW+O44Wk1AcqXaDSByYyYG1PB1/6ybtw8d9egHM+dw76Y330xnow+ZOeBiviWfIPAz/bBuASSQ2+SIiwPi97AkDNAxMARgBslDawL19t8VHx/12X7w+R/yIc2lFOHiyn6b4PHl8//I69Rxff8iN7fvI5rz33Of21Gnq9BOj0ifoUNPsuc7r2G7nQ1fCUIAt2TBhRPmE0rDS6t5ARkylZGBi0Z/IZ4jZSSEI9WG6jM2f880TPyauR0UOsqVug40zro8cZFk3VtHM4NmLQWobSzmD0RW41U1s5PqEKDhE7GkkxD7QU4P9IWWpj4H+sQQcppUokdbz8k37SAUgTZ3nGKXwbyFLx/BIZbHmKibV8fFh5oAjwMw8VxT+0uo5WaqawSuFZKJRaAUaULOnIVK6bROufTs706WYAACAASURBVAQl19CvYoOG/7zHU2QPt9C85TimfuYiky/3SZKaNWDZRHt/SBEshyCSQIgwt8S231gGzkh7xMaIBW+MPOLvdB0iTUAaWJ5EUqW3Ci3Gbg7PjQunIkMsxKpZU5qoIdk9GoiyvuCgdk6u2Qet9X2UBdxybrDSNVjr5QuHsy8ceXi9e0OlMr6W0tixbr+WGlOXvaEcrqxTH7kUFLon+P+u+b0BwMMDBcjXARx/Cs+exz3S0bUz+OyM7aN+DGiNEO7613vR2LmOXTdfgNrxGtpb2k+kbfNY45B8fezRX0mQDtel5TMpxcmYFCpVmYjJwETMZEJlgsx0BgqOFZlYfals28z1IiTOwqynGB8hTI4afG2ti1+5/2HcvNLFT/zsq/CD12Rvogcak11TIc8yN/FgENde46iAKqTNoluRrutigymm3xTeZ9Vjctmip2TeL7z5JakJBW8xeqXzasCtHRKUXo0oUBAK5dRSmiuj8b5D6H5xNdjIDwuRDRyGjc7qr56j9Lya894P0Q+MpOUW/i9Ri3aoAMY4M2DVEZpsoXWSU7ip7+xYgpq4hyGu7GHDoAC+JEaYJYKgaPaQ7kEx/g48S7QFSLF0Dk/ihGWiZiiGNzTjVI4T2k6k3FpRYgwWyUZONirlYiDQLfaoevW4qVwxju6XG0jmykN0ZKNGToEs3f7EiZCDVLl+gvqHOqGzJ6HQsiRZOQCRVpRcExakd/UB8CuQ1XLSuLjKqRGwnqxCrAQvV94QzYVJx2shk+/DgkiiXZc7Ru26R2W9CKjtkIFDJEMZlHCbxm6tmnR7jUyakE3JVEfJru3rHvn+H/nIa16xbLP/cOVOnFspp4e7vVrJmHLVodwzmMgMJgwfXrVIqUr5m8oeQbI/5LI3dMXxdE2+VuVnelB9xo+zQtrre7/lNSBpA/tfuoC17eu45KaLMXZoDK35Fpx9wm2bJ/wSZKI05d8HNvTRZQ+or1V9KYH2+es4tpritw928BfrTRw4uBjm8Wv3pK+pj7nz+icSuKr36XAqh4impiRyutB00dRU5hpqRmphFyFdGzm+Gk4B4UOrUkDUSqLwokDhSOF4lbFydRuxFeC7a+Sq5JDk8L1l6t7fROOvj5iQEzL0fNjQ4cnMXrLtXSxd21nOlHGCTllhr7rg+S5h/bw+u2JtllWdmSB5jL2Tbl6sPtlSzHHvJomAuQTVSCOP2zyh0g32Z8KjjTuNbC1BnhUhDAX0/Dc5/ywJGIiifqRbDCh2DQeKcWEweX51IMjEH/H7k4wmqF47ic7nV4Zzb4OHJ4G6JYfGTYew5VljNqlb5G0XusKxtxs7bWJ9RhrYXbjrybpgJbNIJh+XprH5pxYz0VEgPkBY+7gx7OTh9aF5WhmlqTgFAc2A/6+skLkzLqgnZJGkwESh6mhuzumsf9/UqL3i9+458aUPLDTwqedeke0era01+m0cSQ3mnTlSJuDogFvPcJz6SL77u8/cu+jhskoFqIkpp588lQawvqOPhWsXUGmUMHPfdJimeTU/3QXJaRnOEsqdEsZWqliebeILL9qLtdccwB/tbeK//n2OymgJ3WYP9UqGH33FyP+1Y9vIZf2sTlnooes505I6Q0FOkhQvP6WGDWDeKq1DbLVyA9aIXXdQUZhIYA9dGwtNT5M+UGQnhi6NAi1KgQzmI7qM+N95lc9ogpX/vi/kTyQhCO8p93GdvcMvvSd6qF45gZHv3epbNLzJG23c+c/CaUtOlNZqCGLFJ96zQcyAqy74brGdoQWsOLWGs6gvS/hTdvJ7G29pJJcoHooHEZLobGaVQiARAaHmsbxtmYJewI/BxrEFX4k9zzBQD0VzvVCHWCNmI9BUWJOMl9D5SoODHofunRs3/BU/lqL/QDMYzdWeMw1PGDUmBlW5QTKrKoBF3atCPaMdPmOkU8xt40KqZWPrV+cjr0iGGGzTG/M5iOevlb6eCLjCnDCkLyeKzkMlbS3TVEQMRBo3bY3Le31br/dxxaU79n/yS0uf3b+4Rg+Xe7h2dhQ3jwI3zQJfpD4meoSrKA0QSHOwFBqOJz3OnmJEI8ANoyRZDTh2/TI6ky1M3z+JcqOC/kj/KVWQeEy6vl4JB4AvvnAfvvAdD2FhvoPxBDh6oo7m6la8/CXnodls463/Zs/W73vx+L+nbGQyMzUHl/H1KGYO6mSlegLdgjgzVQNAxOqQV2vHBEbi4Bg9FQy4dOp2g+JYbIzmhISzC8l2E1sxqo8wgsaynsYB6fY6NT96HGt/eZhJq8Ox4cMXIGPfuxXly8dNvtKDuG+zhDfyBYNVjJWVV3YEE5Ey5RMFxe5JhUDBYZXP3ykFmmQn4GQ8OcRanh/EMLqxA7QOUgt3o3NHCM6kSIroe6wFRa1PqCSc1kgFgiLEAiPzlJR3wrRahXTISv3cI98eJC/37N61FuINhmMDh3+XU4ve/euoXDmO0rlVTx6OoKxRh72C9y7Yh8h6TeR+6OfrDzuMb5HORCvctghqGI1ViqxmKOwWvWy0AVPw7ePCxWWJ1kPEaLK+VKPIXeD+kzGVkdxsm65f/N7/tXTLpdeuHv+JX2vhr7o5Pnh0BtVqjq/2evgo+li0hB0uwRwZtJ6xtiYbN2yWAWfqq9/nIsTvt4NfpgRU14HaCnDopSfw5X/3VXTnm6gv1sIG/1QZaTdFr9rHHd9/D+59+VFUy8BcE6h5uxCX4G1vu8L89u80YLCAy8/f+kPV2do5/T6F94bFCcH5wSiFnONKQzZIeJsCAi9BmmG9dnoZhxt6RN0qRZVy42FxI5iKGEgg7DkQiZ5jIyqRy5Cs8OJBIc5nTs/iTjq0zpFvyfSPdc3aBw6ZEA+eDi/LjR4+38Mb2pWvmAjKgIB3OEE5PCDunODXstJztyO0S4jyoJAJKhlSNYPUrhwow6xBP39chDZsSOb1fjLOBcM7yJQUED7A4GKHBueYqMwcDyviS6EfOXZJi3YjJM/vmA5rSO/HDASPw1lpI6pEh6dkseAb8i43enlIgrF/npyLncrVEwYeFRmicxs7hMzqjebW33+I3U/L3HIzwcZZuPBsSMcW8KS/j5+zqPI0LEBc9EJRzb3kwANx3Hn0mHg4rLpoZaRt5uDaG/vGCqJ4IMYXzo7i0S0sc04K2pw4GZrCk0Hqdv+8iUeN82aKXmN958++9cVzP/XW83D1HuCCbRbTvQQ3XjJrnr1l1Iw4wnvrGX5mvIP7U4fpjeM2PmNHOjFxBuc1AdUq0OsBef7Nvzc5UN0HLM93cfubvobL/+ISTB4cR2/07Fc1+SleW69g8crDWLyiiW1LvLC6OjAxCUoSwu23L+DSy8ewZWoCtH7itci8ZWpKXBXI6UAWZauGDPGQIBnw7EhVZERE22/+zuTGOCveEcwNkfOCkxux54S/LC0vBEpg1wBVE408iWJQnr978KxKrUlGU6z+2V5k+9tId9aHQXgbPSy7jNaePx3cdd2RDqxJZC3nSDmKLlTsaGm15AgVpLY5igOmKmX9BmKD1Zmk50Z9uGpwLOsULB9kFcCMtrzQ3iANoJZqIy/BRvJSKNQGJopcxPzGONldtABRgF40P4WZntxL/zIF8aNrn9RK2XIflcsnfKYK+g81kcwMU6I3dOQE7+7cvnUJzQ8vmPqr55A90oYa9wvlIxKXw6wR1Re0U6MghUAiUZJj4gfKPrzRW57/gJiZRdouFC79YC2ggIzEhgubNlJQirakAoaSN2ysN4U067mlifGS+efPTf7F//Fue8ef/gFa1uaYnXU4fqJJDd9WTwx25xb3JDk+nWa4LqtgZTjJTmmkIyNn7sn9BOp2gdXVAWvpR7vdPuDYDsLMnhOY+/r0WV+MkNCpJ0s5vtxMsf+uKsJL9u2MFHjkkTIeeGAaxxcP08++NcFPv+76PS+/sb+rt2KQUQprM2mfOMEquVITFyAGs4NuxvuzW1M4RrFO3l/E4f30tMJcG+2uANEVHFF3iOgPkEcUnLUS8d8DXX1tBvCF7B1gmx9ZQPODR8P3w0Jk40dwXB1NUXv+FBQ2C/w/6woFtiX9FAfwYmnTkJE83QGiMuRjNrpnDNA9nAAsJveHUyEUZdE0gmIzf8D7wzoB5Ph7o/ItfZ5ocqPPbgIxndEUKgJ95STNj+1UI8oeJLL5MPdRXFwN6ZwrfCy6WSiK68+fwsrdDe/k89T84M/m4Y3C/CHkTw9w9tX2KrLjHe79CV9JDzFW8BFyTO4hox03Ji9x/4YFfqoXjuV0eAuoIJQQ6QcdnV4NEw7F/FkM0URP7FTwro5/GFzONKDAyvrHIKGDzWBKpXJr37+97SPND3z0C+bTPpHkec8tYWRkG5rNwJNBRoS6A+pk8Chn6eF4giP1rZIzNfz80uc33w7l8mqbNlBqp6Dk7N7s/PI5QcCWzODvZtr4faog/afdKMfLykPaZVSqDt/zPXN437u/kkyVpt5enp2ZXT2ShBaolzXmXNEbtSPTXr5U8iqhiwbcmmDFSafsrxpwFMvQu4j2xWyVpRDMRxciIvE1za7c0tyVzYM9MCXkKuSaEC8i46nx+RBrf3kItp6CYfFhMbLRw7tHVq6bQGn3KPKlnhCHtNehi2tARMKin4RtWv0aTGhtcjQMSyCLwt/xYk08A/i06nsnrkguCvd1sVCIUghicnYCRjvcgIrBctUQDrYqOEfcQwzU9V2LkNBuyVlIrGfY+HdJ8ax1jpbCumBYCMKvbmnEnFZa7aJ81VhobVHLwdSGRNYNHX6dmSz5XCQ0bjqIqZ+/OHBJkDGXCOIHoF09inYEIY6ZW34JLzoU+UxsxhsikYKtsJgJOFFLcVOSlAHn5CN1+nRSbBtZn0gJqyrciZ5L2tLRAh3ROCGouYy1naZDtV4zv/aL1+y5762f+/TBg8u47bbD2Lp1AjvPm8DiiVZgZo0kDue2qyjnBnmewxqDb7eVDce3Hmc+KM88RiHyFBl+WtcIXvaF45bw+2MZPlDPUCODsZQxhiQxqFZLOHp0Bc1Wjve89ziWF9drsyP9l6FbhjUpuZD4xCxUK3aYmlMqdFExaACfGh2h2GYcksSqN4QoNoPKItzZiTDB7wBObET4wCpmI3KuNdEGU0zejfZoPTGBLze/QSUzNTRuPhoSNX2C7LAQOT2Deg6VPaNkRxJvNhWl4kZyCZkQ5GdJEkAxaEtGbuM/q7AcByTMFH4gijBA2zJSLWifz1ppveQSqAeV6kghZGO/kINGXCC9Oqk2YkPGn1fDQxgXJrVxooBRmwkHq4CdysIUXxSUhNjWlWIvQLXCTgU2VHSNvB9Lw6G8fQSVq8aDUVdaG5KqN3zkjIz6dk31k8ep/vJZ9A/1Ckl5TIPWQHDjBOiC5tFQYaUnLH0jyVeIqBjf3kUubJGfZUT15bSdJ2lMFmr4avUxQqawLF/xAjIF34QK2M4vve3colqq4tLz0+8rmb7PfPGG4fj4x/Zi1+4Z9HqsS18ih79BGc+bn8euiToONTto+7Xx6bCpbfIYUs1PcTgBgXfkJki8bqrl+Ptahn0JYc4Z1D0BSy8WMhgfL+GB+zu48/NH0MsNfueXb7zmqutmJrJ1z+BNYVwvXGwJ6WFSrjCn7A1Gokl1j5G8zueKwV5+4agZCbGFWD/8r1om8lnTRjVFcTtN4DQ2nIX5lpmBmSwjO9BG+7OLSGbKw0LkdA1fbNYSpFtrQDeyjr3/WPgvt9bTwBvRzzSSBPXkZz1+kUfcm0jqFU3NYxtXY6PlurRYouOYGr1Hn6lCdjsYBXCS56kZoHmEU7CJPvLOxv2AVHcudZXqhkN+iaQ/U9Slk8I44d+57CUi41T4TzgJnDtSOn8EoIWTO43DsXFDwufan1ky9ZdsgfGZL7krlLfy+ZvQRhRkVueM+MxQ4dJckJkghGSIgQ3ZQVNeUY0JtKsnNDMQoBSZS06Vu0YrcRYMCrPZ3zYBmwIKGS7UUZ4kYpKk12y8qJzSPIBHSqnFSqOLL3zh8Elv358B+MBdx/COi7fhreefi8w4HBW39mFJ8vjHsBg5heH7hOMEjJLBh6s5/r6a44slhzECzsv5QvzGXmKn20epUsX8fBW1Wo6XXTfxRozURnoNv/i6kHLmXaZy50Kue9AlpAoxSvfVFqYiJsLuci4lRjUR4Uzuu1PK/ZbAKGeugEgv+LImTWwNeVVOomm87O0bMNAQUGaRTpVo7b0HTPZIa0haPY3D52qUd9ZQvnTc+PwVUmQgfODEGFoiDbWcBpW7Yf74VTiRWsIpola09MUxygVyaVBkFXwgigwUdkslF3eX+DDSpNHK12o/kYvZjGETHyLtLIlIyyrxKdi3hxdgBxipTjx+w1YWmj+hDmbyK/9N6j3CmUeifi+8z6SAd5Q3c1PeVkMyngZ0aeg5chqG58HNVdD90iran1pE7ZVz8LJqYwW3kygi4917xSlVhSfKW5LiRM3O2GFE/fm4VpZ48WJyhWOXi4exiK1wBBPiE7CHEvd4TM7zP1cxcCEejy3BGNxljOuv58n0ZHXst97+3N0/+Y47Hjl8qIHv/GcWW+fLuOeeBNUqxWbPQreP/9vtx0q9gx/NtuKCdh0d47Bs++gZwnDmPfYYFiOnMKp+8S5ZvGsix82VPLRkLnbpox7CnOMT3VVXzpvjx1O6jw7hnb/cw+7d69f1D08gs0lftvyE9bM2ai5tHpW9KNQOfCwMXqyawg1xsRLIxJoimyZe6WGZt+ziGvaPeFzWDmv06Rb8xQXmiuCp/rFK51bQuW3JNG9ZEHOzYSFyWoZfYNdzVK+bDNbm2YFOAMnU64mPlpHUExNfopaF8Wcn6m5beJ1F8geUDURC/rOaYSffaPeGxCSCIlQWBMVMQXSajaZVknjpWSo6igN27sxU8S4keoJG8bhAAZmIwDzQCICT1ECBs1Akrw0s905tSYxr9FC6dMRH36Nz+3JIvR6iI6dhpAgS38b7D6F8xTiSqYqXnxsK1rrhgGXYvN9KyJEpqllZnxiZ4yRGns5F7lVhxReBr5MorRj4lXoNy9IFoenJpLGCHFIR3AjNkBQ6rF/qTOofP+10e25sLLUvuGLq31Lf3mYs1n/8jQ4HDhh0OiWMjxe68WehhD45fK6zjLv7a3hleRo3diewq19H1Vkcsb0BQu5wPNoYFiNPcviJNWctPuj6+H/XW7iokYSAgqVv8XDq9/GpTx2iXbsuwm2370OpNf/ikS2z21urGciUEo+mk8uMzaWdaQXV/obHssIWtFYtG0DRbkjyzwiqtPCnCMfGVJCseYqCf81alfOIwB8uOGKppE6ZjeFfyVSK/HgXK3/4CF/71WRYjJymQe0M6bkVVJ83A7fWlwa89uCFsJzoaq6mkyQ6LMT2W/R00kKElPNhpJYo2jKk/JGcKxMuQFxs57G5jVBVLUMUKmZgS9iYhAe1zCNyxW5ixaNbW4GyoyhCV2iO+TfWly5G0R4jrme8ZRl2bTOy5cS9yOr1Ji2u6gtm0LljGYUueTg2dPjCcEs5SPtX/+gRzPzCblBZkDFNXDaSnKfAnlGKtagB4xqE2EIUoR9cnCa8rsXPOBlIz9NZE8GTqJExTvNvxFTHSk9aZprVK4OT9vxLzEntZNE3yFaWv2uklGwbGcf91arFwYOEhg8u/YZ1zz/EOSihaXO8v34EH6wu4IKsjh9ozuFFvQkctjl6GKIk32oMi5EnMZzM4PJ4DfccXMfeA4swlfJjHLp4Ae92V3DnlxbR7bRRa03/JJrl8bzMfiDI84BF+kKAdBfRk6A24K14kGkaq0ozA3PQxcUd+jpJgf0iYl7dg5QraGKsd1RdDsShChfdcbhZMpGY5T8/gP6+FkoXDNszp234LsRSHyOvnEN6fgXZkS6jXoJF85TgFTV07bxyMvS6DX/mjrRlUeix4kKtUAYbkWnaqh3gLRffaOYqiyBCbWJzkWTaAb5IRDIkipVU5VUEx5OJagNSREQuJsMkWagsh8G4cGzlA6tyYUKBJWQDx0RFdZBQ1FB5M+GKWeyhevlIIFhnh9oh22c4TsMIZNYKWp9eRO3ZCxh9lW/XdFgCHLFimYOaJ0AxNCBwm/XzDccgp+AsA7ZRJjwIkch8dELfjy5rVlZMF+uMsMAq4TUQ8qSgxklrn6yblLNaxxjTawLz86PJ7//q9S/5iXfefv+dX74Ya42mOXHiOHW733ouVUP6HeETSQ8fdcv4OZfgX5s6Dht6jH3imTuGxcgTHH7tLBuDHaM1vHv/MbzrgYOogrDS7j6uB/Is7EOH+/j1X3lJ8t2vHLs4X2ohzyb7TOMK0apkRIMPlaqhuBxjbJgtEk2FeEVFFoQTpERM352eAkikudpiF5mwRrWawWtSmQfCLnDGpNsraN+xguY/Hg8Lz7AQOY0jMKMtKlePs0bSSVhhwguy06JEmuAkC3AwozP6Ieo0oIIWaIs4d6eqFooGDohsQLWiYkUOSduHoqO8GUTYYiBZnECCX4QJp5oc9ZWAKn2NkFZ8Z0WkF1Y86h1FPFB8+VhSDgXrjLQeVQmm/SkjUl8twLoZStvqqF41jtX71oMcdbgbnKaRGngDxMYHDqNy9QTMVArXyLQVR8Xxp+A2R0IyM1yNG8jWckImtdyZlI9Nq1m2ChZKSMzqiscnw0YGRjjRDlENrjL4Qgo+UL6qBsibLvmH7jpryrUEV+9Kf2bHfP2DY+MXHJyZXcbcnMHoaPkx38ftMFgxOf4kzXFp0+CGVYv9Jh+qbR5lDIuRJzC8yc2OahnVkSr+6MFDeOMXHwpV/lQlRYce3wrXbDOl9TmXVn6kPJNc1DkQdoIEJpMaQPkZ8WQqYe9Wmp+xuYKBml6xET1xCjQqmgdlkqE4auhJ1xpFSaOEF2pvyMacDIAnI9YnxaJx02EuUIbtmdM6XKOP8oV1VJ81RrScRZWsU6NRUxw0GXVgEJvdrouMENJWPURAwOxOBlX0JJmopFe9GfSUqZxlsrGzo2Wy2rCbogFv1FBPe3rKRHThsEtGC2gUL55fpWbeYPC+UQJGdNKzi0ffQAfeqKln8eRCUGTmd8eZ6jUTWL9lIST7mmFcwekZDkimy+g90sLaXx/B1JsvCMVIUYdIvSukEG2oid8Yt5gH5nVo2VitEExEBfW24pjEZS0JbmcE93Xa0wwcFKPBiqSeTMUJLSKIBYbjG+UuOBk4z4Rez+1EJdnzS2957rb/76/vPXh8aZXGRspYWX58B1C//K7bHO/qdfCC8jTmfABIPxsWJN8whsXIYwy9KCaSBNPlEu5eWcfvfnEv/vTQiXDHskmw1vn2ARjEF5X3AAlT01vB0/EDr0d313g/GQG53HqiF1+yCUsVXR5TSJWwp/GqKmPUpTgUDiSdVi1NgCh7k5qmoBhK/i4N3GbQuduKj0jIkwi2IwQzX8H6ew6h95UG0vNqw0LkdA5rwiJeuWoCdr6G7GAber6DoCIDfNGCbywfrTXixCvMPLWUInFwEOGC+NqxfY0zsfTgtk9BMgnPqkGW0ZBMz6mkLhFGO3zSBOT+SzjVJk4i/yWyVVP1SPgvodCWYkbyeoVOIH+X4iiyCRU8RcSMNJiByqSwRfE/6a/0UNoz4r1a0PnSKpL5IZH1dA1/gEnnK2j+4wKqN0yhevUE+odawRBNEbkCE2GsjKCHp1izFBzrgS5PRLtM9FYCxQOYGZi2MTian0fOdE6Yr5ahNAk8oMEmH+IhTtL7/KXR66WoTGa48erxH/ip/3T4Kw/uXexsna1/E2fk2w2/ut+VZ5ja1sLv7dqJ8WoZS50eFvsZ0mFREsawGPkWQ6fZtjRFxVrs7fVwy0oTv/D1Qzi4tI6puRHUEhsm2WMNDz13OzkajQ6q9Qre/tM3zj3n+uQCWnLIXQqLfpj0ILUmxACMKessuYL0JzrMiIvY4twAFBsVxf1D1Q/ykLEAkcB2DJxGlCyi9/FmbTNl9O5ax/rfHoGdeWxocjhOce51XHifa9dNgFr9ounAVacstloA28Lt2kiDjjM9FDmDpaITJwQMiTmKjZLIKYlAekRXeD7Z0CzhhHgSe3ktghXFiKdZLnlYORFuXBQbMIhqBk2TZ1dgF/egyF1S5Zi+A7JhRSjfRs7jAC+Vi2p59hgSaeopVZ49ZdqfXxkWIqd5BNR0pY/Gew+ifMEIknoJeScfoKlpVABLt0Vfrjhb7ClHLxHhqQ5mGkU4jkgnAmk8tLNcEqtSy6j/vDyngr9GY6uVKlfk6iU+ZtQk6Pvb9U2JKq5vXOPEG7fNV/7kwb24d3ExQ989USpqgnetHsWH7m/ijdtn8eqZCewaq+FEpRPBwmfyGBYjjzJ8O+acNMVokuD2VgsfWFvDh9bXsbfXx9R4iqtnZ/E4uzJheFTEnywffKCHrN/DK24Y+9X6+bUL2g/nMGmeW7jEOeNRuzwIEwuhQGR5RzmlJEtFXglFJYF2WPSncoXHhipFmRzvQgW8LXJ7S2q9XWxEIZC+lmD95qPIF3tIz6+Lv8NwnJbhiauLXdRfOovypaPIjjEUnMuiGnKUFXJWoa4aOBXMIPm3BIPkOkecM2IVH4wUYklQLISkBg+hPIgWI4UQRUij+nR8X6dzRjQ1RGrHrYkF1hRazGjCzY6wIpcoevjRAJ4LLfHl1J3CKB4TqDQUe/4F3xbRXS2Sd8kt9cNJvfThBeRHO7DjQyLraRuOkGytovulFaz//VFM/OhOuIeb8IY3cbmyVHzcRRwnUQyTEVHWYJkpstxIG5EPne9L0V/EP4iVqjuS6tgjXtU1xInSNjL1NUg49igtd3f8hZcTXL9lk5laNvFbP//cS//Vz99279FjR3HDFVWNinpcI/DMkeBQp4nfyFbxT6Pj+K3Zbdh9aBrr5NAc74hRyjMLKek7wnQ5HRYj3zj8un2eTfFwq4f/urKE9602sJznmElTbPP22D3CWu+JB/X5Fk2nD4zXE+RrBCO76QAAIABJREFUJ16AzjZj0jIRZZaML1V8D8ck3I130WfVRQG8JkwxmxRa1XOPlE3bBzO7PVHAqr9ITkEDCjO4FQQLCnVrNmYAm1fHK0c23eZJq0tof24pLDDDQuQ0DxfsVVG7dsIHv2g+c1FpRthAcoBMDpsYLVGjLFJtYqLw1Uu0jAganShz2cM93MPFTI3C4AGIBjbRctUrWbgMttICUpOTsJ9YKogsxr+uUE/kzgl5xefLc0EVxbgkPAB2hWVblPBSXdgSyEXkzpginiBMWOc075XNK5RHwq9V1c0sTWtmKO2sw3NHGu9fZ1XNcCqfvkGEZEsFrU+dQP3lWzxx2OSrmW7+FFx4SeRcIqolMSCxJPItI802BC+lgWIj4BokadUmcuikVS08a5G/s82OX/+URZ2wAxMXPhbRbU2mdaBdwXmrvdySC9PQ9ZCgVElx1QWVN81P1269/Fp39Cfe0MLiIlAqAZUKntAB1Y+jroHPdRtY3D+GHffOYvvD08HFu1HOuZh6BgwPPe0sVXCw2x0WIzr8lE4yi3NbFXzR5HhDq4m724RdozM4z3I75snMjzwnVCoWN9w4g7S0Dz/+2kt2Xn/lOfV8iQ0yk7DYW6athmXaRfDQKK4p7pZuAPRw6iel0oZwHIyeVkW7RshcHPMRbenZkCpEvQqYTQNIi/DZk3oKajusvf8QkDmYyjAI73QPJq4Goy7jljOFrihi2U6a51a4F1xfqLt25FtoeyOKwkUqGVbtnEmtgq4pCi5MaHWmdBE7D8aZvkS2NAiQF5EBwv9wBSBnIqlDaKXCoobWDJJgwA+j5AFF05kcK3G9BTN1EP0gow+iUODga9GIQKjXJvO2WjlqV00EPsOQyHqah1+fJkrwDs1rf3sEU2+5ENl6n2tjjwHLgQkakfUNERZciGtNoiuSiVM7ygGNkqOMicCGS3guWsMPI2UnRYQNItyV+Sgz2koL0NdRTKr2qLan83nIr4R+D2i3mq98y49fuqtyzurRcvkEpmeAY0cNDhyoI0nUWuGxR/hzHNC1Dp+eW0c63cX5Ixmef/ccLupZLCWEZVtkpj8dh/eJmVmvoFFK8PqHHh4WIwCnj9abZdRAePjiFfz5VAeXWeC7bD20bHg8uSnhfGhSUsILXrQLd331CC7bkfxcebK6s324h8waF1IbxNBdjQUdip2BtQx8Cgy3iewrlTHo2YCDzdhV1cI3fIwQHV1iIhYS1nXt+EDZtSIKdkXYWIBaZ6vUeO8B0/vq2pC0uhnDL4ZrGapXTSCdr6J/oM0yE0Gb9e03UcsaPNa9qR1jE+KrawuQIEyeULtYadk5UUoV1qgUCUNC6IgmaZobY0hs9OxJoZaD/jdReG4ESj+JZCv6YQXEI+9JfB40bppi00jnIRUBvlzCuCgphgbQSy1DcbPiDpCJnEfxtTfZSh+lPaMoXzKK7pcbwdV2iI6cxuHXkPkKWrccR/WGaZSvn4A71C5WUnYxgGQlQnJ+w9QIYhc9ltnBua+ZeUZah0ajDYR6LUnQpD+TSTIQEUmQaAJbUGnFsER8b0gsARNGVrjxR5krmbHRHC++bmb3b//Z5GceeGAZszM1lCrbsLQ8Due6Rc7jExh+6uapw0dHu7hlroUXtlI8v5fgWX2vwgGWPEbzNCtKfCFSPlHFzI4e3nXt/bjjC81hMeJHrVnB8tQ6PvPSfVjY1sS1FpjOfRr2qQ2/ZpZSYMdO4D//2jJuvbWBmTed82rkPZsnUdMgkjMihTuiFbdC5w6ap6oUU94WtHKmwQfhS0/iuFXjoKllsdkq3ofh77NBTeHkIrYgb2A0X0Xv6+tm7eYhaXWzhj+t+9Ok9xahTiaqE8ie7IQrZAs4IJQeiKu2ETOzqIRRaNuwC6VxjmLWDBUdumCNZyLqYbTlg6ISMCTcEeUfkXihMUkwsDdCwaOPynyVgusEDWVFwfGQcF+J3uUAhEhbjOCgQWyjBy6ALSBBMVMjFY0Z+b0wWwflvwGT98aa4ymq10wGe/jhOP1DyaxrNx3E7OVjZEYS49Yc1EdAqgOjnjkxZoiRA0bvTGhMM40j+vCSLoLiwsTliVBQiuwDgeNceOx4sGQhPKmRGiR6Q9JCbWyJkzREfTYoPIqdVAwmWs033PrR7ON33J3vG6vV8OrvGUWt1kWnkz+pYgTyHPPrZZxICH841sc/Zjle2k1wY9fiksyiTMC6AVqWQgTfU9nF1Xsi1U/U4Eo59v7c3cgbXaA5/gwuRmQdrK6XMXtsDF989sP44nlNbD0ItB1wcAPK0GD2lwDHjgOf/Pgx/PybnvPSq6+dnaNGH0RVMja3ImiMJKrwWTEnJNpARBWNKCQYXtQLq2jn8w7BiXmRUAIUMuABcLMQ+wpB1mn6jDO2moSLsvEX++FW+kh31IZckU0Y/r2uPHsSpd2jyJd7DDRTLAzUCkY+TmUgD6AILobPxDJD0YXAreCqU6BxVwQ5M8Gk8OJWY1+jcev6A5DaVRm1hldTTRPb+4Ejq0WKNB95u3DyiMpw1T8D6ndDkqcjc16rDCEu2mityQZsJGxEnepKWzVi5hfjcKhIjs+XM1SumQjhjrSewdSTp+lsOkuGoCO9rzWw/ldHzPgPbydqtmP6cgS5ogpQKshCUiURSGIrwtVLEIQVyXpRxBtFgRpNAPk5q4e1/aiTuuBkMcaor0NpTxSZer6Q6Xu3g35i6uXOc3/5xy/d88Z3NvbNzAEzMwZrDca0rT21MsEHr072LdYs4T31Pv6hanBF3+IF3QQXZwbjzsA77fefokiJX4NGl2tYK/Vw97+5Fxde0UX1L6vh4PKMK0aUrVxfqSLtWSzuaOD+F+zH8p4l7FoHktGNe67ZWeDOO1O84x017Lqwlr7ttTPvNPXyRHfB999DMBQGiRqxB+8lvhy6y0W/hVr5CPaO2NxUxYMa+kDX73iBa8SZYRvVASFF1EhY8ThkHB/J1jLW3ncwpHCm5w3VM5sy/EfXc6heNgY7miJb7jO6xSpFMPNfD/1ye1M4SPIocDAn1D0bU8mEsCE0E+ENitMCW8gLLMFYg9iQaTfPOC1PZDdIuG9UBNwp6SgqkfVHiNHQssxraitFUxyjOwU/FxWkwlgKDQhDSSjWVkuuiPQU0QYqHiZB46M6vtFH6bwa1W6YMmt/cxjpsBjZlJHMVtC46SDKu0dM5bpJyg62jfEBe0ik1siZk1wQkcIGxeubKYpwo+otRO4cJBSUpFWj0BzH7nGXJiFCUQBHkXkB+4nRY8GHoliU8GN5hbihZicx45PAi54/dT2hf0u1XsWll5xv7rjjCK2srKFa3Zgt1T/3rHfsBvCxhPDJBCglwKtaCX66lWB5pPdNifBn+/CUh62dKpa3r+FDL78XlW05rjhaVFXPqGLEr4elforyegkL5y/jyJ4lHLpkAetTwMgqUO0CboPWJn9htNvA1q05tmwt4S0/8dLp+dn+Je5Yjn5aZftT6dkP+r9L5iiv6OE0q92VeI2qupefaIBLGDYviocH9oKItyRhPDqOgg9XctwseLn3PmvzVeo+sG7W/uoI7JbKUP++SSO0aMZTlHbUiFq5evYr7MAG6GyexFaTRJyBOjgFxOMy1+046LK44AwFizMigOSmi9pNFQdC1VpFjW7RatEVWUoh5wpkpkC/Cwt4eZFy+g05NhHAi0XNSfJ0beHza1bLMjP40Nq1tAF3lzsp6VXhPuYpnvSpBQDfORO97MmkO6oDnIHhOK3Df5S1BOS9R953ENOXjBqMpHDtTIRY/OS6bkUeklQaZK3a/vNtrKIiNBirh8K3l4qCJrqjGZEPa+oBxH9HG4g6laWC0VwwNtkJWU8JjMnCvKuAus0fHhtN/vvBI43Fo0e/Qlu3EiYnB7ycNnDs4ksXCxY4YoCjB2vY8sg4egbojnWRl7696ebZMLx89+JaFfetO9x09T2Y2+YwtgjQxcWLe0YUIzo/troy6iWDr/7L+/H15y4hT4C5VWBbF6CpjXkuP4G99rzbZbnX1dcQnv23TeyoZ6/HSDrVaZaQh7Ds3ERLhwJn566lXC0Uj7zaQ4n9VYpSB6M1vvTmmZjFFPTC8VghR9bZS7K8jaw/JmmZiiWTwKzfdCg4gKY7h+2ZTRl+L13uo3LVuCdYGq+oCdVGJP+TFMme6cYthyC/ElafE2RDPWUKbp8ZsLhWhY34/HMyDWd3GAa+AURjMa4Loq8NF7o2cqpROK97rkgM5UOkMKlAOCIVkegqPzcRdYnBeBqGN0AuDLe3nEQNyawxuSny/wx7nFjh4wrPWwoTiT0IgX5GMoxB+XqO0gU1k85WglrM1IY5qqd9eGfWrRV0v7aG5gcXMP767dR/JDdWeE5krajXC71MhLyihqaY74xmuBAXXWQAqEqn6PEEe4Toz6sqRL6onNCe+L5aDElHyMZnDU6rLkJ+hH4zw+RYefd/fvvLt/76uz6+eNllD2J+Hmg2vXryiUt8H+/ws7RXAu5oG2zZO43ZvZPY8tAURjz/IiUuTNLYszprhi9ELhqpYLHZx+u//giu7Dpc3QU633DZPa2LEQ21OzdNgprsrvU+/qSzijvv7GD69imk3ago25DhJ2GeO0xNVbB9+zisXcb/+LPj+Pznc7z9n+//QdBOm5dHnMvJWFakSWEgmLPm60bhACnnis97Eg4/EBtilLCokL2mihGj7xzBYNmzMsDUlkjtKeXS5nv5xWJLybQ+chztzy5xEN6wENm04Vs0nsuQjJdCiyaEcnB+hnx2hd06FY0NadopNZQhE9J2TKFpLBzHKP7GiTu8+GCSUW+8yOoD+wJD7MmUxyGOeaQyhshNFWaq0Xg+1vui8IwoyAAR4VOPG6aUIPZbApZChhiLJpdEOjf0mMv+JL5X6VT/jpi/FCP5uKcZihnJYqVmjvJFY65y2Zhtfvw40np1iP5t0vBk+ObNR1C7djwcdvITvcLjDkWB60TZHVYpF1VX/DPu80lPkSealUBrDWXSoCQjzWyQ/gLKqCpcrE2siOV5IjM6PKYkRhu2JbHoZ0BpFOZFV4294i0Pm7v/4UPAj/0YI+HWnr5iJIwe4MqE/dcv4tDVi5g4XMXU/gls8YXJ3gmUjEF7vAubnx2on/cRubBWgTfgfeFt9+K+Zg+vqdaQUfubbvu0K0ZC2CmA6STBaGrRyh0+1uzgH9bb+Lv1FvZ3c4w9OIvEYUMLEcgm0e06nHfeKHq9KZw4PoYPf6SNH3vDLtz43K1z1PRmELlLcokj0EjsYK2ZQE8GRmuRAadBMyhDcyKnGcj0gLp0WknpldwoIXIVbq7SnrEm0rd8Dg2ZemIoIzQ/cjykb4avsx/9e1oMauXh1OhzPPJGJvb+xJ0NEl9eXUkF8fLeY0ZUJZbygGzwiVFjhiTOX8EMpXMERYphGYIJhqo8IQwX5sytEGVNkRVCuRHHyuhDIis2r+lciESfBz8/nVhD2IDaKG821MJOCiM9GQkao9HySkthVRj0QMpoENRAhaTpaNSyNV7N4aGI37+iE6Wkb8MyOQNTvW4CzX86gcJedjhO6/CoxHiK7OEW1v7uqJn5hYvQtzBS6RYLFK9pQuWQitlIry7MLxLEzA7GJ4I5JwyPhX+xc5j80AwSmgUkFCuEWACHEj0UQC4SrPiK4OtK06kT30m0vdUTP1Qy9O4P/NXI0ut+qIvt2zPs3x/b3qdnGKDUB8on+LU05zpYPr+DAzccw+jCCC79yA7MPjiD9enWGZ/LvhC5wFaCEukFn78P9zVbqI2Mw9Gjm4Y+bYoRvxFPJgZb0hRNl+Oebh93rnZDEfLpVhcrucOOUoo9lRRu9lRFu48+/CTv9x3q9Rbq9Rq+71+ci/2HD+DKi+pvTreMb+se7nuY2SrT3xJb8jj1EcyZtRoWWSf7hdBMSbrpRYucVfDGRBrgYGqH0LQYhSSnSkhuhkrgHnFYamAVGE8wa/7DAnoPNuHh62EhskkjKDz6GHnVnCcLU3akA5WZWCfZs2xrHR0ojRiXGf+VSItF/T1U6aLCxDDRXNQZ2AiSaLuemUoBb8sNYnxuOJFye0OVCVqk+NMhP5VSSIUnkiuqoqkitmDcEhUbTqwwjAqFgs2lD0IQwRDX176PGq4Nx8fV3MXCm+E/a9gmUPRFjiK6GCokqVBc9B7XPYvglnqmcsUkyhePor+/hWRyaA+/KSNndU3n8yvofrUZPF/6RzpyMMxV38XtP2lVCzc/8uqi14iTuaXTUdVb4qoallqrv6GYdm7jBGTEEZrQRYMqAAzgeEzbDt1s40xmEpd1+nbrdPWq3/z1V2152698YemXf/kA/st/yTA2BqyuAqcoqnl8IwfSNSBtcGFyaE8T9aPHMPvADMZWamFf6db7yEqbT3X1qpn5Vg3Hyz28Zu8j+PLqmvziW4OQT/liRP+wXZUUh/s5/ttSA59qdnFnp4uD/RwVa7A1TbCtlISC5XTvsdVqgn7f4q67lvDAg8s4cayNC6vudejl5b5Nsr5DUtK1XhX1VNhnaodUnSoTsSd0UVhpI5U1BFyHb4M8gu29BeJ24o6WDECfck5Qi2R/77DOp3NV07+/icb/2B+IZkXYx3Cc9pER7EiC2vNnvG26KSLUWe7Ex0aBmK0WGDGVVkim3L6zRaNCEJTgrUDRFzIcMa1VhIT50TrtAss0RhYFx1X/+8QVS7OVueY0MiYUN7HNYtRQk9TZUvw9aMBSREiHwTeC/eONZKf6wAKjQJ8gfiRqzpAiGbgpwQ0zsF19LUaWSPmO0uyncC3JdRRoLh5gypUyo+hPxyHdWaH686awcu+awdTQHn6zhl9jPCdt9U8fwew7LqGklpo8+OpEWlz0ppHeC4sKpZVI6iitrA/xprFxplpZ3wiJK2IcFRvhyEdw1IZ2uFW8ZRiyY9+RCKnxJZdyseOQmG4fGJkoVV95Y+0Ht84s/cZXvtLJ/uxPS/ixN/Rx4gTzBjc7jLd+L3Bg6zKO/+9fwNyhCcwfmMTUsdFQmPjRrfXRL+fspHwa53qQ7y7VkVy1jP9n/iHc+gcpRqo1NNvfHq15yhcjfrEZNQYfb3XxnxpN3N7qYtRazNfKuKIebRI2ZXi+SKVSwvOetzv58Ifvyu+9dz/+479/2bnf9bLpLVjuIM9rxkh/m+epi4dF9TjTtZXVBi4i2Dqv1cjM6imP1DKIopU2BEIP5C0nxoSu4JPnqlzw12lqw4Xd8KRV7ykylPJu3hBUpHLFOCqXjBIt9pSIBxYT+IrSRU8Z46KcQITaPD+4GPWrq8q/LaMTqh1wVnzCZCMH+yoYqSM4YtcEIhPLxgsvdQ9xuyDjDRKW0DVyapYXtw3p57sBwzMuHxC4UeFvsIHo6kQZwP0d0sJbrXPC6yts4XOmDEDgdEeG3Tct5yqB/2SS3cLqta6QOwuOlL0b0ZGcqyjkjb4JbrdbhchaHRJZN2V4ZcpcGZ0vr2Lt74+Y8ddvh9vXF8SNW3p8CThJoIZo3KV6jvbwmgA9YLBDRtY3nhABLVO5mRCVcoX/lOYtD0QD2LJVxkh8OiE4hbikPMls6oDcltcP/7vpEbwXsA/d9jmD1/4ge0t5AcNmFyPh/OE95ia7WNi6gPsvX8DEUhmzhyYxc2QM0wujGFuqIa/lATE5HbwST1bdkdfQP7eDT37/vcgfAOrZmO9FP+Z9n/LFyKg1aBHwo48cw/5+ht2VUlh7+h02htnM4VnXnU4Pd99z0K2sNMMz79lFv2Bm0j3dw4n/vS1xg95wslcRmptHCe9A+1oDQ6R3w+izgxp2W8s5UyqWFI8ISFoDb1nKJrRmAOa3pLKadHuNmrccNR1PWj13GIS32YO6DtVrxmHHE5OvcJCY5hwKC1TOdTaa18UQZlg2U4i2GwkjZupmGjhFzkiEopwZzUkSyQIPDzOK7y923JrdIZYiYn1DkVtii0diu7IohFBTVXF20JAc/xKd8Eys5OFRoWfQGIQY/w+WqvsXEAgggdoixZm+DCsCNJGywymOTwUlRUp0iJtnLOpWM5TOr6N8+RhaH19Eem5liI5s4vBBems3H0X1+imUdtaQLfSLvCHi+cLzRAvXRA5hOatirDD4JVqUOSWR76ShvwWYHOAUp86vIXyPwcJAQOGpaIsAUSskplAckT2p0M08ptzq2/mp8uwv/cLzz/nBN37+oR07jmBmBlha8gj55hcjOmo5YNYZFuzN9/DweQt4JF/AyFqCLUfGseczO1BZqyCrbCxdwRciu0Yq+Nr9Dje98D68dCcwdlvK8O3j6BSlY6PA0jInDz6Vhq4ZW2oV7G/3YHsZJnKHNm12CXLycM7iy19+mE4cXwsFxFi/8QL0t9o2lXKivtGcBScnORudrRAtkp3jE2NiOVo1dDSdtnSMSAVckDEqQKkMxSi+kVdllRgezxNGOF2EZKoUIurXPnA4tAqGpNXNHdTOg2qpcuUkskBcRUTKPGaWQLM7bNEwZygBTsBkEoxr0K00EPCsFrZSkg70ao1IHI14dliWSkpnROag2sP7k2lIynXRkdWv1XJ6ZZF5sLChgH6Ibx5C1phYeGsYmSuS+0Bipyl2IQXB2hQSXxvpI1o0iekDcc1s4yWjrn9GYtUKdQ2YEWCN2n47x8F/Uvj43KbK1VNof3JxSGTdzKFk1v1tNN5/GFO/dLGXPoL6LjrpWvXRdSdBGzyXBgxWY5CBk8gC4dRZjqaGOQkaN6E+h3g/KstKmCmRrZKLfbw5KYFPDgaeLO7IdDOD6mgJ1z+r9kM7zkm++NBDaO3bB+zZA6ytnV3vtf8TenM51m5YxtjBecx9egv2Ta0Cpccf7vfthsp320T4zvvuwcRFLbzBAp99AmBj+tDDBpc9i3Ds2CaRbk5hKJ9iOk0wUSmFd/irq+t46/37cXS5iUrJYu1Mriayni6vdMI/f/FtN7zw5c87Z7tb6iHPDBLrkDlOTE3kDrkIHRkoDNZMhnlbimSwGaun+LninIm4Y1k16iEhIgrCInkOvFmc1OThjpBH8qdSrP7Fw8YvCKE9MwzC27zhWzRLfYy8bBbp+XVkC52IM4iwRCzCRKsbgwN0uVSGkbqo8qpNYihioimUbsoi4bYqPVGlSlHAWhdcPDxwJns1z5vc8axT/okRqDwXcEX4TR4gZzzDchsxoi+S80Eul5ntz6ji4Bqdxwrvv0JuKX4konCOhlW+JElsNAZ0JFZthS5CdxF5aD7hklcdkeSZGEaAfG5K5YoxlC6oIzvcCdlAw7FJw2dgnVNB+zOLqH5ikkZeNWd6e5ts8qcols7c4IPgWIjl0Tr+RUQJtRSFzgQBTUjbiGwFr5eHkKdVTijyLVGy++ce9ByEXj9MXglFSmrI9myaVw0l5fbKD2+ZaL/rti/gnrf+jMXrfghoNM7C5dQLyVLgjq+cwEvKCZ5TrSNfKcFmNrRifVifXx+cRx/9oTnhfz/W8M6qu0eraOYOz//sPTiCdbx4xCJ3T+xkm/7jLWVcsruPatWh9+iKm7Ni+IWjnqXY0qrj1iNt3Lq8gk8uruFDa8timlsBlwCbMQMIY6OER3uvw4nOJpiZqeDVN079dG1+dL7j01eR+Ywz67ssCceMxIQOydwNVUgijMLAr+KMGS8jAAekRdNWT2wdiJeSQCmV14fNjLcOtXwPMGTgLrpQAZXPrVPnM0vGx6l7dvuwENnk4aHUkoWXl8aAu4HzvFX/J1IiBqfvag8EpA4KvGBbk8RCRE55QuPggD31d2LCsyb2O42lCfOLbFLQp0nxBn+6dAOxiiLRFd4Hl8d+8iShxPBnSnXjM3w8FVyOfRyEXx3bLKxDhwSP8DBFarUSYMPrkzqdresdhGQI6F+m3wd9keMijjQ8Td6/wobC/yo31M5Cq7J67aRp3H8IdrK8eSSz4QhorK0nWLvpkKlePh6UfPliX2im0qwL5Hwb1DHqUhZq6lD88rqXsNkeux5EshC37dR/FbHxqX6T0cKYogpLSpCEgvUSSw79bZNCfRbqJI+OZKC80caWOo2/+c03XHzPL37pngsvPIZzzwVGRs7Cjp9U+q3vPYGvbTkB2Boqx6uordQwtlhHda2CpG+Q9NPAJ6k2y0j7NsSmtEf76I70EOLUBoYvRC4eqeJYP8erbr8XX1laD+YajvIn/PenzWaKO+6wuOLKdkBGnmAxs2mj6hnyU138zy2P4DcbB/BQuYN8K7Dr/BLG0+qmrR/eVfXwYYvFRYvRUfqmPbzVyjA5XcXv/up3zNy4e+q6zuEeeraUJTBp4pKQ/Bia1uIRIrbXYpDKdNSEyaU2l4gmYx3RwEGP+arMOiE1RI6BYmr5wBC7nBWd0TXbX3YTZXLHe1j9o/3cx/HJmsNiZFOHD8KrXDaGyrVT3vgpZm1A/sPkUis0DuYJSUNuQC6r8oMCvo5qkWivYbQZIt2ckGNH2mvX53NWvw0aliJ1D+KcZwp31PCUIn3RoogjVm2BtMixlK0rc2nwWzElYXvN6O9epCTFYiemn5n4eIVkGdFLIsDwEJIvicU987iVeKIwjbwHpEYWjg0BPUNgPUP1eVPwBmjkk1crQyLrpg3fWtlSRv+RFlb/+BFs+cWLQRUb4hGi1ssIS0guB1WTBR6H4/XR8LVhBkp5MTc4OQE9IbFhEnTEDdTILH0XaYGaTEpJrwcBfmSbu8yaPM/tcjt1W6ZH7HddP/Izf7Drrjtf+y/p4CteitBpMGfpNPJ/YScDVqiN9UvagFlG2gNKHSD1fotZgsS3oNZqGF2qwuZlzO8bw/lfnwmKnMEHqpRL+NzxVXzPlx7EiVYX5XqKXuvJFWJpqUQolwmtFhcinjtythUknp2MJeBzsws48doF/KsUQYnH06aPzaSqjo4CC8ctfuc3a1hrGNRqA7/0WQFh2ua49ILR769sKc/3DnRhkjTxB1eTm4zb5v4IytQPLrbZGrIITh1wcJJzqAD1LjclAAAgAElEQVSMIuVU2wfp90OP0ao7COYTYTVO1JJBfaGcMaWxEk6892H0Hm6idOHIsBDZ7CHS0up1k6EtkDX6UnSINFtJmJHjo1TmghhEyggRQ1OHqKWN6aNQwYHEiHmkQlJx+QyohGZeny2R2KVaGz1AuNiwUfjoT4hcm5iBBccKwbAoIMJvE/lbAgVWU5gUmShaLqrz1Wa+IieSpxoREqXUOKE/2chBMYUuR4syOxBfEoorUj/BGDMvoX/GrWYoXzQSVE2tT5xgIvfwkti8kRNK51bR/NQiqtdOYPzV86FlVsRhiLO/erUnUl9wuLksawEN8Ynn3jVJ4rvYGM9PnMy52MNTLUBo94iO3AkHifNquG0RnfT8AY/d1PjScVb9AKlfSr2Islzvrr14qmwu+o1fx8H3/rlBfpY4oD7eETDEhNVKZPNwnWXlNZBZQ68GzO0vYXb/InrVgvTq/8LRNMEHT6yilfUxPlpDp/fk9+KgpjGsDAx2tn6cTQWJojUrDf7v1rKv3LiyOxNjfR248EKHPZeU8LnbqqjWCpqwfw+7WQkV60p0fPVN6Fdq5VIZpX7iDT3ycChNwslU7pEXK7oYDYYF3OoVYqwaQDDUTVaitIumOpHaahc4nBc8eo1XcFeIJ2AT3sC5ErUPN9G+ddkks+VhIXIGhpeRejlp+apxuEZPCEJy4JMzHH+czjGGwcIr49hxxkTdlaAV4UaF47sSTzSMVH5nAptUGKDORTMyX59a1XWREYh7ALJW60urCIYRtEYUPU7KD64LVK1gBefTZJAwi2PEUshwtKxbMNKMN+pdIoRsJ9owLV/iZiI+JWLzjUHDy4GXfrIfoBY2Ri0ELTNc2Oc7XFPVayaHRNYzNVIDU0mw/tHjmHzZFtRGLdDVOISIl/HQXo3/4PKCEsJO1SQ+rGKm4ZyYm6Fwi1c7a2n3cV6GFjvBTVIrHmKWFF8YDOWRYeKfvxy9tis3SaeLpFrB//n2513wAz+FT95++3GM1WtPm4LW5sChkQzd+to3tWlcxsXeaKUcTRef7IjSXoV3tSAplzn050wOJdR6Rzv/WtKE//gzWSf51xEIeCWDdjfhilI+g16nj3K1gp9+83ckO3eNzR5caGM9L7tSRnluPC2IIQ6PnuRygiMRKYiyIKysKS/u6oOmobrOSSKpVChqeRZX4swxezwVHVouG4QloTsSsJaUae7vDmHyeBfZ9tqwGDkDw632UX/pFpYzHu/F+kGaG1JgRC5rNLF2rGEM8lZrZUOWMGb24dAHobh8G+2Q86+syr6VoKGEQHWn5NpHzBpIQRGBrnWTlk3cMuVPhcQF1sF9FKkHBsNxNVeYVJ+AgjwidUcsghSwiTwPATW4OEkGCYbGnFw8hJAoExNXI+EbohIidbkSTbM/8Cz1qXLZuPFIYXa0DTs2JLJu6nBAuqUM+0ATX/vEIrVeNY/a/mZUXSks6BuWZS4VTE7KhmKea+Zno02QWmZC5coWUWWOcJzKdoB95YRiZb19OV9uZf9A3g6bj4CeaxeqcecS7+1DIy6nEuN2pmSSQO0r1w1mLhx96QXnlf96/2HXmJs9mf761B/+Haye9FcYIasfa+foeTfPU/wbT/IZ0U3Nn/63bmWt9HEfVXIG3EgShuKwsuIt1qVVcxYMVXg958Y1fPhjhJX1HEnCb9z6WgfjYzXsuGbi2k/U0uodB9ZRqmT+Q0qJ82TynGB7wuqLsnhtbSI4wpskBJWSE9BacJQkgif+6rQDzNSBvcLknnNipcxxJZUS+LaqWzh3BJfdumR/9JYF5ENU5MwM/zlnhNIFI2QqVu1Uw0tR0l4hf1VUgyI+wVu0FWsRKuzbZXFwwsUr1N3uG1J2hb7JXXFul5OTPDsT2u8F6WgAknCMjehrQcQkiDVcIjnXysNGe0trRCZJarUdy2vVBsUmkDJCAoLixF1HZMn8xuhrUP1yUuhsYhRCsFxRqIgEIIlegJFESwLpMJ7TyijZVkP5inHTe3AddnzoyLrpwwKlikXpLw+bv9o1nTcqNTO+3DMuYUs8p809fxhkEpXMd6MkZ5+ryIumn+AuzJSQumFlWvnfp+rcq1gy76pBHebp0iXn/IJNHq5xKGa8r29zsqYCh4rx0jMP46U29/Lw1RzTy63X7Ftt/8Fqo/vZdjcbYPk9nQe/N5VyesqXyzeVGf79m5oEbrvNoF4nvOJlwP6DstNt0nvrCw//fB4ROZsKER3e1ObGGzI8+3qH++6vYHKCofOSqSCtmPLX1479xzpmZ5NaiUppQNuNyYwLUhlyqAnZyi+MOZ/XINwP5oEwmmFEC0MRHRk4YbKTtgY6yVUlfXLtqMs67o/TtjORmpluRq/86/2oEbBcSdj8aTg2dVCP/n/23gRctqs6D/zXPqfmW3e+b9DT0/Ckh+YBSSABAgye8JROe8aYdEL780DbTkwGx24nnxM7/dlObCexHX+x47Q77ZFBgAEzg01sDBgDNiBrQnrzfOehblWds1d/e6+19qlHIwkkg67uq/1Z5r1361adqtpn77X/9Q9w07UgpSbuJQqn4RhUCXhdCqKzR6h7GfSvFYF1pDUjVYNAAhcBEiPJubCidoQ3Ilickv18Enep0ZoSSkeUkJHHZGxCjMglxfxGmyvWRhES7cVtJA38IFYZZZViJm/ZiZiZvGEiFxnKQyOWPFu4pNJgFNiRIEmCLxUJIVUUsT0ZCd82VVbi5VO/sikM8vGt8ZUfDPRm6jhwYgsvfesJ947vO8z5ZgGn65QkVQevMhcLj1CWy/fvtExNEUiSqCShRzrrQq6e+BlrBS/JCjYhNFsyEPucC0Vu1DxyGWeyF9M9JwZosa/p8lg9DeBROvIr285Rk5rf9UN3PG/xyOqfnzyzgXp9h21cX6bh2aJGnt7zf0HMY3oaePgR4OOfbODyK4Frrujj7PmqRfHlHKHwCL7+1prZaYVIGKFAmugChw+V+Oxf52jWCgxDBLxzeNU/vL2579DkXdsbW7iuHmA9jirb6LAaCg3PNHRJBS+uk+J0Rkbv032FqDLvERmm9tLLlCgZT8nsQkKZcgtI8s5ERS+bWXzOpdk6fe1vfY5ufGAVZw520g0+Hl/BEbxFFgdov2Q2eFtweX6ou2ZVYWhCM5vWV01VRzxJk8DEeCYgTnYeCX3QuGbd8b38SBEYzi7KjTNQwjLBEvXItn3R8cAyUdUFk0zTEOmpsaVO5Yg/jshppUHolc2hnpZadYzkqEq54tO1WJ6dzPT0z1LcaDGU3GBNipQUSWaVyansUMt4c7Dl9Kq2gsbPZ32Ixg1di7aH6+66UPOdPzxjdW8TL3/faRpeP0mfftk+zB3b5JhGYA0bsurRWZC0VfXRx0zMQEi9V4UnFGM4KMui3Q1Za1MVBN5H6RhrReyFHE3pnmPHTidZFPrm7DJiiaqMB4QCmyDKmjl1r5v6Nm643wKwHoraS0Il/nfEm/iCd1soBmanGdNTjJ/95b34e1+/iFf9/S08dvzLW5CEs1B47dCaCQesnViIQA+a2z3g1tu28EfvyHD2fLAsCKJzjytumHtud7KRLx9djSICzpxAFnKmzLyg9BJiJuaqelfYYYwsgDegk6Y0IyUKIplaQdZ7X9nI67fihBQoIvpQ/GBpXxtX/9UybnjvGSztaYLGx75nZmgjoXHHtJy+w83kKlRDImLkpCHocMrVoCBjcZbqleRTI+WrOJEq/TSYbMgKocoac2cIeIbhMJSII1XWnA2JDJaXruS7JRmDVHnTJqMVB1ethtOvJd25HZsqsrZai+hfvVYDZPmpEfOrbLyTKpdGyqfQxNemjeX82Yuq3XfyzBxhoqQ/qIWnGV/F/9nywXMEIa9m7c2no0Po+Fb5yo+y5rDVynHHm47h0ZumsDJTo/bqUFRR5m0jd4skVqsQIMYVhNlIZu0YuEXOAq+NKiRzqrSKnsylydhE8dRYlKQAjFqTRG5fFmsan/l45Mu5QB4REnI1R1wjprNL67dljWwuJ7feadcvme8sKPf7/aenKnlcJXS4V6cmS3TaJf7jL+3FW9/TwtUHIZ2GL8MNaoXI4iKS+Vr4+078LxRKIYBw/z7GRKePxfMFVlcGGA49jq0v/4vtYTmVNRoYZi5wODBkH8iosXde2EHPsVgwQPrX3jkVJiofLwAeI+dGT+qp4MS+iUmSfGMn1akrZoTSfeyjO9mZMOjk3OyXuOfNx+OTDZvZlzWxcTwef/j1Irqt1m+awnB5KDYwRFxK+JBqVLlia6jsdbQz4/niXZn0zMaW0h/X0ixtwOkG14C7CGt7NQjTBGBvhE5PqqJjNUPTlA9LCdPAD412iXwT5035Iu6V7O05zfkSqcBmrSt4BM4whIYtHKH69JIKWVSVkiQc32NozzivkId9RvIztuCblHhj6IcUVfHaS4xodDg1xsJzlduMxu2TyCaymKg8Hl/5EdrHG7N1zJ3Ywl1/dALbgUyc2dqnczqItXKW4loFMiFyS9bB+EByztJ/SSqLcKtkZvAuZUyMCQgVrXhKkhP3JnKutARpmclKGA/k8eBVknHw03Z56blWhiWXiPo9j/ZUvfu6n3zpnquvnsXGRt/yIHf3f5rL5kczJ57CeEIcMmilZ6ZL5BMeP/uLe+DoLF7xsm0cPfHlmZ/hvQTnup1sSx8Os+020OsjhiJdeWWGM2cytJuEV//Q3Y0913See25xHY7a7AtPkgwSDKtL8YHXvFVBsskyR6oQO1RppjAPQiP7ldLdkbOtht1hZAIYu0TtIsLP1+aa9MI3HsXBz67gwsH2mCfyTA0SFU3naxdQ29/A8MQ26wooqlo/ukOT2j/KH01tpd+31BFsUf1CaRbqv/hMaj2RWhZxmdAWRhIAswWkSwa05unCiiBOah51HHFiy54ktFoYxVvVmxRHXxvGy1V1pf4Sq9EImW9wmarteI+ki1OTKvs0QsajmJjpHcPesKHkSazwzcjvKTM8UnV9uj4T5phhYAyadEh3Xrk6QP2GLtWvm0D/M+vI5i+d0+1OGmE6rOxp4pb3n8Gjz53jI7dPY+b01mi9yiMTnQ2pc2ofYx4zXsr7dC8Qkp4rgoikMZMj3b3KhYRNaZPyOpDigZmt155mYCjkm806Zg43XlU4/8lBvxzm9eLSQNdG43ue4njSpmgoSCanC2xvO/zML+3FnvmTeMGdBR56VK/h76hlI1+kmIrt9D5bKEj27wcefBD49F8P4IsiBiMtHO68urOvs7BxukQtNi89s8oejZQdyhLnkNZ41qgYa/mnFzEyITv1cEoGrUj/p6VI5aitaSEupqPS+lwD+x9axx3vOBlPGuPxDI4gF5zI0XjuFHhYSl0aLae9MTY0YMMCzUfonkltEpNqlEthcaa+KmiNoGqbv7ExvBSoLtUXrJA2p1eseBX6ETn9F296L6uJSbkjZIFllmhAMGKKlVVsNba+F2v8xNXfJcd3p+RUQdmdEVYrbon9PWmUneW+X6wnJmhYmrfMkmR9ICRX0UFHvkA6xUl7KWmEhoxsss6N26do++MrVbtpPL7iowgo7uoQd7/5GJ28votBO0N925uM3JIVddJqNIZPceiyfHpNhzZFmt010gL0EnunNHAtUqmae2qulvp7VBW6Nq+SIIeCqjK00x88ceq7twb9XwBwshj6LxutYScNK8iejoLoi2JohXyruZkC58oc/+YX9+Kn/9k5PPfmIU6cshCtv5tPJRQkoQ2yk4uRcG0zM8CZM8DP/XyO9XWKfcm84XDk7Olv29N/Tt6sNeCHnqyxnWyZEnRtQWJKMOVkeZxuAowWmmxEV+CiHovj6jCbCI26EGeEQd3hzrefQGdliAuXt8ek1WdqaChegP/r10+gWBnKXi3xsbIrOhjhOG66zs78WiAIisJV20Za4WQeXsnBg6qQPGbbwU2v4pMfiYSnG8VDM3hhC7GXWonVeYSq3ILE9zDoRA3ZeGRqsiLlqGxhk+e2t759RcdNcFC0nkqooN4HMSDSmi0jL2C0GVMERza3qW2s8x+6mD6SgN1ohWYHOQKl47DF5RChWC3QeO4k8gNN8FYJal0aqoidNsL3ubbQwBWfXcEd7zqFj37r5aif2orfV6Zh57pICmNKcpwMxoAlMI027MCVpw60PoWGMepUjoqwqtb1kp9gn02167LV1XbcDJ31fm9IaJV7XvNPX3z9H/ynT5w8+th5dKe/cnElz+QIbbHhsEQfT82g7IumiweEZO98gbMXcvzIT+7HT/3YeXzL1/b+Tkit4feDyVoIGAqeJs+02doTjXCdk5PA9746xyMPZ3DZIF7vD//kS6+98oXdw5uLBWr1oFQvHKnzaYxXT3W16sq8nSE1soPTakvVeViNEqz7rn38kSOdnGnTuU7ybhwzL+1r4ZpPLOE5H7tAq3ua40LkmRws0bfNF80BnRp4uYj7vMsSyKCS2Yq0mhQCnE55MtQTXRL9q/ckmTMjElnrzCRv9jBfXJxEThrY3qh7SJTPiupaLbrGp2Ay/aNeBCfJi05Fm77xcaa3TexRlkRqVylgkkqGRE5c1dXVaxsoyEnBo3uPFzuRZK8qnA9Besi2Gnmw0ccDqUC8J/iiqgSW3uO0YForULumw83nz9DGW84gvzwboyPP0AhzZXOqjtvecxoP3T2HjekGOst9jfKy0AK2tPLE6NYWZBQCk7NWZijAffIITKp51RxK2a+BXsmN0s6KQqGS4oT0tmBLThChFwcfEqLu1ARm7uj8WN7Cpzzz4khozu4eo1L/pzC+JO1aURL2zBdYXM7xb//DHnh/Dt/y1T0cfRoISVhkQr5LIMb+/u/X0O8TQl7OTh3hWs+fJzz4YB4l0OUwR15zmDqY/3B3tnVoZTnC4rIIC/dFckN8hRgLuwoGlegsj78Vk//FAjwGVUrFzpKGqr30mJCq90JCD+3uCDh1v1Wjeq/gu996PD66qLsxV+QZHEZcbdwyBb80kO9fb9roym4N6Xi8imVG7Kq4UTkKi/yDnWXIUcpqgQEVLNYZciBUJEU7MXxRBUuqBpbogPBMzltwXYq4SbC1teVTBJ/2HUNRU2reaYxnF+WBJTiS2vWxJeiotiUBfrFIZ3GMj8V2pvWOJ+1cev0ExDLHjyiSeTRVwY3QRaQTKjeZZvNpyzNaGFcxrSM6ehhEYjZsjngICqqnzfeeFyJrdglg7TtwhInTm6xh9uQWbn/Xabzv+67l1mohnnbmyMOW3kVIzCn72g1988LQJkvATkW30wxG9ly1XYLVe5zfSbtlZ8MUxaiz3dAXeA4O2HmW+1Zjyp08fuprSjfcD2BxY207OiZfOuOpvdcvWUhfassmy2r42Z+fiezib355H0dOPjVjtPBtXn458Du/m+M3/mvr7060/GUec3OMsizQbNTwo//kHnT21+49cXadZjszRVGG1AI7Y9oxV3s0KfOMKz2j4iCB5W9MkLRdiBcTh0h0b1o2BdWhfBJTw0ceYYA252v8wjccp4OfXR2TVp/pEbbUtSHaX72AbF/Dlye3SJa5BBHTiEO6IQBaKRihTrnP4Q7jaiH1RuRQMgVrDofxJy5qqxgpRXQIumvHJ3cVc5Yr1FvROud06oaQW6qUxRoaRZkajalZLI9UPYJ9ZOrhzaJEQKqfLYwnqonUns8gUSGfOLs5tB9k2pzYfNE+k7P6SD5RReoDI8UlDo7ZrbK+Y6RShFIlKIdbL2yWYN+5NKTadRNcv26CBvevI5sbc66eqRHbNfMN3Pr+M3jsuTM4ctssZk9vyyFvxIqalTMUJ5NDRV/ikUJ4RLIY/zlLZFdZQE3jJQxXs25VWYFCJbqMJ8VWleAQBD1liCypd+uN1/yLF9/0Oz//V5955MEzmJxu7Xwy5N/BcJnD+dMFfPmlB+Y9JVcfUdl4DNeH+OX7rkL7sgt4ybWLOHH2SytGQvGydy9w/Djwh39YA2VDTE3xs+I7C1lJm5sFmjVg/vDCXTzn960v9VEj+AH7XKkbJHJ1lp6/lujyDKRiA7bDo90ldtP4oPeVfKe49Ar8bKs9J/6f3CaOKC+Z1+abvP/hdbozklYbz+yHNB7xVO0CcfWOSFx1qJQxljlHMF9yEYlo+Um2vaaz2ciZD7ZwsoWwxG7dSBaut2eWxrjF5Y5s6eySWRlHGmlyRdMFWegnLM7xtvoaLuF9Oham86jCNYntwibd5REqi7FYnabohgstRVmklVPsYMbWVoDZjXgSPYpTyyXTEDMlwsZndQn1kWdOETSi/YmqTu13yo+1jJJSyonQx8TIw9Jne2vUuH0K/U+sjomsz/AogmM0D3HPfcfp1HWT3G9lqG0XnMhFFJN1STvVcRJZj1C7gU6ozYn95CVcT3vpTJY/GevaML/CtA9Jtk7wF9OL612jcnNd6DOthsJxoAh633adOlc2/7esyR/03p/zni+NCcRP/X0+ZYvBwJOY7hagLvCLb7wSja9fwVe9qMTi6hd/Le0OsLkJ/My/q2N1BejO+NgKenYMqce9Y3z2zOnXXXNwz4FurYmi9LUk+lLpo7H1Sqosv23d02KExbwpGWBRDEXwMKWEZtIoNq3mnBpFGf4eXItdUc8p/Hf3fScQTIIWD4xJq8/oCNvs8hCNG7vcuC4QVwt1XEWsBSqZrO6YlP6JpLdSASYg82v3RixK9A6rXmGRYApha/wKqllkWQGk7u+c8vCQlK+lxpDJVAtgheXuOglsj6u1ExWQuKZapQNDbEQCGUmwZWwtaVIjkg4C1dVaG0p2EpLC236BLyLPmEJIKvfQh9F08Xj/kKualcGnON5iqiSSzBzH0kOVPzrFSoRfy+mELCA8wOslNW/tYnNPPSYtU/NSgtp31jAya0B7b3vPafrwd12BfY8NZP4SJZVLmucVewlIGJwKvqJnkye9xSpFllCGiCxA0hKdLdeZjOpk5n+lOeolHX4oTWp5VuYuz4+eOP11qxsb+3zJ59aWevEQP0KK2qVDGquDwiHLvrQux9PyOy49Yc9UiRVf4md/ro733uHRL9wXXRcFKW9QpTzwUI7pBf+s6qv1ewW6k0288nXPrx+4oXbX5uYAnbzrh0XsNpoU0Zb5CPkJv0e2Ei/8AI4Bk9As9RSyoapfbfYrJJ9k7uo9Uh13g/ih9LR6WRO3ve80nvOxRazsHZNWd8LggUfzrhm4yTrRas+81NOaRMZs1vZd8oA0oYnSHAyTSCRRN0rUYyUu63KoNupht3W+AlZ8qTMps/NdRStJpNWRABpL9HWjFpbEyZ8NqfMih8RYrKgzprR6OCX2JwGNJrtHGYIqHxTF0V6P3SKOOWMin/aHhKDHCsmJaaZm4sUKzGsfSehYSma0jynpjXVITc9OER+vIfJyjXKmLjYK1A+10bx1EpsfuID8suYYHXkGR/jog0XBXW8/hWO3TvOFKzo8eXY7xHiBU5XrKxm6DJ3a5unkk9JKmX1k9asFHKRfy8ibGQ/bc0i6jUqI07QMQQgkQFvIGXMu5wbqDcq+80fvuentv3b/3zz28FlMLzQwO+3VWHD3jtVlh717++htfwWLEShCMr/g8ellwjvf6eRU9SWOmT2lLBXPmi+JUAzLeJC94oaZb53dm+9dujCsNhjt4yOSojTNzCui4fSGsFh/BzMpsxsEzhwhK62kMgW8Pa+qG8jYgLS+0MTez63jxb93BNudHD4fk1af6eHXS9QCcfWemSjnpaosSB4cHhf5gCWSKKljB0uOBkVPMC+eBVXmBcf5o05jipl4CDva0GeYxaoSUSjRy9h6RRpYoMkzVv2qVJhHrPrUgZlIlDEBvnNit+oEyBO/BTJf0zJmmJFHkhvHi4K55njFLFx8Lu9LBX9UGJGpCwSPGL1FPk14LEs+mrnP+pGCyqlbqzgVq8zCk9MAYwqIe1TveOWYj5xWU0VEYlJBhNaLZrH14WUIW3dMZH2mRiSzdmuYOd3Dy/7vx3DfT9yAXidDY8tfVGhSutG0iFbUrhSZuxbJFm1dfafJeNJI22a3wCmFMUVZpiqXBNce6UkShiGErMadySmavTH78VrXf3Q4KB/9R/+gj7/3zSVOnNjdAEk4K4R1IQANX8p4+klQAdj1hFq5HRMMn4oif/3c076Kr/gI5dNEt4GTx87+UOfyg5ONZvAWKZ1YWMlOwZrAm8QI5lop2QoVE1vZ/mbqJMggV9W6OrZSoi3G06RacjKGtQxFTnzPm47HDIexp8jOGH59iPbL51HbX6fh6YGqPuTkbu2MSsAdC80ktCV1FLPuTDJUhVTt2oEhxyP2X6RnfSdeCT5K3Fw4H5BakFHy+tINXq21Y7vFW3uH4plCzEdYe+FSW1c5NZykBtUGHZ+EYhCfXJ681xE8QhAcJWx485p3yovR46yCPjHrSVgi1X1h6axQo7JkSKWfbQr4i7WEN38WYoPewRVS4+2zTRlAFRlWrejLpQFqN3ZjgF7/b9eQzYyJrM/kcCUjWBVc8ZkVuv1dp+nD33klGke3IKkIUpzHeVdCo0VJoxDAap6TihOfUhc1dFEdhpW0Gg0JjRWFhGez2vJI5IHUMl73QbkjCu9jDHu92c7OHT92W2+7dznBP3rl5T7mrQVjT5cym3bfCB/ncAA06qH78cW/yaddjPhCTjN7n7s/bMagbHf3VanmsHFmA7Utxg/+ny/b2z7Uv2ZtrY9GvV0ihEk7khNf/A6cyiU9OFkfGAZExoNykuqRGu/h0T7K1dQMvvK4FJqfCCHkRgqPC9DlLR88i8N/uYTl/eP2zI4ZRKgdbKkDglQWrLNDyP5aqioxrjqLmfEpqqJE8QuKlGZWMYqEIjqDxzSkNKyzpZYCGSfpDqoJGHAF0inH6uiOJOwNMIzyQZjUjs9ZPl+lSVB/MlJ1TjgfmpeqWZBRMj6L9mwcUkAkwaZqvvuRRVmLEOclPUFqdfVAEXQwbgmkkIYX+1T5NIGpA6gAACAASURBVLWnFbXNXkVBLhX8GSuSggpw19LDWWWoDFY9RygEOWDK9zZRv7GL7U+sADOX9pTeCSN8M+tzddzxx6dx7LYZLF3WRmdpWzBomY7eWiuJi+2ZjTk10osRAwbvpd6OMgIplOW2C6YK2qaMeotk8OfN8Ndioc1vMMKOjn2Ywhgiq7Wa+IbXvOimB9/z6Q/dfMNR5A7Y2EhKtV09Jj2wvu7iYpR/EUjQ0y9G4umFMHvLQpVAuotHgMg718xg4+NnML239urafLZnZTOe0LwEI8CVYalU1h878fszoaF2xhOOaD4TThvWXs2uKdmZyelWev9srXpZNj2hX3fI+8DNf3KOfB4Ita4KuhmPZ2xw30c5aH5VE8VWqYLZRMMkc1n1KrCK0yAzdZT6dpl2hM3mQF1VbXrY5m17bESLSwVbsmqWpWU3SV6cZHaopjg6jYQQMRa5cVyWM2nrcPL+jYiLN9dgo62aBEHIJcmZNdhBOVjEKgnHVMnXrJTW0VDeKuxXSYZZ0t1a8nBSQQs3V0ngxCOSTiXPxi0pbiEh410W/uSgQiZjSrbw2jyqXG9V/Gb7jR8y8n0NUN1ZpTUez+CI7ZqJGhaObeK57zyFP/7Rw2ivUSRMewWcpS6vvijixB+yaSU9cmVRk4Z9pbDJWJk4sc3RCsS89MTGUpmaZlgZu6nKg3KuFrpCjrNyYqKbNa/Lf+Qj9xUffO978cByr4U/flc9emm5XW7sm2fA2jphatKjt/lFPP5pvZpnZI0c+WQDfnPwLOJ8PPVRbBU4cPcVOHZuI3/g/kdefes1N9SateD+VGaqFyvjNEsmCamTrUkZLMxV5fLZ4uYi/98sdcxzVU/D4eeZOCWwt2VZmqAr+5p82/vPYt8j67Q+Xx8XIjthhHmwNMDUS+dRv3YSw6VtzsgUgQIlx3slFCEO5vQh0QFKYa76dJVliPJHow6HvWS6mHMXRzPXKpnDdLax2EgxNiJN8XERJLVjcBqbZEH8oTYRol6KgonlUcAlSr1+sYp3ahVmvjgpsjGpfMjMuSuPVxHNaE1iBtxlPNXaWs9sggW5BwIHJbSa2FsGTszHKcOqT9aZIfModmbQGn1KMgvMiaRDr6WcQyILhKwoNWwTq3yfdh1n6cXrBerPaUcCa3lhADf59Lvb4/H0RvRTWmji6k8uY9/nNnD+qg6mT/fFfg8mBK9k7EJ8EqTPmykIWT0iZWfl/E1qpZbgM9jNRJVTj1r/kLCxMyQSWMi98YUvmrWan+x02ydXT9xw4uTKVf/XL+CB2vQEHBeSn7TLq9rQJW41Gd3uF2fX8dTvKpL8Ez69ge1mDcWgvCSY5kXhcfxPjuLlX/+cK/Zc3b9iu+eRUT4sMKgR5ZEmQqkCEfA7tluItYNuTRoJObNjbaE7hmO5WWQbKCVFIQacpma4EBxLYH22hrlTPbrnTceiy+oYFdkZI+xnITRr6u5J5HXGYBicVpmSHEWt7thkulQ5sI40Q2SeWHPZDvVKQ2Wy/C7DLUa/dzPUKLW6YPXbyyxNLL2Uycmlgy5HNWJTHJjrpEpsR/Q80gCRuN44z+MOkAvOESanGaEYGsIjF2toOaeMX0GIKFVs0tP3qeHDVtnIATeKFoIwOV0/9DkczN4N5FUu/HnapfQJS2vffhDfgHfRbkWNwQVSgd8aonaggeadU1h/w2m4qdolYWC108eglWH6zAB3v+kE3vZj18UgvZoF6ZHX78hVrrs0ErlgvRbrOwIJvdTKnyzrCUll43QOicU2jz6zhUqJDHkYPG9Kz5lDFh26v/FVN9/6zv/+2Ltu/arLcObRJTp/co3rzd1d1NraFkwE3dqTm6A9rU+DahloZRv47Hll8+zyEVa1QYnlpR6637z3p+evXZgeruXCMsxyjB5k2UyDk9G0kj3S5uHtBKxx7qyKBYKZVyX/Sa88V2eqNFDRdFQ2Mrz01x/B7MkeFi8fO63ulNFdHeLBayfxmRtm+FvWttHKmDc8UW7eBdZcoRR8z6POqrIYemNUKFTCEi5DVdsmaX85tRfUgJ2VHm0uTonEJ1Lx5CEvhOqkpyl1eVXiiTRjhEwbX8eTgTUjxQ/HQlm4gd78zyQhmFUNY/dA5DhZc50rhzHL4gsmU5xg8+Sqyfr64Cp4GClsITE/5CPyludaJdBYKKUFTsrvWaaJSovVZ0Rcbb0q28xsBex7jNYLZ7H1wUXifiktm/F4RkeYLIHMev2HL+D0oS4+8u0HMXdyS28fg5yRwkhDcEwywRZrvZHAO9XWpBgPLdjZDgNkwIjKzrgCvbm6GyDTN/MOuQ8XMaz77uS0u/b57e/Gbz/wm3/70RPLnW6d81q26/t94ZMrh4z6FKHWfvL3+vRLs3qORruOWrn7ezSlZ5QDxne++lZMLvAL1lY9urVaORwOs4pPmvrS7MTQOvYVg5RMBbuwUCY9ApKkz4zYC5NS/AIinjnyerq0qPOsIJy/rOlve/8Zuu4vLtDyvua4ENkhI3ylE9sFPnfLFL+J2/7q1TV3c9fTcCtHSBPPiUfhWSaj1ZG2KUhEKZA+n8Z9SfeORRKsZ7ckjHFJBm4IQbI7tepWfpE06ou1yJB62EuoLywGz+zlpT4Jjy3ZzozeWkKpbWRqBJGoa6ldmfdVdqqk2l+miszttT8Zg2f0YomsLpfthqSPZI6ARmVFciezg6tqpfVDTB4/5rZ/MXBU/UGF1MwjwcBGthFRkujjVkvUDnVQv7mL7T9bQra/cUkgwTt9RDLrbB3Pe/vJaBO/dEULk+d7sFanMqfNNlBG5eVTfYN0cWng1XWBEqUcxm6iEXHXyAGgcp/3UtpG7Th78p3OpFs8e/QWpmL2+IOry61OHS53lwS61t8qsf+6DmrNJyfIPOViJMDHAUY9dXIVeS1PJnbP+hEWp4KjQVTWrMUUYVt1BgOBow/cdehge2HQ2diOhEHi6I9gzprycCe9awvDYx+jz0B2MrQlUatx9S8TToHSBokzdSzxMOPu+JRbszXMnN2m57/lBEVPkWzcntkpo9b3WJ5rYOvWaWr0iuwPejn/RJMxUWdeG0g/O1dyBieLdNmZrZMRmZ9KWCYjtCL9rSJkOFWXKGcjIxcbe9FA1CniVvXNEyphfIkqUFce4NR5NG7NcQJ6Ut8R2eydqW60lkbqmsgUdjb3FViQfqOaQYnSxQuZND7co4IpKpZsigsZBSZM9yB8Kp8IWEhK+krSW/luOv10vD61JosYsuMTRVZ/L4ndolrHGSIU65xQIdYIzdunYjEyLkR2xjAya0BE7nnLMbztddehrDl2hUKKZEWvFhxsBeyIV4jCJemMmIQ4OqkqghNQYYLJMy0UHfZkBms6tdzxwwEP+jW0pzr5a/7Vy276zR//889dOL98CbGgOaIjX0xMzFNHRgL5Ls9QUC4W7k8lsncHjrga1YChH2C4uF1dIFWz8OiFxR+6qbFnf5OjEkLtGCp1A+l05qrRH8ggmr9aGeyQzfmUi2bRGawGm8bsZzY7haC+2ZrM8aI/OELzx7dw4YrOGBXZISOiIisDPHD3PC5c1cEdywM8VGT4bxeIf2hu6CbrHqsD4iEHqVsi0il3P0ssEgvjSoG7wsmEgA+2FI4e6jT4TsgXmqKLKlCU1IXBVXPKFLrGjlWReWrqRBVYst9g48WK8W+FXJA8p7IGSdsdmvohhifJNliXf90ESOkzGpmT6hGzjyWT4uge4pDuMK0+9O5xyeJb31zqcI5m9MobccYnkV62gfFkH5SBKSwMYVLGCXsqQ1m0VtLsc7tcXt2i9XMDZN0xkXUnjEBmXdnXxHM+cgE3/ukMPvPyvTR/vMdlphSmlETgRgtPpYuMeMxoNwdK/IOmclACHg3d9prAKLW8V92aRRhEsU1Ys713MXeRM25NTFDtQP8HunvdnwxcfW12Xwe+3P3rdll4TO1rYvHY1pM+9qln0xQFao0cC1fv2VVwU7ldwu2Zwr3fkuPRP/osPvphEYTXa8CgL+4NKyvnXlivHYAfAoNiSNYUH3HYtrIkwdUpwSl2rb0eH6mCDNMJlSqoWEmDLiIqLngOY/GyFq7+q2Xc8v6zWNkzbs/spGH1wdFbprhfczTD4AN5SR/tOZpZdfgHcx5TDaaVLWAYU+ntYGXggNqpKnEyjgrKsFJZWoCQfoYNkvC8RDj1F8HSdPHvq/u6WLVXCb+sxL3Rs5+2x/XnHklhYuoeX72GEV1twRfjSgvUU3mxwhg+RaXa8qFnSc1bGnGfT2ExQuiVF/Tp3Qirt7oGb3iPJhnTyLUwXDoo2FvXatCM0IRoTspg1dcK8ghH3W2P/sEWrd40iebDp1FM5qM14Xg8gyOQ9wetHHe/+USwisfGdI3aK0PJGFIVLhsXDyaDZ82opJRfafwRqBq4CoqmxCdx1S2B1N/T1h6p7MZbrpRkiDENarTUO/3yV/7i9Qvv/tXH1k4/vIH2JaDKoizDoFdge7140sc+9TYNiT9C0f/So4J38igHJXhriEFZxze8AjjyCOHsOYdBfxCv+h/+6EuuOHxvd+/6+gA56j40BUPLiko1gtIzqU/rI48cAHXBtJ65LWSi17Qtg0SzyUn0oFxGbHdztNaHeOEbjsVNoGhm42JkB43WeoFzV3Zw7OZpmlgdYMhEC5mHb5b44FYWi4/vniow3fJY3XYjJqZ8ceqdMvflFF/xRKo2BFJLR0CRTH+kJExKLsBV98NSbCnFn2MEfBNQwwxW00t5BaNFkWBulqklG3/fSw77SKgjj/CbqvVcZMw+hU5fTKSFhTARXfyeU8iIr0yiWM+hyX1q5HA78nTASLFBJhuGyYyVcE6J8Kr6tsS/Ud1FvMzpEPqVM/74gsdD18/geyYvoFYwiuxSgdt39gj3SjB/nDuxhbvfdBzv+YFr0dws1TXYIja4SlxQepZhGdo0vbiQ1jmkt2m1PkNjLhMZ3ViCssiXXnJP1UGNyuHQOZeh1ak1r7jq4AuK5ROfO/XAGrozzUviuwkt4yLWIk98r4wp4V9ghKl57IjHLTd73Pf6Ev/2Z0os3LQHnStnsf/27r9eODBzvfcO5TDmXQQLBh/NJ51abOoibHZ9qfto/z9O9Dzl+BhJUS0fYm9fKIxOF2xZMLemc7zgjceDFXJkkY8LkZ0zwvfT2hji4efNIRCKG1ulLn2Ey3Pw/gx4x5rD/7NYw9A5TLVlUSxSuy5EnxiyINbsKVfDqllHF9/QdmpzKQn3IqVNrIhH3RKqugfGQoGE7qUcFyVK68+d5tLoZh3RPKcIju7SarAgeaU6t2m0IAg+IeoOZfIh+HR/xNfLxWslvY5ebrwP2CfibArwGbHUR8q98ZKiaohifD03cmKt4vZYCTviWOUq/gexGmhyahcFXv5EeN7c4z2bwDuOFnjkhmmcvXUKE0uDi6zux+OZHWE9DAGht7/nDIL30tqeupg3aXs7Ur0rGnTsxhgLOvGWbW47m4ty32kqtuVa6v2Hi7dQMRzWgjtI3yAhqPCRe9jtTOOhv7zwL08fXTpot29ou+72/8qSJZriSca46fk4I5zC1taB6w4B995T4v99Xw33/vQ3INu3eeeFE2toz077ImZCuxDgbxY7I0bSI7nUI+Q6GBCiKykbjOLMId4K9Op0Gx6yOVXD7Ile7IuuzzVGpJXjsRNGIK6G7+XIbdNo9kp45WeEtTAgJJfVZLP/QC9H7UKJVy+Elk1ASMKC5LTOqJito0iJ9USSCmakwFUG6gitDkYIgXl7kSbSavaALMTB0jcLliByPvTJ9kyvJbEtyKxCki8Ia7ydZK1z5cZmrCmtRMgKby18SmtZWgFAxqpSxa7xOfQmKUcAk3ji5BH0SBi+cBdJIriC4fX+Mmk0p5/atVEVDegrtNKKHWvZdIiR14BPbRFev0JoZ4zJDuHILdM49NHFcZtmh42y5lDmDre8/wwefMFcRI/r217q8nipoxQRS7umKsSUOfVp0uxUyTfb6UB5q9ZjJWfWJTLPMuVFeTX6i3VNSb7VnnB9d/ametdNA3S8tzmMqMGuH9VN/YTvdFyMfIEhE8pH34W1DWB2GqidPYX9i3TT3CGaWVr1aBQmtwzKA9KWdDS1TKJd7U2afRKl1TeWKF7jwTKOtXSkPOnWEo0l0+Ieb5XtTk4v+sOj1L3Qj1kMY/XMzhnhC+qsDPDQ3fM4f8WE7ywPnElLQ5ehEOWq2xsOalmJd/RqmF0Gvml6yFONjNcGcbFzudJW2atdOVkenCVZkIHGmsSfqgauOM8eldG1Pt45q4eT/U20WYWJCSCFh6y40mJU0gan/obTzA7p0TpFPUrRzWh/0pYds5g1OhVLfmpSMogRvvI5YmKeQeG6BZAt+lKqkwFErJi7oOKiPRObQI3ZMXmyU+6J3E/M6tY9wn+xQk4/xkgEcBxDe1jC+NrBxjDzfKTHeMNqRrkjvrLpUawWdOSmaSwebGNieRBTssdjZ4wwFdbnG9j7yCYO/8UiPv01+3jhWI/ZxzlXJZ2naIWqa6kWNWAjXrNGqKMiEqU7wNqNzuItVQ2pYZKabB1vohB9Mwz31abH3PwkfuBff/2Nv/PvPvLpzz1wEt3pS6NVk2UOy4vb0Wjw8ca4TfOFhvfY2ibs2wPaXgf+9c/WcPJ0A/2zj/44+oMr2xNtlIWpHZ2tk2QSy9irCR7TTs6kmmIurn6VWbdOa6f7TMKIxdzAi6qQSk8r+xru0CeXcNv7TmNtrjEuRHbYSMTVW6e5rIVuQalAbXWdISOldIT9Deb5JuFNaznetVSPtehkvYzR/IVRJLL4hD4pEOP+7tQ/L9lF+vifZhslsqlMwOiTZ14IHFFqayAqg8PH3g5XDROnOh4RiEn8S8K11U/MnFAqMpTKZdlctn2iAer1pgrCymoW+1TTXQopxdRDWnqoNRsb5VvkRZRgEnFiZWfpI+p/JnWaN8cQfWfJEY7tFcUE36dAVo0i1NDfeDXdGjivMT69DfzactOfR8bPabEEp/VKLO9v8/GbptBaG45bNTtshJZM0XC4+60nMXVmmzam6yN8JhFqK/U63Wja8NNYxmDfR5pkR6mCj0Nnv5c5qIWI00KEU3c0RlFKq12AEY1v7HQnsOeq5j/Om+WBuDGzuRvv7v/svT7RzTIu6T9vhFNagwpc9qJr6J3nCB/+Lw/irz7ewGt/6l5auH34/N62x2SrXW71yozFLkG7M1Vol1PAhBXfNtFCXE5d7EkLPZBkYRYNGVlmB1FFqON+O6esX/I99x2LQoIxaXXnjeZGEU/Jx2+cpNb6MKp0w5fvjImhaQCB0cAl6NrM8yO5499Zd7RE4FdODqnbKHl9QFT4EFHnbPtM+Gb4RSSGhyhqfOxLq0tYIqjaQc8lxzOZSp6MqmcLbIWfKp1zJC1dz3jyl3g6NJEjVIJs4XyJasGMEZKUtqi0dqh6KW6kbW+EFK9nSRZKSjiESpAqqjA8O1E5qiAUIX5IILJBM6r0lbAbbU95SzrTNpFk6ElrylnBwhEVcQ5uss6RzvVn68S/v1ajbefc9TUfv9Z+yMpx4HxY4sjNU3zzB89SFnyJxkTWHTPCV705U8f8sU08/+0n8Z7vP0ytjWEsz1mj7WLFXwXnJURNy2gx4iMVflckEbIWH7E2LTV5IXjyWIi1Ewgx3UsyJz3XKGfn6nTsxLEXrK2v7fUln1y50NstrhhPOsrSo9ZqPe7DnrQYIcWL6RLobQWSTdbI8Jzbr3aLf73Jp7fAVx1iPPJADwdvmvm6xvzmXL+XqeneQJMKLjLEYSv+kpM2eQuIt65Z4pRUXH6tVXwqweOvhwp/fa7hX/j6o3Tw/lVpz4wLkZ01SIqR+1+6Byv7Wpg6t131RpNsVvP6NfIk2HBcU2ccd6D3bNRxYZjhldMDLNRK3h5mvM1qyC5zhCU8VLFfSoSHkQzgtOdbOZLyRkflq2w7d0rPrRS3BgvAOkOkRFNoSrCvoAfrQIpaRr3bS2tUxucwnbBclXVw4pbvKojE1ERV5SMKHM2UkRvEGzqkT2C/wmztpIuIG2bVXTFAoO7zCVSJJzW2MkdLILmJebIm7/3Nq8C7txwy5/jGeolQn/QC1C8+97Etd/L6SZy4YRIH71/Dxkz90pz/O3SYVXywQHjsthk89twZnjm1pW6ARFp7x4uXIyVVpCISrMzc4iM1hDUnmlM1olxpSlXMiHbNeqHSx1Gma3iOYAfhGsC3vvb5L3jjL3/6E6eOXYiqmksB7B4MGbUsq7ySPm88aTHiyxLFACjz3f9pWTDW0b89z2ceWeF//9Mn8dIXAa8+NkN/df+j//J5B/fMN5sTxbAwLwNKwkifOPoSycswW2xDjeVPCu6NZM8ony5Gk8T6WtiKHrS6v0XXfHKJXnDfcazPNSthxHjsnBEwg5xw5qqJuPY4wW+hIVtiw2gCDz2Yl2AO3ZxrasAkPH2sn/Ox88SvnhzgtrYPwg2sD6UJoc1ptRoz6wNZ3JJ3jU5fbRGa5UfK24dpTCJI48yhidSZNNFKma2FGEivHqnqSPEdej3xR1IKxCexyEdYBqASRwWCqFLIkvdJdV8IOO6MTkKoCihKGmbtnfh0yLTgkWTcSmb9DYxk36Sja2KPJ083vbz4WZYlc43IT7QcttjTf1skfGyQY1/d42BQ0jBhOyJdyWmN3JBpc28Dx26awaFPLFcA03jsmDFsZmhuFviq336ULhy8xW9ONdBeHQq0hYqo6pKUTPKg5cRo/ryp+q56hIZmJ7DNuqFO7wVPmUu1vVXlwQQtFjST7S5mbnL//OCh1vvL9dYDc/vb2NwirK9RyHt/Eprns3fUMsLGOqHX20CWQeW+1XjSYsTWEe/LJ3vorhjBHnNzdYNnFzzue0sNb377JL72e75+HpefOVwOS2R18v3+MBPTHCUPSqJGZZxAlCASUo8GPRNWrUuRNUiue5y6MJud+D/bbYfaVokXvOFYfFi/lUWnwfHYWaOxWWB5fwvnD02gvVHYLUOpjBCvaNmhyUdgKwATpRBG/Wxe4pac6XPbGf7zSpNeiz7f2S5puuawPnRchHRyEyCGVg8LE8kJi1XBgejgofbymqXPjtRaPt3IZqJq0hpKa7Ak4YSqKSXwmvhXAQrJfUkSYY2Rkwqm4gE6rX9S9qlCDy7hFCNmH3JVTp48clLN+AFV98gMq/TmoNjsSjVS5bgib8KbgoeqxUveg4OxbSK9JTZTC09cskcnJ7TqIQOzpN9eJPrwMONrm6C9BD+MDFoX22HGJzBz2/p2iaXLmtTv5HBBvngpKCOeRSOSWecasV3zvLeeoPd+/7Xc3ByytPTMdMdEvaO5AiFbQfnOIw8xa0r9BKrWI5mIXSa2s2LXhxvUo9JISi8+pzaWN85c+a3fce0V7+zRA3/zwBLm5mt43h0FhsPdW9OG1WpzC+h0PPr9///Pn5wzwmJa4jJ3aVT+Dqi5Ep5zvPd9gelc4EXfW/z97r7OrC/aAWPPmUsnKhg5XzlKTUZIcRGBch/DTL0aFzg9ehJ57yymzBTtEc5TiFo+59W5hr/3Dcfd5fev4sLB9rgQ2YEjLDHttSEefNECB87IzOmeJiRCRBxJlcojfqjC1xRiPtGQCW3HfF29dI+UOf+PtTr1yh7unWSeJMbmAAiRSJlFs0BEI1rUCKOUeEQZm2l8P5ttDZulEyTBC96Z4NUS7xRtZh+dRcKffQxv1Ku3qBjtjo+ofcnqiWopFgWCk76S00rda+lNtiSbrsxqCW+anaqTr+0ZV0l3rC2qZZDE6DhOPRwltJDF8thh13hzcunx7RYa0TtTJ85ajCM90OsvAPcPM75uArTApR+yo5IyWMuLtMjU7pjvrA/p7KFuNLrb++hG5CmMx84a5j1yywfO0KN3zdKR22YwHfrvgjKaAF1vh9BZySQYzLHV4bDkhArb5FQKa+2dAgwg0ZNh442/7ypVmHn8hCQz35xo5LM3zn7zRn7kzxeXtje//we38NUvK3Du/O6eQOHWDYXI6iowNXXxz74oAqv3o+H4u3wQMNgu4kpYbw3RaPjW2XNHv2/yygOtWtYqh4VXM6XkIG0MOa2QXernJ3mut4wQJUpp/7ECwFEdXZmwMZvj8ofW6c53noquguOxM4crfbSgPnrLFGXDwvwppMogSpt4MruwRGe1NIizwhH6HlQjxvW1Ao8NHf3WJuFhz/SdkyU6LUeNIbA5FDTFqYIwFiBm/66QsidZCi1gzvz32JZCKR1MZKslTNr8RaIrGfrxCbyF21gVIQiH6mNs5pJ2biqCKLxoxqRvqWoyXf3jfVCaQFi/1uTJk8QK1V+8RPx7u7UoIS6GtKQiTzVoRMZ1sZD3iokV/xjSt3N4ngxcuszhT1eJ3rEKXmbiQy2maWYM2Gzzk2UK6VlDUSK42sDz4mXNoKLCwc+uYmN23EbdiaNoBGO+Ie6+7zhOXTeFfjtHvVcm8qpNIVZ3bJFwsbKaNbMhpQiIkL2qTUJL04lmwYlOB+rDzcyJsmRBDyod981WC6dW1773+Nnt373zdv7oV72kwJkzQDD6tvbFbiW2lqUUJAEFGn2PT1iMqOIfLstBub8kkJHAkQnFxvUvf5478YlH/MteNt+ev6Z21erWENMTXCCIN12SDqjYMhk7UYouj1oBs3U3+NrstfWU5xNjEJaDUGQeoUVzxztP0cRiH+ev6IxRkZ041FvkzOFuJDK2Vgsx82Q1m2EJxIcKSJiscoXabVW9jPB7oR1QA9OBRoFimONdG8DxAeF7ZwocapWYyggrA44SwRqpWa+zdoYTZU0sbXw6wbEZOSV3EtPBkNhERuiuUvezsfFY34cdGiMNqowkVWuUc/VmRrouFYpttOxktqMwtyhfqkok9YL0t0ZmuvxmivAdQcj9yGMTYMuhVRL5hVnkoAhSKXRZuWGjHpOY27mnRgPUI8Ib1zx9aC1H6LtetAnB2QAAIABJREFU3WTqOM89b4inojZm+ibAU9x1RKsECptaKEZuf8/paK41bIzdEnbaCOvs2p5GdK6+7d2n8JFvO4jZE5vJVtBXRbDp32V2+YRmkkQUGCaIlAulhwNjjZCZ7pHUxWnLlAZQBMOR1Wp5EEsMhmsz3/CKQ9PLD/VQry8hqwHh6Dkzo7+zi5f9sM02m/K/Np4YGdEPo94AGk2krJTdOsIkCrl3oSB53kvn/PD8CSxcNfGy7l50extBUku5NMDVJSF+DmkVVpycTEmj4VyEiqatDpgwQ4akJhNYvfRY29vEgfvXcOiTy1jb0xwXIjt41Ps+MvW3JuuYPbklfQUl60dYwZPZaCR9h+y9TpzLzQNUnR+DbDT88XDuMMuMI0PH/+lCnV484fFNnQGmayVCQtKgyLSuFQqIZcFlSqzwXKm1vBYmcc/2Xmw8XDVtbcHjRAdVdyddeyvztlDwKKmPq2qkWnCNDxLaui6ZN9jSLMw+WfYjjyVyPxy006QerBU+Yr4jGt6nhhAjqb1e0Q92yV1Tep7hEnMYOmKumOG/pgMa4Ud1h89sM96y6vDIMMNc7rA/81H30C+dMI5hIWoi//UjJrPkqhC99lqBM1d3ceymKdzw5xdiFMAYHdl5I3wlvW4NN/3pWdz/kgX0JkLOVxn7n6j4RGQApnVkEhJHVsi7KjeKKlzOJhkZfmgT8qJEG6U9BOIDNVGv1XDTV8/c+29+G+/e/wfA//KtQK8HHDwom/QT+IM960dcItV6pNmQD+4Ji5Gw2JVDj/5GH3lyL9zFI+S/bBHmZhgvmHg9TnQzPHK29X/czfOtTqPDvvSZwtmVVEGOfFpcp8SNkRxeaU1qEHWa0CYbiw0bL3dBIMLVBx4v/b2jqPXKePOMpbw7czQ2S1y4vI2HnzfPrdWhnakSP1Q9pG2VUt8uKQEyATP0TFbZkZluMHRd9mces67AY2WGN67l/OA28O3dAV3XBOo1wnDI6CnDLpzTHcmO6U2yomQ8sUs3pw1bOUnSo71ZoCBt27FTHqoFV+rftdNBegpUWJAynwja3pQ8iZVqvQ2ucmLsZUnQCu0pxRFlk+StBW/2a4q6VMTT1FTKrADz2v2K5m+kJiRide/F/CFY8Qdn28kaKATdLZfAHy87fGhL3vW1dcKEix4j0CwvykhQTF9pnANrOH2/dryIl1hGoMQ/dM88Hf7YEkXxzRgc2XEjeo9M1zF3cgvPf+sJvP9/P4R2r7ANkSnZMyQYTmyOvejqnVGsTCrvvBb7pMCInjz1LpfwbVm7q1687gpDz65GfnJ6Mrtwbvn7GrP4tV//jeaZy64o8KrvKgSN87sbGYEWJJftD7ErARqmxy9GrNvQoy7WfB1lufvVNMNhibzmcOer7qL//gd/zldfc1Vjzwtnrh72HZp5rWDu5/LROI04DUt5xmkdDn9wHhaxTmp4VRKnItsSTJEi38XgISx7GwtNetHrj+LKTy/jwsHOuBDZoSMSV1cGMfti6UAT06fFW8SZisqM0V3yO3UsXTsBa4PzGQQF1s6IiFZJuBclPEILIbA/r6l57Mk9HRs6/o8rDbykMcQrJhgzTY6psRtlhkKtQwKlImyavjQHGy/8fal+2QxDSDW0Ugdr7SF002guluiiwuRLAXqC8rAWLmo9Etou2UX5YynYjiuHBXE9VRSjELy7SiyOL05c0QWNOeKN0Sp1mrJay4T2OGnBkDfzEhEVs2wS4dI6OaPeYATD5D/bJHr7GuFMKPZqwOU1OXoOtNoJn1P8DKzQiFC7M7ZIVEXz592T4Q6fWNnGqesn6cw1E9j72Ebc9MZjJw7G+mwDt73nNI48dwaP3T6FqZPbHHz+wSNp1BZlYMaAIoUzAmDC2uROyWLF75R+Hc6VoZCwrKk0W7whLFLkDMtgUF/PahPZvh/++Zfv/cXXfvTMr/7qCTSaNaysZ9jcdHC7HGLLcvmc3v0nE2h2eo9fjARySa0G3P3iAtOXERr13V+MhIjOAWpo3DPF73pDG/P7s2+8caGxZ3MttGiCSMtH26MytiGdBt2F5T4b4QOo623s6vtUKjtx/0sFSVKMsfgorc03sf+hddzxjlNRjjb2FNm5I7TThq0MR26dhitKclZcmowjMZtly1b7mio6VoO3ZIv2SadhxHzLhwnPHJ57KgOuh6eTpeN3DXL62CLjGzuMF3dLTORMfsDYLByKEOqmS6V0iBROZsPm1KpDOXaloRfaTmGfIZmGkIoUE+QXk4R9THqpcBRZdFkrq0QIhNmKxOcWuzWJX5LADlUYJIqvNFfMoI0dpQCziDxkZhoom4Qocy19VxziQuHhySyPCXkGtHNxNX6oz3jzGuH+Qc6dDHR9w6MbebQuFn7ihiJERRVVxG+FrS2E6vqQvtVE6Ke8z7QyX8exW5TIOjO+d3fiCN9J8B7BKuHuNx3H8eu66E/UqNUr1ffOEqKh37L9m9gI+lFVrwXajFjdVEpf43BD131KKLgeUcM0zcNca9WayBdaXz09s/XXxx9m/Kufm0FZhMh9t/snEYtN88JlhM4kP34xstlzaDdL/NQ/Oo6TJ3c/XySMdhPY9qB//kvv5PVPLaP4ps4rS39ZK6/XMSj6mQtyXXIjBbOw57wYiHBa2ytj4eSToFVIdH03DYBG0aCoO5R1wj1vPh5MebB4YCzl3ckjfEenr5nAyedMobNSaly9TApOZuwyLIVNOgkwtWqsFpy2PlnbNk5RN9WsWu4Ltj2jDsaVuacWEU4PM/zuOuPPthy+s1vgpglGt+ZDIh96YT6R5Cs5FQN7obuytYHUjaMSv0BaJ3Y29KnhiIQ+hxNhFuowdiOtFDLPdmn7wIoQaczQSNFSKo0V9hjPmkFGiV7irHFjYSFk2YCC8ohLmT2FH/m8syhTyDJQgwhBmYQaoc/AH606fGCDMIDnfTVPe2oO9YDOhGgFTUez8sipJ2cJVh01VbJM2xg8RgwL5bMM77G+WeD4LVPYeG8jJjiHe3o8dt4wMmsoGu9491l8+DuuQOPYVpVpEFFv+56BpO4N96/ORc9ySMgszGOEBJtuh3SHJSqV5XzoTRXOBXnZrLWzI0dOvXZzc/v3ms36me/50Vuyv/3Ycf/Zj57gzuSlEaKX1zOsrT1BMTI/z3j3u3P8yq/kEcYNPerdPgJzf2u14OdPdfCyX70LvT0bV26tF2jV65D4C6ccVbFM1YaNelGyihS08rX4MVtfKxxZrfv05Bx08PvbuPn9Z/Ccv7gQNfHjQmTnjvAdNrbKeAremqlj7vg2LBFfuhPa7gAqTojThNmKw2ZZAXEzdSRabwmKq6J1lSoX17KBmikteNB0XmLZEc4MCL+yVMMN2x6v6JS4rsbBswRtcpGI2StYX58tSBpSjMhmm5lDqVcOi532bP7qzzFCcPXVO1C+i/5dpSfSxvCQfDBKFg4SIwmj90W0I5YzpTnMl8rEMraovYxLi3l1AvVJwROAlvCIdi7+QOE6VgvGx9Yd/ud2jpNDYCpnviojajpGUTJ6kk+DLBFgw04kNNhw/5ZCL7lIZqwopjJ/PLLR5F9wDMw7faiLk9dN4jkfHRNZd/IIX0uwTLjzbSfw6O2zWDzQwuT5HjizuaZ5DNGnUOerN6sgpy2aijtoc7WaI94yfKXNOSJgEDQvEwOqeKvX0ZnLr3nNT3zN3nf810+c2YNtXulmON3N0Z3Mdv13ET66QI3YOOsfvxjptBnraxn+4iMTmJ8LuuDdf2cNC2B7cxu/8As91G/vfscbPsCHYg+9ZM58FtMgS4mWJpEkKFxktGcjpRoHwOS8EMcqk0onG2FmrM/UMXNyC/e88RgGrQw+d2OuyA4eQb4ZTlZHb5tFZ2Mo+RPKsedKRjVCYzYVTUW7D/B/7DzEbU92+fRz+32dP8ofldnGoL6Cx3sdMNdgnCqAz/QcjvYJV9VK3NFg3DRBmGk4NIYhyqFEsFQo1R00LpBOzfVM/aKtpdFLSBN1ZC6Kk6lxTpwKlKWKcmmBVpon26Kt2JA+f8RIolVPlmqa7KISR/xkWV3aIu/FjGOVC+y1odWCRzMrgJwia+ShLcJfbGZ4yDsssyCYB2seczFbkqJ3SHhxZweB0KTRFpEYIsv700Sg+J5K+/6YLBQnoTWkOTr6aaGsOTx2+zQOf+zCuBDZwSN8N72JGuZObeGFbziKP/qx6zFsZKgPdR5q4SEzUNdvqU4S8iHkbS86nDLowLniiBiX1dRyihR6tXZwcbbl4Z/zYGzebjd54dbJ1wy5+Ik3/PoDW9N7O+g0J4ABPfs+3C9xSOHWAuEJOCNGtFxe8ej1GOUl0Kbp9wvUqI4jp+7Acrn4OqCcb03swXBQwgeSkhNmtZislpRMzbiKXWKVRlJ0wfTa/xa5mC3Yxo0qaoSiQXjpf3kMcyd7WLx8HIS3k0dYYyaW+vjrr9uP09d2MHOmJ6iIbeLxxK4BWia9dYqPKCoWlzaXQvXNx0JjbHTBo2oh40wVM8ot8uL4EQoMrjngyibTAQaWSocHC8LfrDJaW8CL24yXt4Cpukc3rpiOBiWj74PrjXPOG8QndZBzI6c7qlgeoiiIip14iaW4Omlen9deOyULBl+Zk8QiJUvyYGkFedZTo/FsnPXaM9jy78SFxbzi5TypnZEsoBK5R6b5Ir3S41jP4b29DJ/YJhTkMF332J8zJoLnCBhDiccms8a3EinSiHNWB9vKDNxZbkkqzsxCTcle2qphZ5A8x8yfiZUBHr1zBqcPdzF/dAtb07VL/ZbZsSPM/+V9LVz/4fM4c3gCH/72KzB3YlOsjj1VOkhFM0w0afheQs3U5VBslUmEDWrbwJW2rCru40EjSq64UPI4ZTV64HMPfx+a/Jv7r7zzMyVvoz9chct2PzKSuSye5Yvy/OMXI3LjMh5+bBuwdI1dPgab22hNdPBAb36PG5xcaDbCBMzgeUjxBOXtBCux7Zorppx6S3gk7SuypnUoTG4yLyTX6hB+x8GmOLRnIqw7LkR29AhdgHCCCsTVYOOp9QYkS41H2nOAV7MuZ34cyjPIVK5aBrt1TeWKehCv7INgW+Z0twvPXybH9jh7MrZNXAL3xJWVMVsrMZ0TtuqEswXhLRvM79/KcEejpK9tDelQo0SDHBoQyKAcsh96oqFRQthFhEJCCVxCSiwsyZbfsD56cY5ny+OV+U3pvWsrw9546k+FwkUURy45bCO1QGDlTyzCSpUV544RbsO69a1yeZHNocef9TJ+31adjhZZbE/tbxQILay2k3ZRH+QL5Z/GLwsxcsTkwrECzPQqSpM3a6tKyizJ7NFgKUsS1GJNmkWkYqKwIdW2CwoHimA5fvn9a9icqY0Rkh08wje/PlvHXW87iaM3T2Hx8g66qwMxuZNpq3reMt4fPq3xIl2QFk6UkmttoogjCeFEhWlkbVqnJoTMSPasWfTWI9Ta1P7en3xF6/2/8RAe++RjaE81LonvoFarYXV1FRvr608g7dWqLsuKKmxrlw9fDyzmLZxbefi1V14zeTmVLZRFGfV9WeQcenbepXa2bRDKtU+LasWrHtWaU8UFDKe1eoZ82+PmD55DWXfwGY0Xrh0+Ii8gOq52MbE8pDQBUivZlB4ax8+cYvbNPT0preJ2rSJwhYQjC1PtDmzLU5v19GOfqJMGrkizJ7QPc/aYzgiTzmGemJZK4FN9hwe2G5jLPA7mHi9sMa5pEGcNTxl7aorPOgbe09D7ikbKVafbkZnAc8qSUWaIWmpEUazOdZJADk/kVW5gTqalZ+XBGBHQwzwrgzdIVK94IM8IrUj4FQ5I+N0hGJsl4TNbGT7Vy3BqAFzQBLwrap4WAhLiKMp+h3pQCFUTJyM0Vj4OVSojLbNcQkWUVKz6CU7oiLjAkTHPLbmYNJdQqcbhx42NAsdvnsL6XB35wMfWzXjszBHbNd0aFo5t4o53nsYf/8hh8Kr5hGhF4sRfJ6pqjLM0ipSxueiMxHJXimCo4CsV2iMCB9LODTfyJk3OdDDZxjecOnvkk2fOnS4mikbaO3bzCAaDw14RjRK/YDESe7aaB7q9XuzajyKvceVpELovJaPRyrCxtfi/NppzDVe22RelZWN54Rxa4qPxPkZhejacN/YFLegc2m+XX/MRzl7b28DN7ztL+x/ZwNpCY1yIPAtGvVfgxA2TMRBt9tSW0gZITK6iY/SIgVgFgI1MFKVgOJjDaKUMjNtgxIcF+o88TovTT3wTReCU1oDKaTUsiQV7FAVHNclCxphzHutMWCkznPEZP9Yn+sttxr4a0VVNwvV5icM5aCr3qGeEuq8uOqQFFwwqvEl0tQHFVgLFi1SZelptxf/JO/VQ4VhcRLWOU1WN9ynzBSL2RbB5CNccaCRxRYqucCWGBePkIMenyhoeHjIvFqClCOwQJshjX62k2eCqGt67C0o4cx9k5cVoapmlmJmvim4sjk1MHVurgR4W+LRw2QjTmEcIimq0ZuxiZ3WV7S7MaK8NcPbqNk7cOIXDH1vE2vylccJ9to7QrllbaOLqTy1j3yPrOHflBKYvbIscNxUVlL5p/3nE5uS5Yx5DiZPk05H+4kd7oWTL87vg9k1ZnbudaTp98sjrhsX2mwB8trc2vCS6ERDRKUJw/RcsRkJQT63hUGs00GozdlvrKryf1dUYJY5OJ48Tpd8bol6r47v/8b3ze2+h7rAfNODAsCytHqbkCqnzTDYdWd44lcXVqVIF5wlmCoercNDbmKlz93yf7n7zcRQNF4mx42Jk549ALl7Z10JW4iJ5bNq0QJX4w3IBVIHidEI4GkHLAJWnqiCl8q5IRTIl6MD04FLEwBC4KidPdkeW1+upaLfNFGW/oavSY8KidzjNzKe2MvoYZ+iCMZ+XuKHpcGPNYyELpNBYIFBAWmK/SZ6LTAMb1odCEWmvOR7sEw1E/jGTmiLnivhacxT/TWU8Mlyq0jkIaxbLkMnj8elBDY8OHdY9YVuklFR3HntzxhQxN0g85AombEXkSYmyVGUT6poPocAqNOmQPs703UXEKpYkGrN6MdlcvggnvBWF4AWN5xEio/JmPGPQqeHsNRO4/s/Oj/2CngUjCAdmTg/wvLedFjJrnqEWi2ZOSJjc3k5VcBXKQZWMQRhOevPHeea9njwUUXTm31uB6qFb44uCs6xByP3UK//Zyw6+7Vf++rOP/u0xdGfbFeVkF4+slmFz9XEIrBcuAIcOefyHf98LoZa7bnS7wPGTTfz6r3ewuLyJRiOLJ7aSh9h7uPEj8/snDvS3K09ecnqOtUYzucSwN8GkLUsY6bk722hGPRyyDL1Ojb7udx7B/PEeQvT8mCuy80dzo8DSgRbOXDsR/0yWyaKnp2hSkdLF1TvRVxwSNp94RiV5HXVotPb0qD+B6cPt15z8m9W31v5g4WwkEp3XC8uIoudIod6rLQIuzzk4L1PPM7ZKwqYnLBc5Httg/Ckcui5IZB3mM2B/RtibAXtrJSac5xo85YEFlQMNy/pPK7KBQgYjVAxdVgVMeF9DROdnbDMhRIOcHDic8IyAeqwWhM0C2KQ6tvVk2iTG3syjQz5eV6bYRD/JfUmQjhEpECf/tQRZJlm9S9CSfdLpa4kcRUcXXfqopliHU5+Yz7tnE5hCqPV8lItuT+TICo4t2PHYuSOsv6sLDVz3Fxdw621n8Kmv2Y+Fk1sgmzf69XlGdd8n5aSp1KqWvRG2U85vcne1w0tgg0ciirpisnMuQ2uijdnLJ76v3sXHhsNyKbkh7/IhccaPI+0typB/wZi5jJPB124aIfRvz4LDoatncPL4ErY3ZHZNTTfzE2eOvXLq8HX1Wr3ti/4wLnV26iI9gVV/N18RX3UHlYKtIbwWuG6gNpb2NnHL+8/h9nedxsqYtPqsGOGbba8N8alX7I/F4+yJLf2aRxrEOlI4Ilt5akFvtnOns3KKzjKj3s+Pf0q/YbpYtUZ1TjgPMKKdPo3QSrw8XSTIOeNTx4JgADFbC/tpJxTlThCM0IgNOTebHlj0Gfol8eeGYWLL8hDi9nPKqBnURATMNxgzzmMC4IYjqoUkYQTDsUD94ECK5VB09JkoPGdon2ywwxoT1rwogbYB2kbGw1DTZ6Fwiq9GochphwKIGC39kMRCnmKy8cAM2eKli1RJfX6gbzPyCsVJtjos2E1oMHsqV5zaqUj+nXSWLA7QXF/tqzR7f+UGkW5IZRJyygm4vdzH8Run+MRNU3T1J5ajFPyS2FWexSOgniE87yW/+xiCrf/yZW1Mne9DbUaS70/EvMkZvVXLDk2Q1vSnFI6ns0y4R3aAlWkp24YozgIG48hxt9ulE8ePflt/uPGfUZQfunBqPRUwl8L0eVzOSIiiWVv7yl/QV2IEP5F+b4B6u4PZqw9i4/RJtNptvOqf3Ht393A5v71VotOkIGeW9rwtW3oOVndJSqerqgqmNEV1pyBD6z2wOZVHc5177juGQTuP5LZxMbLzRyAibszUcPTWKdQ3hyq6zVOLJMD0TmtRr06hEdl14nk6ki+uiUV2IA/lqeaUq5tjBD+Mf5F4SZXHAXQCxtBbL/wKV224sWGQids72cZZocK2NjIVYmJCpMGlXecxmUVfP/LOU/DkCPyJgSf0vaNhLFg8NjxwdDuspjnnXjZrS9iNriBB5pNnsfBmNXBTPqjG2xAaFBxl4ScdR5VMMCttBuk8S08+DxWNp9CCsYDgODKptrR/P5IlYh8Om2sIpDM/Eg2YCIUX917ILO213RRf0I2wdDnxky86mKVFIX0vIteJPw7WJ+H+PnL7DK75y8VxIfIsGGEd3pqsYf5E8B45hj/6p9fzsEHkhjq/PY0QWL0a7Jh2zA4f0CwooaiLjYNZLMPCGwMOEjA6x1oKOw9fDj3ltRpqtQzf8drn3/r6rfs/dPLhI7ji1mlsUBcZdn8cyxOm9u72MewNMXl4DhPNLfjV7VrzwPB1EwuTMzyooRgMXez5aQSYbivEZt90EdOZKmJIPD6FmejVY1tSecPCtd2t872//zmaO7GFC1eMg/CeFSOgAStDPHLnLM4c6qK9PBB7dWYtQCA5eCZ/tXR5th8qXwjquZ4IJcp8JaOyepJYbekziIeSJW5VTYW44JUskmF7eZbio5J5mQLdR6t02XGdZM0pcuOi1lCiDMKjwtmMvenUiQKhtJ0pwTMIXZwABWEZDqhGGSmfqZceK/LoXqqBekGCnJEgQ+EtZmSuJkHSjBiskCHxTaRppR/PUC4QxtY1mQ5bim/CITiy8Z2eADzIJA7Rk4Us0kZDAhWfEiaummx66az6GH1phEF5IQVPHCrhsn20bN9asktTGMVo7OgsDej4DVNYOtBGa71Av737PSOe7SN6j+xv4vBHFnHjn5ynT3/tHp47tkXqn0eJia7pH3YnG0GQZU54oQZ6WSfMro/MoVs1DHqzwVHln1fmmOhOozlZ+27U/dt//EeKI0t7W3jr/VdjYaK36z//WIxYS8FfAsZm0J0hID/DfoGBy9FuN/CNL7uy1ej0797ue3TrdZSDIhlTW5LASGCpPhEpn0RmIsVShJ2SWUV4o0vV0r4mrvmrZbr1A2exsmfcnnnWDD3RHL11GsOGQ+6D64Bht+J15xNbQgBcr0RJ696xg2IlnoxdZDoOiWtRP/m4K8u/GUuJhCgqk8XiX5LaVxqGkXzJ8WFkcXKyU4r01as5pAkSyYLwrF3kpKCQKaztb1alcUWw5RwcSO/UjneGR+Zkk45llJXp8UpL62xAiwyKvmMB/fE+WqeUXhsgmTWuTO9ICdtmkwFrao9XJYvqnPVTI70/jZgTvgAnn6UUI0YtkQ9phMHlE5gpLVQaaZMZVYcsV5uoSt3Wz04um+3ZU4BXWBPqvYIXD7To+E1TuP3dp7HdaY2JrM+C4Z3DoJPj7rccx7Gbp9CbanBrfSitv5LVnFdOFNGDJlOqlirRnDo9xOwpGD8pidm1ty9t1HDDuBg/EMBVRu4cN2sNOv7Y+RfNTK1ce9ddOPK7H2cMl7cwKAe7/rPPAzO+1WLs3w+cOLEDrugrMEIban66oJd+9S304OG9/uP/4x2Yvmbf4en9Wbe3lccc8bLKESOyVSzlmlFa0KhSOnpZ08g2BFmmgvlSOwvhWXz3fccpAHRFMxsXI8+S0dgssLS/heM3T6KzOmCrMyrI3gzR41CMglI7QM7rZLKOuEiRWbA6TTqK9h4+xuFmmh1jJDkz6FKQjU04iJEmhbQCmYxHYif0KL3xxpj1GP2pSNCFii07smenvBUkkMXY1wK3eB7BCFXJQjBzJ5L7JL22rLcpETJ0xf2IF4PgFKyJ7BTff5oSKraVF039eDdCSDWaTTyK6ifltChKTrfyV6nWtOaLJNYEILGps1UjM3LMILMMSj37+D/OnrLqf5HQeuQjGHl0KO/42K0zdNMHz4WEwfjL47GzR7iHNmbqmD+2iee97SS99weu5cZGycRegU1ry+tNp5hoiglI7VBrilaVrc08NRJUYzWboNF3KAIurW6Je15xx1W/8dYHMXjetThQlig2Srh8d3vW5DMzJf7nhzpYWfG4554hVldxcQdiF456HRj0Mj52bBGPHltFudjHWV77wSnaO1l3LZSlT+K+pMiqLEnIJlMlp4hDz4nqsO3NaY+iL8U99x2nKz67GhN5x4XIs2OEHSkk9D547wKWL2vx1JltNfuX79+nCZH0G/8fe28CLGl2lQeec/8/X+bLt1a92pde1XtXr2paLdRIQkKYwGCCzQzGGCy2kcNgY4jAY489JmwPNo5hcIzDHnB4zIBnjACBQMIsQizWglpoa3VraXV3dS2v9qq3r5n/PRP3nvOd+z/B2GYCMZVP70rdXfWWzD//5d5zv/Mt7jNCYi6N4HPAdCbAlaLVfPF7yV9Pv8P+o9nS12PLS/SWOouxgxpc7sfs6sEMwaEz/OHj0SLd+r9QQNk0UP40AAAgAElEQVTXNaODCyVXjywgDMwqrhDEVmc23gWWe2NaARKwj8L+ZDHELYYWZbt7djt82ZHV554+bEZsOY4vczxUdezkVDjHerquLQ6xjbS3XjLVhs0O0Qy7X4nbetu6wTDKZz9WrUHTk15ZfaSlSv/GgM/fO00X756ioy+u5HC2Pf7IzT+yuuZQj06993JyW+Yzj+yn6SubqooqqKQVpDD8Qc9Gh7quWvGibPI0X0B6Q/gN61zme28oCXmsaGauT+PCX/uvfnTj/zyyeHn70KEurV3fzC3J3TzqyclI82cr+rEfO0hve9t1euDBLVpZ2d303clJogvzQh94//Ny5uU1+r5/+CY69sjWl6+tDGiyO0XDwcDTnhnGSEFvvGCTTWw5SSK8VBR1ds+J9MWUTzE3v06P/NZFWpsZ2/MdGKFRDxpan+nQC6+Zo2pbfTaUxtyadyzqX/s1VB4crTt0QgrsJFW21Nd8izTaTlA/8VY9YmRWNCSYUbJksoVFQAO309aMeaUWbxvyw6BSOsPwxoodaX3XdCMBvyJAgMQ4U8GLFZHizOrBS8TuQyIudZdWbELLPKzNOy0iIxROdn5boAxBnASNZfTnS6w4CNp9UqlC8OQbVBDs6qbQntpQoSnlxmWaYBxSoQExnHSdt1KAlFLiWB+30pNZbzd041CXPvfkHN3y/OJeITJCY9Cr8kbkyV85T+cfmKZhLxAPFB3R3DFUH9y6f3dsR3JrPxibC3eab0HwUKPTKMLJAC10OzQ1vo/ObJ5509zs5vGzv/qp05cnx0yVt7vPeZ08vfbtb6jf79DP/uw0TUysZe4l7eIirDsW6Nr1AV25fC3/ffZY9+mJCTqwvd3N7kwNSahbEf8WvNv2JCij5bTpG1nRHI7UT9yYqul1P/8KTV3bymS2PVRkRAYTTSxs08uPzdGlO6ZpYnFbyWZ2sRkQGHFL7q0PDQoJJTcqE1+UO691gnBJsWWnglAgclpqKPeae3ew2afn6IDGGSC6LEq7j2iv5wsn+WQJzgOcXX1CVf3NTrSGUEBZNnEQD/ArknfN6HA/neJzUlZ+tykGIZVQSRUJJFAkU55lfm1wZNuLCzRItPwJrcIAtvXlM+XPFdG3FzHiDvlbZtIiJ7c1hdotBg1clZakMl/AoP6ymvRrHBkLYgW8Y2fPEJxANLk0pLMPztL1Y+M0vtrsEVlHZKR5euVAl459boXu/sPr9PE3HaGD59ZJaiVLG//bze4IAGUwClG2idd+p9XO4K+7YzfasErvVtxEmsjDQZcm9/f7f/Xvv/Ghn/6R951euLaw827cpSMTWNPJGh9vqNtlGgxmWtu03Tm2twNNTAzpwL4Ora9v0vz5l9964NSt02PdySjbMgzCHdS4WapFpjEILbklmIKhjc2Bw6apvcmt886PLNBD77mcbaH3CpERGgkZaITOPrQvh+OFoU005PdCWXSseM8FhxWwREW/oTNSQ/pLBeQtpQZImMK+lQdRotXcsJqh9VXy8qV8IZrZnqEUDFvrqH4lUrldPYll0cDNNYijLoBIMhJjVFENB8MlLCWQruOaUN3ymHSRWbACztngRXwG2EHbLkg19caQyaXbJB3Es7ckkxHiIXtBLs0gmOBaXFC7tcqlh0+tzwwEvQBfdvyaB2HFh4BoC+FNYLBIOGuioeQZWxtmA7Rz98/SI7+9R2QdpZHuu+1eRV/yK/N09sF9tD4zRuPL25l0CNSTQkvRwG2PkVYN7sbctrH1Gt2jCvCrNGyiNFtbTW+yV8vhwffNHgi/L1vdxX2HxmmwLbS55d6Iu27UqRBJypJ0YqtKg/F2/2hoMBhSvz9G3/29b6GpU8t3r603ND1ZN8O4laIyOEY0BLGhQ8Neipujw8fkkyOIS4MJlu7mgJ/65bP5phx290irozS66w0tHO9TUkP0l7aVfIiFLIAcQb7bt42189VgtoVJiMBqxkKsBiSsel8C70A7yPAv8TUPLGn8oC6vjMohttweS+NhR48DasTA0d4abM5YkqSlfB5oS9Q/TCPxUIi0giBz66hBWBjWeKQCApi2gil4fsdOzopRXgja3ujdkcjYddqbaRo2AbHZCeC66LfAGZnbksqz1DmpcntV2zh6rbRAU8oLu1OmFycSvahjLvogcWFOO3zEdsfBIXj9IdFU+XMPz9IDf3BFE573svNGYqQrvOZk1vP0W997F/WSRbC1B72o9Hu59BzJHPh0Y9q61wNIsGGHU46WxSHzkFIy1GAQaHXtxuu/7dvvO/Sbbz+9OH91mTiM0YH94lPCbhvJZ4XW1ipaWKi0PbPLR9MIdTqB7rvnCP3RR69QdevEY5Mn6ejyatr1DauY3KTyKpDA2AAHVWgKy9KDrZjobAuiX2P6v+VD4/zat5+lk88t7Vm+j9hIi0lqy6Re/9Vj4zR7caPYy7B6OeufMCng+reCfB0VyYiBZcUSvBr1R6yloeTHRH9US5r8zcrKAQEeAdp0g9wuNiZDWu1UydWmeLbC6LJWxlzHkKzbghKs2EFjKDoO03IcVrZpOt6gumA3ns3FeaK6BvbsarN28zh+tpMmirSIT9CeEROVaCEmr3ETY7i/5d9PGEvgiJpL0RQUgAaBiFt0Ryea5g8QNMJMQ3QUimGBvFfrB7byxykuKI7s+vr1UwgF6BVyH4wXEJHqypo3Grm/sCnn7pnhy7dP0qFXVmltj8g6MiPN28mK4dTvXKKXnpij0w/N0L7zG6mzkojgtn/QyUCR9JgvvFEMvXnKDqfbs2ZiumjcElVf6fNUd6oqbjONT/bGb3v6zju3fmX+hfn5FXrLX6jpO//akC5f3p23T33gwJBe/7oVunp1ihKZNezyqh3uBQcPXKeTx6/T6Suf+YGJ7aO3jY9Ppzxnzvs8qYmz5bYi086mRxyIwBi4cPMwp9X55u3T8c+s0qvfdTEz6Nuo+t64+UfVxNzbf/nROSWgBd8D65oKA2hTciQChzgznrzwVJaHValgeTLwXd4ZtpdXTHsv72KYj2MwQWH6Ngdq8R7U+yans2jPBRVz8N8Xv1e5vYCiWFI0AKyonOQX8TOi6AnW+VyItTgpimQrRCRmvqDyGrxrsBRTsu9HhpDHRMW6y4vk6E8bAiLdDihIYWapILXC+0cFO/b50heqQnwVm94DCLsEdCbgmZRgPiieb+bEMBR0xg/KZzoGQE/OWOcSnMyWm1nkRzo51IMoNw6MySuP7AsnP7NEq3vzwUiNbMWwNKDX/vwZunTn/bQ11aHuqloXq6ND9tpRWpJDk4xeqBbXjrphpPtd+UPINmsEFQ1xb2xceHKaX7525bs+d3rpg7PTtPjXvn1IJ0+mKJM/Ho20G0ad4KC/9Jc26fiJTYLh6G4f62tEJ44R7TvcoV/82MpjyzdO0IGDHWmaLfL2cxZPCKynQmBxuNm8DVSyZaGkuDe2+nW2D3/j//Ey9VYHtHB0PHMP9sbojExcfXQ/nXlwWiYXtsgsL5DLaiRU7V8oxSOoj2LKvkrLZwDAEF3y546hSBbPt0R26Mib/ryxjpHQQU5GN8JNNBZGblJzE7UQZoTlGdkjcgjgRUa1TY8Clwx17Mo1Toi6jRM2CDlbvFqWcGTnW2Qinb6/svBsyTXgBIIdsc/LEXoyK6+iYRKpKnNxvLI9lfPCSuor9oCuRzPTBopqnd0EjToOMGr18iqf99iuYPKTW5kzKhgmbpwS9fi83Razdb+ydjlbgrCT1IEQG0c3sDqExNKmQbsOb5V/n21+KAtFFD3DVeivDujFL9lPD/zB5dwCTEmxe2M0BqS+J55foi/9+bP0nrfemf2HvB2ofXsGqqhwiGDFEMSnKisMW4+07Y0RkF6qmyNI0Y1IqHvSm5io5uc//fUxDP7R7Ey1eOftHXruOaIzZyP1eruwGLl+PVC3S3TvvR5Su6tH+qyba0T/0z8Zo/u/+su/fOL48ICspyk1xMEw20BZinjOAgimF7fkCex2cIYiYrtsPhJeOtijL/35M3Trcwt09eTEXiEygiMVk8kbYnsihKmFpK2qtGyQwFXiGFRaVKiHogq61QvMvJ0tgK4Yg7Du4qOwox7pdXRr7/FaybYrm2uwwKDLgu40EC4F0ljOnRImxSIH8l+0V+C7L0b3yACO7LDMJoVtjJzKDOWLIF2UDeqrHB7ItQZWWA3pgxVsAlJd0Kq9oKCpG5SzbTzW2t4kmOGs99sBAGVz2lwQhOLNYoIE5f/mZhCwl6hnLWZIKFnaFygK3A1trGuHHrJdgzhzNIhWFcE9TiQHh7IqeAS9fhaoh1qCKZzpbKiivrdaHkXOJNfgvBm8fk59lmvHJ/jMg7P00Hsu7RUjIzeElg736KHfukSnH9lHrzy2j2bn1zN3XRE8zrifQImmDwhbB08BedEUqWBZBDEKwxsic8T84Y4sseFB8hw5ME1/858+ff+v/cvnn/2lt0/SuYsD/uQnl2ViYvcludS//MuBjhwieuIJohs3boIj+gKPmVmmzzwv9B9+tqGvPjb8vjfdNnukPz4Wm7hlCRcVhIQGrptiQABeS+n6WZ84b/JiQ6v7e3T8Myv02H+6SCtz3S8GNdauG2l1TgtFSlTubDYE3gOBSWH77Wic5jR3NEIWOKGTCRZ9RqNESkcF85VBDsxQqUg0jBcCUteLIuxGWQjaO1Qfesi7TGKTkzAq1oaPHbIrbxLdw/zExDrdSNNL7quGwJi815mwbk3v1FytjizUr84Lc5N9PqLHqwMuzCiNIhrqfk06ccMUDCOfu/zLWjWlvntWLESFkGKj5ZL9PmoENswIZm9S2mnuj2pzvRiI4byv1vWkjGAEax0xIBhF2blKO1jz0w8MZq150GXEiY0j0lIBQUAM5ZQy4lNMkFy7ZeLzebd7YwRGeo6S9wgl75F3nKNz90zTVr9D3c0Bcp2LM6u5KAeT/8bW9W5535A2eQVRBkiUyoV5w00ucWanD9LwFnnr+mDt937mZ1YunbhtOj+ca2u7L7ulHgyFfuInoKr/YhlNbtfNzVy8f6xziGLsycb2Jms0QbTAMHaprsoeoZN0mZbmj9u0nwrbYZfosV+fp8kbW4qK7JFWR26kULOrt07QxTunqL9sZM2QSWkGI4ADaQt2DIKmhDreRUSUOGTr/h9FE2rGXoHMqku7NX6yjE+hkfWpF5QX2woO6KU3odJc0rYDZOaFZI12jL4cBxikMdK+4ONqiegl48Uz6j7f4cAMn1B4NGLYATMaMlqMgBkqyN9R1IDt6AUGcHZ8uaCxaSg1ZyyYV11uLWSvJVnS3WRKF1fMyaWRO6YxqHcEwTymnHEFHF7OzGNdfURqrV9hiWGrNUCN1f2tC53UDx8ROvaRjFdm1z8GCmPrQ7pxfDwb6VWDmFO798bojPT8Lx/q0snnl+jR37hIz3zDLdS9MCQyHx4CM0zDjjKJqSmikGLXKuxqN6wvao0WYVwYYoxUx4qqukfzN869eXOweezKjdVLm836jpliN416vB8o9saoGX4R8EWYaXN9O+/ovvWHX3Pq9gd7s1srkepavZ2JVOYMKJa9W267wmC9eFHqHmxaE2l14UhXDr+0wrd/bIGWD/T2CpERHKlYSDyfBKUvH+zSgQtb7gMQLLXOJx0jMusyZgWFcjSLVNYfKDF3U1Xjoj6xksNZ9WAe4fsGnXDYcSvZa8IN1tRbYDTBYAkO8Dv+JVJcz3PxEoqRmOEVETlfUUHmCkgJ9KpGyQMaQIZ4NPicYJ5EciTBHSvNnCWT/na0O8t5snZT4bO6My000dFlwDCeYi5ZDcjDcWowFx6HqoOiHV8wkzTfTBQyccDRBCvpYmbDRPJqrSiQ3L22TVA0B11OM432fxordC/cNZn/Sf5Di4d7e54jIzbS5dqY6tD9779Kz735KG1MjlFvbdvrzh0UksDl+WTLJhJ4GNrdZZIw0S2HW+flZ2uonPb+VEXf/iNP3/5L/8uzHz39/DwdOjJZ3At30ciNp6oOVO2+FtQfH2mt6FQ0c7BHJx+e/NszhyePx7WKYtNYxpfp/WxLCHdF2wVqv88gat+lcaDtfpX3ik++c56668NsdrYn5R290dlqcnvtzKP7qbcxVJmetyaM5ABFbbTAOC42H5rGaUnOigooEJtNkqQoSRxoyAwD8113QUshbnmvhbCnsmFEppbra96ouwGwOYFk9mTp9OQCyFglAd+3touSWEuWi8nGCBNrLlqCuo9qCqRAf2PFO3kTE46kEOWAv1qcUljJHvpOBlhbkSBEdYCrrR4eoG7bG1AEZIPP54XLTtcGJucHZtRFd6HlHKs/oQURqo7Gj5GNKCatz8hW1Xi6EGIBHDAtagn9vDGjNwLH3cg07HXolUf306v+aGGvEBnBkSM+ZjTi49R7LtIHv/lW6q0P/fbwBikMIUKxoCF/rqyejeVZcb899arJ5DBpmsB1aGamJqupyc7fCePNM7eemD43d6BPK6vbFKrdhazV45NfPJr3zfUBzR2epr/6998wPTa19BWrC0Oamp6SZjhIFzY3giOX3ZgHjhLkWi43yKtN3lw2RIsHu/LUL5zhe99/ja6d2PMUGcWRLm9qrz3/xiN04VXTNHN1nSB6VUgjWEVqefIQ2OqKa+KqXK1agJ64fBbyPtH7i+FCIgELob2+4RPwG8hD+POeTwREC/KAbQTDBTSkRQhgRrCeQyutABAxgdeguzZB1DT8UWinhaSYuyxbSj8kw5lrgZ5m3LldY4EHCNpVwfXw7kmiJBfo1IynQs6cwRFB0swtRqkIe01gP8mW2+eoBxtjBBojNhRLP38ghjgHuA9QFuxR2dgfhdfqxRgkwvBs1U6uObLmsMyg9GB7/cmFbXrpsQP0wJ1X8oKWFra9MVojXem1mQ499Ytn6fKdk3Tm4f0ye2Gdk1U8ei6YGgzrFPPsYc2+Dqhr0VM1ibiRxCXkDOtsP9pUUnem6cwr55/q9uiuhx89ce7K9ZVcjNS7LDiv7ox9MUAiOgaDhsbGazp82/4ntrqDyWar1gJWPY1MN+ghWykbL7fBYwt49RY7cawi8cqBDh/73DI/8WvztLJvLwhvVEe6yKmH/8rDs9pUySTUEt7KxeXL6JhK36h0nQrKOyNgDihBVCGCHBkDMmIhO4pRFVj8DtPFMGobAg7r/poggDJZ0IqvnNGmPEvoS38V1cQa81TlrMa+sIwcYTNaCyjAnd0JyifyD/zCCsyJ0QXnNtjTNl7Dds+KBzJib+bWROvpkGl9Pa2Ok6rYc/rJHkIwPRrz7lCZDMQwqKj0MsUsUyoIiDjYqfRd5eDAMdXKNgBNXmKValDEzViyWkh/GMef09DATtGbwt1wg0uNkFRcb0a6dnySzjw0S8dfWKK12c7efDFiI12vrfGa+ssDeu0vnKX5u6Z5ux9obDMzn0gguU/3p8CNytO5DcQzc2Gz2QvEvjHILdJECReSYUNVYlBNjNf0TX/76Qd/+6deeu/LL12g6blx2t5l9029vrpxExzGn8/YWh/QYmw6Z19++W8eOzUzG6hLsRlGdcRW/ZUixLo6JLVhMFJaTH+NJmewpnkzJjzskDz5jnM8vjKg68f7e1yRER3jywO6cvsknb9vWiaXBgWy5wDQPwP7WmooKRNeFkxUaKggPOaBNoEJXAIEISbVbQAq6GsbJ58FbYhUD2Qnrx2hvtpQ+byEYOzOxXUxbreaixDjRyBdT+sLFSbrFCitXBg24qktyyEUQQ8BUxHzYgtQuHvPiL16IlvGIX8311knnpj4GRoeO8/uvJofplaGTZq3A2iysLetzDw1lowbIB8AczTCXZQkg86UKeX8suHXyMs7dsQLzmrFHB6XWvTraBWJ11ZAZtJWOJj4TttCIbcAz5yaoYffM5YM0aip94isozaCObOe+NQSPfYbF+gD33xSDpxbd2PBuKNtp7W2K/VLOpM+H9HzH1Uhl38nagGblW4VTUxOcl1V38X1ld/odJde4GqLdhuPtV5Npk5fJGM4aKiqubs5WHm81z1MDXckDhqG8NJCI9jT8IJYxleQ0qFROC3Ehq8fmaBTv3OZ7/7gNVo8ukdaHdWRiatrg7xbXZ0bz/B5dCPTRlUwiMcPCJ5xBUlxWBeGMsNNoMW5A4HdPz66h1gw7oKpOVohW8pJAiPCGZpQD2LBxOafiFqGSgZmMHxHGP6utBPj2JFXl61T4RDb4r0CPpbsgR2U3G3VCQucJa3+YS9UmKRyeKEV2EeuHbIOjSUMtj6895QkoK0UzZUsMM5pXuyD5dfpdxw7MdqxIVrRWkAeZgekxh3UGGkzMPq32ikimidfHCiFzLuKHRUCEGJesOw2Jt7IUfaQkYsmlgZ0+VVTNH/3NN2RCO+Hul80rfLdNpLD9uO/Pk8vPzrLN45N8sz1zdzyDEa0dt6UcYYkSOuJE2spejqTFv8seMyDWkpUUap+tbB45dQP/eDa7f/xf5MXnv3sBs3M7K6TWc8dmboJDuMLP1Ih0mwzff3bnnzV0TvGpjbXIvXGktNjVJeDPCtGTILeysvzUY4zN0KcqOnT6myPpq8N6MlfOZcJrDEUme/eGK1Rbze0NjtGZx/YJ521IZZ3FhfAYgVnRuQE5L0ezCbInc94fmGjelMDMk9S59CA4NzSGQDjwFW/uoAraoA832jEfQhGIpd71fsMLDALc7xDLPsuagMmWskE9U2V7urgMXGl222QcsjPR0MhFSQSpGF9BavJtNiJgu6TuJmbGZ+xe5+wtljcldLW9iYTOtjEPCC5tKozI4wiew+ipYgNYhTreGHHyR4YSK3Cx2Eje9US5OsM5dDY8RlgoQrkoiTyQk2pY2AGGSwl1saBzlfw4/kA049WQ5KtXs1nHp6luz58vXV/7Y1RGulx2phUMutr3nGe3vl37qPBWMhoF2sZa/wxNvVMtI4hI44KDU5/PoOnJNnzlxyumijdUGefk9Wpp27/+HPvp89+bonGdplvXl3Eirt5WNEhkeZu7Xzf1L7+TDOokwNeCnYPFuUVHRyH4VlsG16BECgU60Cbkx36sp/6HM2dX6frJyb2SKsjOjJxdWGbXnxiTi7eOSkTS9tcjMEZzs7ESJ+JCESzPTEC1TyoxPgOvs4pzSDvu0M0B/SAJgLconW5E892cVWrNVHYDToceQHVwS1Xo/cIIqMmMTIGOiVgd4gF5siO8FGGI4cNfMsErqz690iw4SFbcwtFhoE222rvzaxita4/3ioC9GuWiQXeBsOt7Y8xUTx2zAscUyHoewVk/OnLlYWe23/2JpywJwpR+aKfqHJqiucKGLmF44MiJZQFBGexRYxtW50JTywnJG6fXD/Z5/7SgDZ3oaPmF8PI7ZrDPbrnQ9fp4fdekme/4igfmF9T1VmWkSNkEgbAeDAKSdu6wRZ/ZICJlthmkCyh2+vEhibCs2erb1moJ36ms3+w0Z/ukeyidadeuLR2ExzGF3ak22E4jDSzf5wuX7/wZYf5bup0O8Nme8hB00LFvQsaUTyX4AMlFscK8yWhxbmU4nhRHvmtC7x4eE/GO8ojWLzcC08d4EE3+ZtlPYeVCrqfNv5FEOdJmnYmgnepJb1E79cQ6Kl5SHTfc2D6qBDc+hwpuZDGptpZE+eMgiquYTVKZ7RV19ktWGmxnqLQCKrc8bIhApZATWK2ZVSqCm/25D4ImKzQjLhfGvvuzgqIluRMhHCEJdw//3LT0tQQkiaD5tlFmMuq+khn7UKpgH29IQ2MuD21HBHzEWF1gDPyDTJDSmqxduz16GBiS+zuInq+lXcaPBGP8G0YzAnqs+A9KM3lyRWnW+4CncIBoC04lOsn+vziE3P0ml86RxuT9R6RdURH2pym6/f0/3WGr946STdO9Gnixra25pycXdq2ufkP61W0Ep0L3trWGCE7TUoSm8EYjXV7k0uv/8affvNt/+lH//DTNz57hbrTY7vmPNa7HR9Ms8FwmEVS9HVvffLUHQ9OHNxcb6jfa5LZTDZqNrK9RSgGp7gp7QyOSboNHXQrGttq6KH3XuSmw1mBsVeMjO5IxONEXJ2/d4YmbgxQDJgFHrc6b+yqEkc1dFqxhcoSdiNMs7Q/4XEqQOyVb+L0DYkOfrBanrOpVvWey3SKrJxhMKcVGIiarO+UjVbHyFoFFopjnNayijNIUVy+1FpwC+lOmw4SiwbWV9dYai2vwOxcMYol1x0BloiGCdkROMM2lyPR6rOoxFqPvgUuFZhRMYn1vEB8RaUg/i+2XhD81YK1kwS2Ki55S1bzDEayWagGPbPt6w8ZFco+Pe5otF8kR7QtvUtxl7tQgQFCWc8qEo1tDOmVhzSrph4INfVes2YUR5r/16c7dPDsGj327nl69/ffI32AggAbhRwdJLQscw0bgbuaPbPjcubzo/fKcLupQt2l/niPZuvul8n51U8vnVmksV2khq3HJ3Zh/F9r5PyQZGDVROod3vzBqcMHDmytdqgZSGUhF9pDtl2fVHlmtOk0GGwbo8WR0dLhLp16z2U6+uIaLR/s7RUiIzzS9e6tDunMgzOyvL/H++fXNfJWTM6NzkcUZFw5EN9q87ORzrRtUSmbIdou2FwnbO2NBBPSvLl2Ky/tExaxn7kgGSySAQMDASL4LNT6VTBCcYTidmU4Vq2powl0WF1FpW1wYKZnvncXxQ6kfE44moopdjPEYdhKFHNj8Z9Glp4hKVKIok7uhEOqmosENXIJqJO4+L/FHB6jeFTQJR/iFWwmTVLLRZgPPxEyCa/lxMAtN4bApYliDZloZ8ZDgYxx07KL0RLLxL1G69EbhLLdfo4DgOhGQOPx2kSKroj6iwO6dOdkJrLe/vE9Iusoj2DJvrd/YoGS1UPa4Mxc2cxG3YVSblxmoCQmjQOF27jt+DHDGdM9xjEFmHDoUN3p0LXPvvyX1xaWfoGIboTO5/sQje6oxyfGd+XNYQJAapqGOtZtMf4AACAASURBVPUYfd1ffwMdunX1/o3lder3Dsv21sDuA2xzxUUBNs+oL5Xyn/NMvTpd8/SlzUxaHXaDcu33Jo+RHYlolnwezj40S53NodmxRzGPkaTJ1IUX6H4LTNW1laOGzMJj0VS9xUjEza7Qe9G1kNHp8OAW2bHqa9S9mFwETEkptytBhx5MIyIGySD8Qgw40Y9gAuHW74N3WdgpsSS2OEkUUIf+L0AnVLRlaD/YYeofskdKgNAVikWwSaVtFwbMIJSejL+dGbiw9kHg9047HD1AIzFRguExMG8DZ0ZTccTTZxzOMl8HUUcUdYG1nlSuQ6JonCEERJFybLOuJAwCC/ip+jUEBGnlxYZuRY8USnudLPKUaki01a85qbju/MgXQUrpLh+JYJr4Z6/+tQv0rr91T1oj8jXeERlh8jRXuGH90YcgP1veJiaXyIVcw6S1rDtG63H9canjbCpGtjeaXRPjUl8+v3oTHMYXaqQd0VaepY7d379z9mSY2V5JSaJppmxsdmVL7NSIct2JKiItRdWX/5UUF6/7qRfpwNl1unbLHml11EciDp5+ZD9dvmOK+yvbxcOLXVCb2xS+zgmZqkq7HrkEMLpAm7KJrTlRUeToDAT5RbFKRxGhDu/wMAtqL2CQXGVJvelmrLhVj6DWAf8em/V0Xzfq9qgtHccSnL8Z4QHp4ExJx2O3rxb1Ww368ZLIpIJekYtPCeoKbQ4FQ14sj8NNjSX3SpItSDRTN6PfWh3hZ8r6OIRgvWw+KDtEPmb8ZnqZbPZhTF3QUWPLyx1aIov409pCqbj5Q+aIBw0786oqtjRK6D9ZqHB2nhGUcLarJUXc89sFZPhI5upELtgKBDhs+X7ZOOvcqRlaONqj7nqTE6P3xmiOtB4sHezSPR+8Si89to+e/YojdPDMul5z64oGTb9kQyTJsbP8/MS87w3o2GRAFNyrJFofEG0J9Wcnpr7lh15/+6/85Edfnj99lSZmdkd3o/5HP7o7fUbm5og+9KGa/u+fm6KJiSHNX3r5b0/eefjuse4UNXEA9n4uQPJsmfBfi/QMtjuLpHtjbkgWTnblng9f51O/cznDcXuFyIiPFHC4HenC3VNZyTC+NIDfaIbUqjQHqFo0GDJvG+ZCJIURqNYe7HRQMsxVEIbncTPBGxQE0qpTCzT1iIwAYhYYwTkORscka0U4xqAjIw8cGYeZs/t1wRNjaSLhRailBQGZTuEHRx8IWS4eOSMtHMDTbbXr5IRvCwRT0mc0bKVoj/RACXkzbVIOW4iY1zkkWK2txRO9yIkZZMmPnzZPtYEl6MmoMoG1LbVTyQI+T8KJVLWgVwzwFji+RlQ3fmv+nQjbVvR/9DOGEv8LQ35q5/NwhHpJRZtKT7HCM8094ysN3Tjezx43j/zWpb1iZMRHrFJWWU1PveMcnb9/mldna5paGFCsquKIFyyJ0iaXiNCHUBXCeYRQTxA0YZSximb3TfJML76NO9sfEZHF4VBoc9OtBUd21N/2rbtrUU2T6PY20eQU0dHDDf3Ob/boO7/3LTR+3/U3rC1v8uzkzHDYDEPqUedKNO8GK4aPwE7+mXBoEpTf5amrm/GN//7lfCMlOG6vGBntUQ2UdHbl9knpbAxUcQFvCDNFVM5GlIb1brEURbE1Nm9yFLIAhwMgAeoMIxwJ0m0EauDE3ghFvmJ7bLIUWAMkcnZNVFVJMApThP0F0vC0AigFknZ5ooX8w6CNITs2Yy74pJizubEz3b5UcAS64Ee2XZsbkAqQi1yvw54HUyH0xuorxhG8jahBe1x8UuzNiySHYEtmUht3s4TIJbCbjoFE6l7vrFb42kVKFWUuOhI2w+xhfgQoJtcg+S/B9C5QWbubScyZyTFCC6W4SsxX1JVE6R2CaZes3RbEsnuSfwobilTENGRnMSg5KV35S3dMjvZKsjfySDdAigU5cH6d3vCzp+ldP3BP9h4JQzVetpgiff4UCSHMAiAi5ac1oBccROOl9LGtOhXXnT6dO//y14z1+QQRL26sbFG3C1+b0b0O9Wdf2F1PwHBAtG+f0PQU0f33Rto3d52WZztfObe/OrS2krYkIU0ldZ5LuFKrvLzLjEncna9n4/aPTFIzbc5U9PRPnw5zqT1z6157ZuQHE/UXt/Nu9OKdU9Rf3vYihH2dZ43Yz0hZppzqmoNuTAmAc3ORzHtmpLmw4yyKSUQqu/QQIIFRo0aQ1SwKh4NZi0SCGAV0g/QOjb22vXBhsJnGRBi2BiVwRZytKSpWhtQ2WEtFd2NibarSR4LxV0st49iIyYwV5Yi2hAc1AOR2Owra38qwEztLAZk9YIgobUdDbks0ngSwVb1maDWqYIQC1S6zFS8m/E0nwyxX1TlOs/7Mfl7JOD7zg61ijZ1ieMflDLOXXtrNZwTtpEtREY7PK62i4LGYCbyUdtA4oyPXbpukxYO9nG+y3dtDR0Z5JDLrwpEe3fPB63T60Wu5XTN3blW06RIAyXktTS1HnGwTZKFOttmx51NFFWmX0DQVTeyb6HzLD73+oX/y1o8+95bXnKW/9cMNzV8Oo12M/OA/OHQTHMaf3djYYDpxbEhf+fp1euWlIV261qGV5qXvGjT9g73ubJQYBUaTlqBu0y0sqcsOjYdEi8fH6Y6P3ki277R4ZK89s1tGIq++8tB+2pqseWJp2ywxUC8I0nl32IMp1wKWp6mjG5CCBnPTrFEVxqQArCDrR6XJyzE204ys3tLBENeBWptD0RRdtAz9N2WPBF+4kelieY+EY3LnLfJOkdEnnGMS4JNqYTQBLqX2gSrIhCEaUkdZaJfNnAOqHCnYg70+NCQg64l/j4xVq1SVSMiUi776qwW/H58BM1bSGVVUd5XO9GOk+HJWQnFTeYGh/w3KDIliDioV6dWyZzqUKNWWTRtKHjbmiwNR+vnMW8XowBHfaJ94tIjQhso4ilWHSdG1MaArt07Quftn6KHfvURbR8f3iPEjPmLFuf37xDvPZ/n22nSH+ivDXFK4iFxCcRZxERi6gazPJ4H4qm3UqAhq7PWnwnasvufUY1u//90/wPMTB3skC0xjI2w7Up89v7uc/0JFdP5CRe//7TRT1PQD//zLwuFTi/dvrQlNTvUGMoy1NsTNKsBoaGk3CoacZebRxkRNnc0BveYd5/J8POzutWd2wxhbb2jh6Dide3CGxleGpqtLS5OzG6QYBECTWRAIJUUEZ4OqXBTCFCOreroeNt6irl55mOqFIbthzUGx3rBYWi1cklDXWLynG0abztQzchlJ+WZlAG2xFH6LeBuSldFgzYWSI1yWVgvTgA+9Uh5sahTXA1nhwoYqihcu1h5yZTEb+yMTTmEQH4wPw9mX3pveEnGEGeuIsVRVoI7GYECMEs9DS8BElXV2rDIpvByT3aSE9owQQYML9QsuD64kbCF0umiXWnhNw9sdKGldEUFJCCcStKRy+iG0zsQgrWVV1/3vu6JGfHstm5Ee6QlYS+2as2u5IPnt77mDe6sNMUNJY2U6u6GyMs3JYT1BNQ+Kq/5IJB7j4XA4Pra2NP+af/OvNw8t3//G+f/xH0dae+Uq9ac7I3va6v747ltcc2bA9hb1xjbp0N3Tj3Wnh/uHi8M0idQNR7T/dQ6IjOa5Jq9G7cmnqW71QCe7I97y3CJdP9nfK0R2wUhzwMTCNr38+GG6fmuXZi5tKXpPgRtrzGaOWbD8tRjIMuascGUKiUNRNflkiGUXQSDO2PVw4+0ecCQETNCMeMT0QkmfkiATkDgZVHv9fvbl8xj+aPTPIGp6E8lFtVhHFZgxnkibxyEBtA24mqrGOHqCP3sryf3oKxPPCjmLDv+3kJyMDjlfhZFjQ/bZDD3QvFxKU3GqKypFLkySDK0J0opV4ogX0qhTlFJqvxCyTjka16Pydb9BIJ6VNJEb/fBZkmTHmQ1aLf3BfxqxPTCZTazYaKGp2J0GD87gnal/9hn1WhQPGJB2A0PGY98X+MCU+NYUnredkZGEkKSIifXZ3eOs+cU62LxHHnrvJTr9+H46fWqWZi9vKCjHuJuCQ4jRGp4BWUrFI88iBvR+q2KoOyFSbzZ0FyfeeNtP/Q/XP/ax37tCB+cqWrgyGNmzXe+m5L9k5Z56cF/6F++sXvjQ+Wb+0xfp3LmXv/+W2ekjvd4UyTBNTimFtcL8qe3hvDNrOTAQ8fpMLTNXt+jU713hjamO9473xmiP0CgB+fSj+w0SYLZ6NKtn2EBUmyrEPUuJDN63iaEBQgIGpifZkBcdBku0Yu10SQ+adpd296oshSGX8i8gI1ZM142yNFRPo6EZ3QQ3KyOyMK488lKYnS9y68bS8HIvqlHlupE5BAKRwPD8+hMi9gPwH/ii6pfB8I+VARUWQcqqBghBG0k5LKzRXkUARqKHqSybXByZXNfAG5PGwiNMfQijNlocQVH1shUenmbjrdZgG8qG7YT5J4D+Wju1zi9JjbT8m9HgkODnH8nJwbgu3nWy2Hft55shBE5RmlqisEPvpTy1zTGrQZoQdTYaun6iT688so+Ov7BCa/v2PIx2w1DvkS167N0X6PQDszLoBB5rwBNRxA12xsrFNt4YYh1E8xBAIc+BCVKFTt2h7vgUfeD5ybc98/YPfGjlzJULYW58pLNq6qefXL8JDuPPZqTFZDAQ+u/+8vn4c9cG9PRjT44fO9G8bntzSOP9njTNAPsvvbB57mxM9KheipXx9zamxui1b3+J9l9YpxtH+3uJvLth5FC8LTr3wGzu405eGzKBaGDtl4Cw5sa7BKJSf1sznaxa6doWGkKOipQoFuWJRq1XdnBRUHiU8DyFB6SFOuguyaiaRirVpAsCEUWsLWLBKuCJCD4AgvXVHVQtOcQIl1rYBFtKG+1Q4vU4GHEO3YXo6g+GbUpQoYmmWSevkkDwlcwrrRY2KYUys7ACe2Ju9qJN7bDGqBXBehLSZLTI3qkgCPlVG/IFPB+/ssyVBagwCVmSD7uiSEDRsABkrytV1dAgBJOHxKLcEiXwGGsVZUgwmbVWdpZgI25el65fELdXgy1LXlis1RW1ekEQUWYUKQVGI3L8xKVoghefPEAP/MEVGtto8kK2N0Z7AB257dkFeuAPLtMn3nKYDs+vp/xre7KE0L6Fh7I1Ce2LikASELqMng4jcy39ydlqZe3sm/edlLsungkXVhY2KCaeVyvMaZRG/czH+7vmdk/FSJpEO795Up575Rp9/Xccec3E/o2Zra2OVqCp4gjBmeyGvrvMME95KYXx6CS96iM3+JHfukAr+7ujrZfaGztG8hY5/fA+2pwYo4mF9UwUMaN2s9SM7o+qjoiuUMkvU0iZyjNg2PAGa78IPDxVugl3Dt3UqC1FiGq6lYH7hj2yJliDQY8BNhtIx8dfQqFNwEMLTmUtp1YGSgBHdTb9bfFh1c/qFmVaiOQNfwO5raILUkivFtvPxpHR9oWV93pWsgVryHTwoUmBsnaITUmgRvlgnARYkYjl3qqderDXb0g9bq3tY0FjASxQPejoJjCuhTKnIPHZ3o6OzcPBdcVsSUBc9DXIWtaSEMxmrTjYYqqMwhOwaFjDKffZoLIOmexshnfGpMnMHjXMs1sk/3Sl9V5vZUhXE5H1gVl64HcvZV7THjoy+iOpy5JC6sl3nuezDycyazf5GtkGgsELMavW4ECrMp/USw80snSrNtHu/kR/rJi++ftfd+u7wqfpk390lvYd7NIdtw4pxbGN2q1TX7i4m5oPerF+9ecu0v7xG53V6uT3TIWZ/Z2xLsW8F9MmuwmlJKgpUZ7EKiWQ0HYv0Nj6Fj35jjP5ptjzFNk9I+02F4+M0/kHZ2hiZVutPWMOYfPWg/IzBFpURuJJsM4tGTVR42IQxCrA+r1QEOTAIiBL1TZ5MYzJ/dfMyKBwQURK8RNrXJqKOHqgEmBUGkbgejAvlOz9jYNhPhfaokI+i1gBBYWH8kntHc3KFB2MmD1HyaUhnI1MVGSrxmNiPsaq9klVfwJO0kQp2UqjyHbzvyLb72uLVIW8ZN4nwdtZ4vNxdk1WRyDTDQ2d84ENJbgv6g0DSrp4t6M1z1mNEaynogUU+/syMoBgqBvAvbGejcSWjZvNHwhQVNdZvViML1JRg0fcWsYXQneYrKUmQmdPzdB9/3mPyLpbRrqmILN+ya9eoPd8z53UXR7YgyceLOnR2RD6snOffX4JGu7IUZpQhUj93iRNTve/fcjNe7fW4/nveesaffnT23T12uidvPrAxMJNcBh/dmNzi2k8rNM//lHuXjm4/JorawdpdrJDw+Eg5UrETN3L7neVWSpof1iUykbLh8b5qbefoZPP75FWd9MQ8xZ57o1H6NqtfZq6vKULH8VCygCmEKLRUGGNbtmsphyJER5bQTkYMXMic5shczXcP82cMpD8H3TaEROb5LZLFRWuzb9vpkcm363IIvGLVgcczLQ1MutRC9WNLWdQ2FswcvyRWkuQrWZ/i+BIglEcMBvCxF60dGKn/hsfIlg0YHr/2GgRFLx/kcEiIWtOiAX6E1mLA2JZduvU3LLIrFxYpJaWF1vh4IExLNQEJeLWrc+vWT0m/zWBi6mY7JeVr0LmjZLfO2RvepGWRJoNRcrHF7KNbUaQQqsidDzKJE4CsQ8M10K7ChHzjXDmkTPTVNRH0sSQC6fEJZpYGtC5+6bpym0TtP/CRjbm2xujPzLifqhHp37nIr30+Cydfng/zV3YoKaKnkoVKnRoCinaTOTt2dU2ZoJFEg+qDmF73/S+scsXL7/p/Pz1e2raPH/PHURr67YviqN12mqR3dWXZBnS1rBPy9Nfekx6PF2vD4iabm6lM0sj6igZKioOBaRceV462KNDL63S479+gVb3j+2RVnfRyE6XFdMrp2apETe8sgc/gnepTX1z1pBIpeUBCqLB8MEmB0HqRCiLDNnCt8NCBHktxnfVt4V/eTZkpXY2UsAu35W4VEzHWlG4ApcChreqdxYsgaXYhbXi/DJvA0TPaK+PpV1po8hLyEeHl8h8EBHa0a9iOw9KJnGCDFkAji/yYo6uqP2CqHonMporJYiBhb2uCiCbRGXQJNVPBcKw/wZgbjzTsC0za3j7vFAE5VfOJGQ1N8FhR9i/6k4VJjOtHpUWF9pli+0iVpDGh1si8Vlc0Qy8Slrtt+IiR5J8fomp3ox07fg4nT01S8c+u0wpD2tvQ7Q7xrBXUVgaZIXmuXtnaLNfU3dryNqpFXcYFMtV8rYj5pfImJMkr2ANhxA6RNWQ/sJ3PnLoU+98jiZ6V+jatZquXmWq69G6b+rltV1UeTPRYJtpsBHpI5+Z+bbbHpd9vbE0aZhnZaQqRluIggV5RZ0stsdrioHpS99+JodXXT/WN+HC3hj5YajIpVdN0bkHZnJWhMljDLnAkqUCDzLuRwPnLru5MufBfs8LC5ApIsLTCkk1w/meZY/4tGKo2v47NQjXV1JnsDC42Hr/4mSKP4qx8RNGUalqxF4TDufRcmhS+eTdpxaAYpSHXAA1XojE/PkZi7wvucHZ+lhMy/mDApjK+6Nnld8n+Klkp9hFit76AN2ivH5Eu8sCfdGycFv2onki96ovG03FhVqTQ9MqLANSVCP7OzYecmPcH2oI0mc9V2VxMPCjZdJm0m8/OWjN6fyDoF+MQB6zBzd7Qjuruz6kVx6ezUaLna2Ghp3RJCTujZ0DQXonP7VEX/Jr8/S+b7mFxs4PtcvJhfQM7xFFDfW/bPJ/BHRWsZFITbUlddMbn6jueLDzdR99O/3Ssx+7Y/sTnx7y515ck35/tICGemNl4yY4jD+7sbU+pPEkxQ1nv66uTnDVm4wSG5Fs2GBSgjzxRu8xpyu/eLBLr/3Fs3TvB67RtZN7hchuGmJ8kc89eYBW5rpyYH4DaS1UiB2wBC0h9+aUqWuai3BJiZjBJHggNYjyH63PX5x8A6PN4/WEICpWg2yNZ0CWXdO27ARFlCyPF9gLO8qSI1gckfGWkItRDIgx+xJvT5fP79oTpU3A592M3FqupAExN6UwEtC02JCRAsv4kVNxkSTb9Yl5exRPMEgdxczZA4ye0CoTeHsU7mdLQUs4JG22ClAr+0ZJ+1M0JH8mpbho7cJ2nS2gkLywQlHZSiS0SCLYd+uLA1vS08bmBgumUab6cuv6mOFI9pUIRt0x7lG6LSYXBjR/zxS98sgs3fefr2Zr8T0i6+4Y6Z5cmetmdOTiXVNy+qFZ3n9hQ6Qylx60ZCWyP3941rHRsekmU5cqon5/gpauXvqqpY3m6I//xNKZucO1NA3T4uJo9Wnqujf6aprUo082uFVoqNPp0F/6G0+Nnbw39LdX04Wq4jAOYSggPk0DIRfitbkxOf6ZJXri1+Z5JbVnmPYe/l00MnH1cI/OPjiTcmjyHpZBlNT4+Ji0pXn3LVzaMbFlz2wLLAxNo3lyqPKOo1RQwKitR6bGmqTTcXrnqVpvwnNtzXssrcPZiTSQK38FKXDZsDQ3AUpgPkqg9AbDZAfmW2gxMCZgnTd9MpmxW4hYtN2rTDSl184N+xKMCH49CwHPRjTXjfyamoWXU3zdG8SOBEJjcfWx8/yhVMprc+6VaPfL+iOCrIY076ppalCMJf+4M0RRRzVGwA1WO7qdbrALCmhFLEeo9aQrQoOcIf0hsfNVOl1UXOmMImxwepOd0hr74PlcK2JlUEzWXEXd/uqLgOCjLr1WKmZurhowVkSnH56le95/jWATszdGf6TLvDVeZ/T9tb9wlufvmky28dLdiGZNJFbYU7mHFUazOCykcWMHJSEpZ8Znxqb+6t/9iqP/7h/83plz56/Q5PT4jlSCURh1s7k68he4romuX06bnSHVnZpuedWBhyantmc3V5IXRJIKJtOIigv3j6z3qzublKqYeCITi9t09eTEHiqyy0Z68J97w2G6dmIiTl/dtA4HgH2x/UfQNDzITyCT1aUzECoAc96EIZhu8rGoRc9IQ9y8/kVtPjx5FmEv3sJR4Ycgn97X/tw5FGc3Za8R26pHJ4+YKDcImhTcKrahWGH1ko3wO83fEmhByBpJJl6JIO8bZdXYJghp0cdDnyItQgxbYMT6IUnYezDqXGIIBwdl6OZl19RBAWdM2IzepWiMMokmFzTQJ6Mvk+ftxmJ1goYqqxBZ3KBdMsQdLDA4loviGIWyaaPZ0Acg4/rfTMYJWcccI64Pi0NRal2CC+YnkwGPceEIRwXEzAtNK1XLMmS1nY1R7X9lcrHh8/fN0JXbJ2jfxQ1Kxot7Y3eMYGTWE59aosd+8xJ96BtOcm9+I5qILcC+D/eUaC6TwD5ZfY6MedZECVWHe/0Jmj7Z+cqxseEzzSDGzY1BG9AbiVH//R/ZGvkLPDdH9KFniH76p4maYUMXzl/49n13HZ6ru7XKKBUCB1DONunnrJDl/d149IVVvv0Ti7x8sLdXiOzCkXq1V2+byO6HtoIy2iMRKk535gRlFaRRtjj7aPwA3ywzmJEO2SeBJ4sglMRxkPReVRKcMHo47EQBgQejSVQD2jQEC1BB3WS2a4I8XtebqtKHLd3GIy7S7zTSssEg2/m7nFaM9+FRcYAmIKDREgvqwuiu7WbjnvAfk6IZI8ID+sCj0E0/u4F67pQGxvFrgROS0ig09limEgyZN4LeiSHYpDZs+oMht11KpLH921tJQc3oIjgy2pXzDCErKoB6OLPYwB2N0Il6/SRoz4Xdl1tDDlNZIVBJl4vOatVq3kcQQ/ml9cgbZSUpoVgbyFYAJq7IjaPdjOYdeXF1rxjZhSNd0/vedzVtlHhzogrdtaEKZ8RkdQFCT72bQaHOgRRVvjc5NlGqekzqeowvnJ3/1mEc/Fuman5srHa+1qiM+vCR0b/I6UH/pm8keubDY/SJjw9pYfXKQ3X3eJJPyHBrG05SAitv7F+bMaamYn783Re4tzpUk6G9YmRXjWoo+aFfONqn7sbQAQP1EVd5aUbw1Torrz8AzGHE4cwBd/RwiwCYfOcFK0u01LBVBbUtagOKH2qn/reibbk0CbQFkRnzyMwtupwSRl+kuppErt0boDfRBDzsP7qj94wIHqNq6v5f3c+1QyFt33bh1hoKgozhLRaGzuJkFUNOUh5dXpPZ/dDsQ2omnsBzxHin7nvPjcYBUa3zMkdf58uOMX3VjczY3xp0XcEjX/DuFpKkFV7pxWIrCqqL+5w409fqzaBwjBWgMKsTXF+r5MS3Oyhq9YJoIZQ/XMtBIhg6ki8Be0dPFI5fONZXz4G9satGuq3WZzo0d26N7v/9K/SBbzjJB9eGRtx28pen5cH1zI38IvqTqeUqw2EjY50JvvPbfvjN+9/xL5+Znz9ziSamxkfqlNUHRzSbJnXHtwdEC6vaptk3S3TwYE1P/5WvovueHISNtQF1QmcYMzXI2swKy+q2JxLdONKnh99zie/94NXMKdgrRHbXyKF4i9t05qF9dOmuKZ5YGZQ+qi22Fm7LiOMvnEglHQa3SIzBtRYmbzXU3mEOy47zxaMALjuLF9+xeEuHC8pvvQFb380fNa3IMftmqOqvrM22bWLkyHqvh9Ff4sLTLvm1arzux6WIUXajLQauhHUx2G5fWqRP9RZjF8IWYoVJaUX9UrgY3TvzgpHMVxy9WFN/zQMllvNnU7H7drA5Y4vAR8G836ScaKWPRsQRE/Qq9lbGIUUrS43mUByUDhaOt5ioOJZha0MUttvIfhNUGFfNqPEdA2lyBnEpnAA6UTkTWruK0PhKkxA9SohtSpreHjF1xN74L490S2xMd+iJd81nsvKNk+M0fWWLAKxK9NznFsZhPjqcW5bQltcVVdSf7FWHX334yQF3P7m1MaDuRDfZAI3MqD93ZTQJrIOGaXK8oRNzm3lyfO97iZ55Zkjf/eNTf+HEbdWdyze2KIaBJlmwst+0CFEDo5WDPTr64gp92X94hTYna4qVp4ftjV0ysKK/lZ7BgwAAIABJREFU8Jo52exXNL60rXmzuQCpzMg9cgzYcbfMRDQ91qUO+LKuOtE4EnkdYnAE3LUdtqroH7gxuVENdD0GZmJG7eLFCRlr3qWxltnCLUBEwBi1GDzrGbTDDVwfQs51afmvgp1vdBmBxEYKSNDandlvBk8mJvHGh8leW9QYSSR/RkieC1fdiTUfUVDaZhvtIIQRujYGHwShM1YeqO2rs2TLIm81hh9xi0trxw6Zjp/u0qJqM9vbSAzKx5A7YdnkXWEk94p3nxlXO+E+0j94q6nFj2WUPIrKuxWr0nZSETO+NqRLt0/S5169Py9YWxN79vC7aaRruTHZoX2XNuiNP/My/cqP3E/bExWNrQ/dzVnKTsKVclblZkMbdcuLSbghDY3zK2dP/8Cxw5d+e3CDzsRqSFU1OjdM/RPvfNVNcBh/+rG8VtEtJxv6Z9/xPL386YZ+5O+mK5RscD/1HXfEe4916i4127kYsa1iwITMww4nW3/60refpenr23T1lj6FZu8p320jBY+lSPazp2Z4YnEre2blZTZtdFXtkBf9oMu29WPYs9DI4mKVvYFMFzBRY7Y7Z6zExQvUfr+kbpYqA+RYGyhH3NzMF8DMl2fnq7KJb/Kh28uaO7zkRBSlipDPWVQ6F6o/RmUkLWvzAhgYUdfmtojSTI+JURxhIQzQq5h819NuHBKAv1f5tgtxgcrEwu2sEP7LiPkxTxZN0tMAG/tt7W4Vcl8pNsSya9hcG3ACIHAO7oNiR2kIN7W6N57866ol8VUga5ByLF+rfVOuozGByt9LpZQPKhqHBe05tpBiCK9U3cUeoGc/Vm0LnX5sH5363cu55ZiM+/bG7hnBgvTu+OgCPfbui/S+b76FDq6uqSshkFNpoZjpAary3VOhYRtyED3Hre264nrlwZ/8V/Xs//oP+cy7fnNIhw+Pzv1S98ZGCMdpjeFQEjZFW1tEB+ZwoWrajOtHBsMhBe7SgEoiOaRzaSpZOtqnh95zke565jrdODa+V4jswpEe1PGVIT37pllaOtCl/Re3dEkRLDlwmrDWislCBW6dwTgYnnei61mMVhmwFSliDqTE7niq+/ZYtDpOoIQ0BrqLIi7VmiDC6dOIHLaMgquKNZjF3FeDMg1MGdYmdhjzzbvOhPaRIb8BC7hVKK40FZi2RYci2EzRUTjl5T20PoSXNzG3ttJcGYOJYkg8RDQHCGMlh+EtqJw7zpV5rVOgHcUAyB9SZXSk5cJuYpXcyuKAv4mfM2vSAuVg+zWzpLXCLJoxvG9CUVtFFKHRVwiWyAXDwfzTqkKMASzOu7E2T8C3cP9YFRPs/Ee7KYLm+0wubdHlV03Thbun6ZbnF2nlQHfUeIl7478y0uVePtilx949Ty89uo9unOjT9NWNLKX7/DaePX0IxsSWIN+FnZQF1Zuief6aw+cW3kebm2dpZWN0eCN1FUbzzu7UQsnYJT3fJ48RPfpoj04+8aa5ux7cmF1b3KSJ7kRBVwGOR6a1mQ5NX9mgL3nnedrqJ9fVPU+R3TiqgRJXX3lohqqtIZJwCQ4RamimxMH2rt+icH2zW9zETNHh2EbIbRnbjsOJLBc6Qw09w/tl9iJcwdm4KOyh8+og4kiGLvw635iUz8xd0R2y5kNo7f1d/8KFqMLwwzBKRemH6CpoJYspSgKc26J9kGAeK9HcVUxJ4hRcNuJWI24clgdC5BAkDI+MAMqIiZNU5JsfzWj7PsAf0Si5kPJI0WGbUjmi8+WerShsWCPy7Ao4DUzNXGKpPnGJzS4mN6A8BiB9oRFpLFJGXIjXagvZnREFAihB50spx0ztyqNV9bb+HFDsmhusq6bsXkwHPRBa74d8H9/xsRsFYdobu2agXTM3v05P/fI5+rUfvJfiWJVjr8WJ5iBxsTHpVULXZOV6nom4l9Sj1KNnXxz7KxeuxmdilMVBE1ou0jf3qGXUSJv2IPfqIV26Pk7vfXaOnjp6hc6ci/T0d3W/YeYAv2p7o07pU9pSD7qLNWKhrE91+HVvP0sHzq7TtVsm9kiru3CAuJryPS7eNUWTi4NWT8Q7F95YYFPA6F+0Aghau7Cl/bsw3BgYic8KS60IW0TwOAIjfKbFUXV/rWiKUuD62IM7+E9O1DBMps3eAEoD0y1vS4gvs2BMgJdS8smxmqZ/NSBytvoeCSEJZcJLqp6WiXmxLiFQWUzVG7Q2EvGF2n7EwIFW/eNhL40zfNH90kLC+Cr4jsJAtmCDUBrsyiHPz23eYe0i3o0Byyd/DxsP6HPUt82s5vWgA8NPVSuN6HmJO3oyhOstJWPIKgkCuwclh/0LyJX74lokPE6o653wOdwyd3xlwOcenKWlwz3qbjQ5jn5v7K6RvUcO9+juD1yj+x+/Qp988+Gc8gu2GPyHvChBiy8/7pprVY1VNDbGtHzlpa9phsv/IjayuLW6OTLVa13PdG+Cw/hTjlQRrm/T3F1H+MZYlINzV2j/voZeeuXlrz/28MmJXnecmhix18ulZZIYLh7s8t1/dJ0efu/l3KfbK0R276i3I515eJa2+x2aXNjOvXZxfoMjnGymZlky4i2ZsiGG5p98YXMEXgCQ+MKJnUuFADvE/dvPBStIPFTOlylfxbzqUI8jW9Za4XOMVg+qD4vJocqS9N1HHfam0t6b23vIDjgQ8XLsbyMlzNiJGVgorcvSsJkGeu8j/0s/siCBDh0OP38wGyFYoQkOlFUmw6VmtPKMy3GWc63lldNfvZ3lJQhs91sAFxMulL12yIYnLWcZQkcIxFK/QaBEAg1XsnNRbNFs2cINGz0LbpFnpKFQuje5iAu4raLHtJZPirhFHf3VRq7fOsHn7p+hB3/3Mm0d6++R7XfhSCKK7X5NT/7y+ZyhtTbT4fGloSc5FLYz4UblIK0nHhNZh/Z90994/fS7//dP0Csvnqeq06e1Vd9J3bSjlhevj9ZVbSKF8Q51bpulztimPPs71+hfvGucvu0Hvry3PLd86+ZaoJmJrmzHLbgSqadIp5J6GFNAESeOyKBX7RUju3QkrkiSRL74+Bz1FwfZQ8tWJsSCEJimYkmYlTZISC3AWdkPAWu7sRUyzzC2zEP0dcjkEGw7eCeTtne90XBVCWWhdDOx4tUadHbJwIGRWGz9VPoTm48HUIb2z4BTYd0WT6SFzoWATEQ9vlQTIOk3gYeJfCIlQy4TSRXGkZ2tzMiIqylAARLjGEtsVP8P70IUT3VxX3yIkgB8cOsFQbDV46v8tRkvIRIkgHgT/O11sh6SlNaRJxxzuyTLlqxi7q8Glthbm7ylaoFpuLKO+rj/jFUZ7IRoexE78WQZRDvuGfeYMcN/7wUxF4SJ0e5qIksT5TNPHuC7P3SdqmHcI7LuwpFumZQWnxCRp37hHP3G2+6i3mpDIIRZ67h1D1KZg9IcMoxSh14Yn+zS3LH9X8kT4x/eXA/bx+4I9OjjDW1v39znrB7Or9wEh/HfOOxCVFGo3oq0PRzSs793lZ7dEHrt22bfePQWPri51DGI1fK/M+IceHU2tWfO0IO/dyUHT81c3jScXt9aYCfhCLBBseHzv1ZEA/4z/hqFAY3RumH2xp/DSNcg27+/8TAtHBmn/RfXsBaREzdsMBxCbOFGcpFe5FAkDcYMBSCiGXclAA9werFE5Rafo12R4NVboWn6LXOjF+c55r13RCtA+wxQ8vAOKyQwtKNJUTReJgDqCOoiZkcA8Ea7He31UQNyNG2GrN1iMIH6nIijMm7+6h0LKIwQdd5K3VOuqNPsVItjHx3mZ2K8lAAdD5V2DbfaF/gAgrIqWF4QWQFUmjxgoQbn/wAVc6BHe0FgHUtJ9C1p3i2asymqCGoXPNMVtSYRnGbodoKfa9CZ4W9iprl+azhsJEWUjJOUfnJyYcDz983Q/N3TdPJTe0TWP9fR4iXvGK0iHcgoS+vPBABDiVFuDoivSfl+mQv0a4nTeOahWXrpiX0yeWPAEZ0avBli9RhIYUJSI1ehprFOjy5duPhtkxOXf+HgwcEnv/OvLNPTTzV09drNvRbVPF7fBIfxpxtcVRSvr9BgKdKRmaM0mFyqz10+/bbbj8zNdTvj0sRhOemiKVW95SEN6oo+8I230NZERdUgJkkUVQlpGYr9XXLvLn09NPb3oeh/8b2YY7H85xIrjvH1+Mdvss//M4qT0on/rxREgVtOj/z/WgB5oURlrsX4YiqI1HG1pldO7ZOxrYYZ3hh5gTKqpC2wsaD6RdAB6DwDoAkbiJbmy9k1Q+eagKzZTPAMfm4btZ6o7FJE88OyIgNccW1PaFoaFr+AZd5iKArHoDVU8avDUD+s27nzEVuE0RKNY8GAxYM1x8NoHyjDLREzoZRllDS+T1EQcq6HCj7YmR8aqoLsOyZwcYzVaSu+LejewjFGCzzLyCsDctIJ0BKl49jFifqmERetcdKP13NaA2RfWfn8J8GDx2yTEsyEF88O9NEZPTOJEtzhUMh6RwobErwNe6wQLhDBmI2D9/oFAuDkuiay4+nXfL1s0VYKLLx83UTanKoykfX2j3+REVnlT/isOxb7zy8MxL9eCoHP+1q7EPBigooOvXTfSNxZ90+YowNTCjXM/w3696bKQVD2vfJPU6evB4q1fc2+33Ts7/b1Yaei/tIgB3xW27bNwfPJbgOgzU5wpAISv0WGTZepXr39x/5n2v+r/z7SkUNEl68Sra1Ra666+UbNPDq3NHKqXv3qw+FTn16UV55dlkNzJ+gbv/MbOp1Dn3pgY32LZrqVxGZoELtuNlKhUG809OGvPk6D8ZrqOMyFhOHpmayYd36GUSfkJU10uRCJJNVQZ2QtQLRIqYdReJgqHZLQRK5y4aI/m36mGpaCprKiphrq7+vfUezoz1YoeP6kIqj1T/q5UvykwigdV/S/589Ff7wIyv9Nyocq5F1Vuul3XZsKxNUHZujiqya5n7xF8gIQisazzZVQOzLNKcvu7+ZEytFOXWPsRMTHWo/AegoMoyspix7eQuChLi3CgBEx0PYoYh22QoDZlRU+9Xi0Y5mAIXaxaQlBvy2/MzsdRsiw6C2DetkW1Xx8sSzPdoisxRJYIoZwxKBq58LEMNQhgkQa7NRGo9BGa+O4K+rOFgxoOuRVjVYBXq2Qr8b5KyHATY5KGQCnBXaTD7i4ls/ZRnOgijQnEevMaUpfWX8CZnsnIaPSUrVO8Z+H73+bucIlI5CKo60H+Fi5B3tdBYzSJKJ6ngDgB7/g8DzT+PKQQGRNC9VgFxJZ07yUPtvU9S1f3MviXzZeYqg1FnSxn9Xfsa/XO4sB/NNUgaTWoqGp2oVA0IKhCrnASF9r6kDDVqGQ/iuVfj3/k7JYqyqpzfX37ff0d3MmQi6epfq8IqWuCBFK/jkDwlvz60t/ZZvHFwbZE6t09/wJt6XbG7z6xUjc6VQ0qCKdHb7h9mX52O/vm3qZOj3aqdS6CUcdR2xBSifz4x9flvHxbfmOty7S7//ncTrx6PTk8nSXtoZbVE/ycHvIHUKQiEHDTSUJvhdaGbBFs8OEyLZJ5BvTYVD4letKSXKh1hmLLVXCQkpj0JkrZocJs3H28hyRfOxx6BButhGUjKw0Ci6nogJaxzAUqdMedKjBX0BjMpKjBUtKFsvf18InFzvJgzsXRih8crEz0Kj7VIHPXt6gu/7wWp7I5GYuk/8/jHTmU/su2b9vzdQ0sbKdOZEOldtLhnZhgrVUq9e87wbpMVhRwsZSLZnzCDFJ94mwpBmIFRYQqEpYjM9BbvBhilayBUZNxpX8YICGCY93LNwFs+ccPesNY4uGMVMSMr6k954ICAdzLEoOwLuthFnYrqmXKPw/Gl3UQ4D7qi31Xsx5H0FdXq36RdHjxYS3owJpQIvANSy0zNcEprSe+28S63wOY0Fvgjt+ZB9UgtmHRcpINEP1lrO75g+pXjifP3iuWo1nri0Is4MXvZaw0REjr3vYqxSMIswuIYtoC7Z7LkYQQaOuUJhRx6QP6L5PRcBjdU9/ZUBXb52gc/fO0IN/cJluHN1ljqxMlDLCtvoVffCbbsmFQd4v1pWjB+lrqeuYFn6qmYa1FhexqkgqkWHFrEUDCdWBc1ESAjWhykV2LgbqlMUopQgw/pRkqWwqHHDvGf3YCcaa6RTabqhGcs+1d54/8vydn0kNbbTgRqv8dUOSrAeadPh6n0RFbwMKbNs85lu/o3KuiLgs146JzxgMJ8Go93e/P0brazV95vzEl3/w4913PvIqWnjzVxBdufb/9wX+L4961BqPm5tMy8tL8vf+3gJ97VcTfexTV+mZ05/42jsf2T7UG5ukkIdwhnCLnYIVBzqVB4s3FYRspBUlakIRZbioMIRyJy47PzdSGStR6xu2XTchQVwoWuoXJnDNerdsUotmD1iUbKa0rVl2B4VVRK6ehYfpdTv5vbJ+VID1s6aQiRljZ3VRCMZlsPe3LS/66MmguxlLOwKhqWtbdMfHFnZdMGCSPS4eHadzD87QxFJDxZVbv89mcIWNbkTPFVgF/K/Q6me7T8RyzFr8ROGWyqYSNzlt7zyc+MhRibJl9dfX8EhOceEGMY5T3Ti9CQ04VqDPIGy53Zm9tJT1Hm0K8aC0PYLVRkYqbZnOWygvjs8Kp9LoyPcyvFK8XFKeh6MTRanjchFrGZkxqp8fbtcs+tkN+QzU4spkqxOQXtWKLbNsAar46TRTQ3JzEUbHymGfqACL8zL8f5X15sjLEUcuyFz8BfKi9P/GHF25haqIo+nApPLeBq71JufmyK3daZHu6I2inJtA6BtpixCdHJi2JZXYfe+/mk/9H2vljfiYWNimT7zlFvrN//5umrq+mci7+abMOZaNFvCatY1zkua6kOvcII13+yohZ2orB1uthRPyHYZN+n6p16FIicZy9xpan6tKf1XEHxBpFQN40qUlUrf5IwC21NIi2/eG2FpyzdSQdRME+x57BW67HPud7mY2cDHWL0a0GBuhsWosjvX7Ybhx7ms3V5b/9b/511Mf/PBHurS+fnPfG3Xg0eKMpIn4yJGaNtYn6N/+VE03rk6O3yIXvr/q7JvoVOPNsMnAmXdUnQzYjspqk+pbLWsi9Kj1QqfqIm2Qap/ctLIgB72RZRR1DbFFI1ilnAoKdVtSmwNrCrNuJMUXAspAjFhXPMdflJ00aZHkRgxA24z0Fy19hC2cLKD9oD44qehWXmA63kZo5WBXPvy1J/joi6ucYsqHnd0TCTq+NKDPfNVBunrrJM1e3LDNvNmzW9ClXu3gGLgQRHPi0lUoTtBeyPUJC9ZvLWgS0pQNuDTznS1FNqB90fimKt95FZUAErJklsjo9kg+ooSZZSNYOJXarg18kmjkjWCb9GIG6w2bwt2wWTFCgaxcixyJF4r7JzVq/pbvP/NMzS+K3H8odEIoHSAWPxHknRkt0qNSNxgggu73zEsVu3/dMarfacwrTZbee5fJCLra1AglEFgL7ADGHhtK6UVMAUPICa+pCBclm3j+MRuknQrIvC9hCKFsNTEOQusVlQLjsiJ2NAMLGvzLGDwuEH5LkjJb/cnwciUzHfCWT9s4DXND0PaVGavR1MIWvfLIviz9PPbCMq3Njv05PV1f+JF4fddu6dNzbzxEh15apd76gJrgazNnBNnOA5C7qNUJV049FzzOjoSqB55GQ7NnJVn70eb/yux3JSSNVdCwANaUxWiehlQ0WWUw9hIIyLQ0qHQNk/ydrb9rG1v0V/K9Dy+9LOGzex5R35HJb1hPtLLSx9en9GmiI4ExaAEzGAybsU43rMr2zPd+3xOH/t2Pf5p+7j9co/7EzX2v1BtbvZvgMP7bR4LOrl+v6Mf+2TitLIzR93z/X+wdfuCzRwbNkKpuh+NwaLR6EMW4rTIgc1q0+HhYRtvEE3yh0VuG1RKcUDmndUD7w6bbkxC8SIZHQrR1DKFgjMKYI6BnzEntLasUV2iXOaYGkKk6fFMmClY3BgMGalnIAp2P4lS5Umoxx1pocnGbLt09zRfunqI7PnKDFo/0dhXUm43sArtlssDbA/2AQqqAZQZFXM5gxajH5Yo5eLcRDa9as3cNIUo/CWElokGg959taNI9FwKbJFcjN6GmqMBo0Dky2Hsp7zHr9Zh8EmRHLqwqjmaWERTe9dwZtHVSC7Cy11dve7aqWdiZHvZ93aR5a8VAOCuZxeS+1tnQTSIZjICWSHbPwPE1tiKkhRSm7kFRBby/vaGfsXymGD4d6h4raLfqt3PrDCxcIEX+ke26KG0EsEakkmzjrmdgmnBtTNVsOeIkVVGSbtRNDHxtkfRMTTRbTN0kIEmHUZhaMQkuMnS97Pm/XEyAC75j3ES9bSPg+gjmj7712CBlmXTo3P3TdNsnFmht9s/ryfrCjtQmmVjapk+98SAtH+rSvnNbejdKy6046JORYk+jpUhV4pWb1yzqqm/Ow6nnorhyvnvRAW2jdugNposa3IxDShuNWtff1g+tKa14tZswCrOb4JA+HD4f+OEJ7Ho5BHCizKy3spkEz2fGVNnxW/CdtDBxva8dO3xEIm0NGqmrLk1O9Wl6buZLaGL9nUTXaXtwc3OM6i26ybGbP2mw0CAMqD9X04HHlx7uzNTjw/WxVC0HnSYr9tgy3FARYV/wrnSAo3gfOvxtKEfewQVNefV2sG5j3HICLWPklASdmqKLD/VOakc5500fklJJszzyThdrSbDFE7Azdk6aZEZRYu53BkD6IuXh0iUKhlW2gzPzLttFJCLVC6+Zozs+emPXQL2drZiJuddvGaex1W3b8esHiy52gOQzGsrBuZjLOSMivgvNUxlOqBRCIorOxvBUsxVl35Hp7KL3i1WBATwNGH6I3U/BEC3ktBqVgg3dN8AAd6betFZsSEvVYYhA28rTmw9MxauEwHPJm8pQXEsN5PMdPFICI7tyQFmt4IuwmTB5dB8BHSIgJkFAs0H/xc8jWg1NS82KhVcfP4ekdSoPCj3vhK3Q7lQBE5mBjO0bCYb5OBv+Z4Z6NhqVR1tveReduFshgGuqt4mHI/qOhbVAC5mLJJaCozwBKV61pAoLMkRKoKrCcRhcZbQ1xVXR8cXHsa4XTP+juHEs1duNLB7u8qCLbOQv5JP15zMSVyQ5kD73hiPUXW/U+CcYN9ik14Q5jKMbwlX2vACyKkwrGPQaYmLzr4JiYsW+GeW1hI4EG5vA7ZarRnIHxg7HlI072Ul+x3E0N2Mqr5puglD+SE7xCt4uRQtZgOpUjDgEr7fZTGgcIpeAL7lSRpoYqnpMxmem+ey5C9949dr1nySiKynY82Z2XK83N9dugsP40w6mpmlou9mg01c++a333nZkqtftk0jjweY2UZcueIPICiBrzrrPg82ds32t2NaILIXEhkrnDW+It5BaExQ4lV/9E3CbSk5WZLSQwPH3p4i5PTEZu5Ut6YOV4W+GWLouxRKLjt3oDrK0AwGIkRcARZPXN+kzrzlA977vGt327AItHh4faUdHMRXNp193kC7fPkmT17bK8tEamBx8U4TFBjBBUZr4130py9v6NublDTNPoHX/DyTfCjCWYPWggF3gx21JLZmcrH8PtrmPHmCnVCGdjiJYkjnStxJss0FNiMxOguYEXitXyvTDQTt+/pkKR9LKCceAxNpS3j0RlZxaJ8PFqmB+uAtki9vp6y8H30/qoyOsoS6l7165UVz62aa01Y3D42poobL6ik3YgrJKuJxbcDa0TcdRvWijL09USAGFpZF3x7rQIeNG5wZtcykPR8OfDU21y1Hb0x45lM1PADUHW2p7/0Bg6ugBmie/2CJb0oudCqNPsFrI0PhqIxfvnKIbx8d55spmzmAa5ZGKvskbW5m0evnOSdp/bl1N/+wiBWvyid3kbvlvy3TM6FuapCNJG5gwJ2NydNO/rwgfg5gaDDS0+d+eL2oVz5m2zOB7GCrnKKrV3/meU6e8iJagIiYtbyAXzxXic9AS2DuguME9loYLwk/gBijXEQWYBznqoVXSSKzHxqutwZU7uIqzRHylrm9yZGTxymghI2LSO441cdXQ+vLSU1V1gsLYmMRBwoZDnnIyLdpgbVFpYr5X020YcfGlxSgAnV7M8FkcM0Dn3FYTccYI2GqirRmUzPZnuEn73javJPCQIDesUZFhowhe/mqj220zQbBFyreQsOL0gtlen7VhiBwe7Rd5fyEykEjiFEueHGk/+abDnIqRpLiREXZ0xI7x9MP7pKnRY9UTLb6ZdoMRQoxZ/hqiX21KyVSyoPsmjgVcyqthhEaibfrl1t4g3Ft/GlIqddXKEw7WWCURiduGpHtOYWexu9d5AmBhRm5fa823CfZekDkiPC62aHXohcQWezTCsBztdU2stZIW0VxiDUIun1/8JmR0QUEaidpDsaC6mEVGmZpXsEkryqP4BTAnJ7ZQvnR+0h8be3JDJOfORC5zuF4GMzGLuCKCTS+72ljDb/X5d897I/2p8Mm2tHl+yG+sIzJ8HHDGyvNpNv3Rz4BSjBTKMraX4ktaXQU7P/pWwbkN3jssfBeBD6vYz5pNm1NxtZqu15tw4/iEnH1wNptjrU93RrbVmj7p+PIgp6c//4YjMpGkrLr9szR1gfEkuz7aNgpu2gczQU19zB5/6UyGWHxBYoBWmxDWaIR1PJ/eLrR2jd0GNn9rFFV65qLnxaCATXd0Y3UPbnfQBfW4fJuYIZloS0OVYWw1wmvglCOuV5OMtnnbVrjCsQBBBOGeW1MbEQ/Ts9AMG96Uat/+6eqv/723HPqP//wPX7hw9gqNT9y88S/18ePHb4LD+G8fIVS0urpMq2vr9HXf/XTvzgdpYm1xi6b6NAwsdZpR3KzfQAZcMOheGjGKh5jxlXhrhOD2QODkuUtnglszZpb7/8Q+N5OrXLC/1KlEX8AwtFajxybEYLA5F8I0KplK25uqCHJ9KKHzYtwGNqXkjs+H8ik9CkFNIPJCLxxMAAAgAElEQVTjBm6ekRho9voWv/TEfnrp1fvprg9dpxvH+yOrrEmOq1dum6D/h7x3jdX0us7D1trvd+6XOWfOXEjOkEOKEi+xRNKiLMm6kJLIWIrtxLFh16nTojaQFk0KGMmfonDbH0mLtkhstKmToGhaoHAdOLUDO4kcxbXryqltyZBdyeJNF5IiZ8ghOff7zLl8717F3ut51t5HUiRKJmeG6GeTGs6ZOef73ne/e6/1rOfy8jv3aEFI0KmEx3cC7Jm1gWW79fahq4DPaS8Lt7ZLKW68gs3f2vcYy3DKkhKIilkCOWkNFeXeFnwIv40Z60chG8h0w2j4Azo5IboXgwI0i5xSFi+FzEA4InVRPYTuh9DwiHE3kcVEkDpXwqt7j0Rbqq2rFH67HIiSdI+CMa8mZ2l5dApVCy5NpeF56ZIxUXMkoDmhcpnzeiWMgbyFNkIrccInTjyUgoTeOUuF+szK43IVi2Js4yhpASzQmHDURpM6EMaVxWwoksJjN3UeKzE4INxG2TDI7VblvBn1mWpvY8Ku28INl2uhGPoVVc27fvc1mexYlby+NV9as6M+/0NH5PTt87rv6NXqz5H6vZVoMrbmEQ41jZeHp9c67VdRG+Yc9z6HLDyI4crYA/rjVASK/At0FwLxQw6gZJfimrfW+0A8o4gFiMllw/80Ng2lpAKoClpIDU+bJl+o338EUpmsJ2F3SGto3OvehbebbHFlUVfvm/8x0fw5M9mWr1Ol30yvycb6gbfUEp4ME5kfluXcqS/Jnd+z+sP7jswevHiq3tZhJJnQolKm9QKalexwAXwD2pTRW8Tc6baNvWRX0LBPNgDmsbthw+eBA8sS/BU6dnuH5GQT1hc8hHBg0nXT58wVgZbUABCAdN6kQmIpUKSRViKoOVhFhbOF0r8TsPU0V3LcH//I7XLoyxdl9ur0LWmiVK7X3NWpPPvefXJh35xsvHI1qGeU0sKBrG4Ypq2jCjYALnINPtOoCc3PLNQjGT1xbbHoKxO+Gv2Ew9WcYgFM+fqI1HwZKm+kgSsKc48srUCpvAZOZOCrFUOiVgH4NRAidbU5J/nTT+RsoMsmHzLBv8Brgt1hfabdc8MJJ7wWEvNsQttsJOJANtTGmEOYu0T9xfsQJCuqErWJxOgJFvwPyMbiJG9Bhm2brvbqsGXlc8CDPPAwryzCq4SVuXM+UM3wYUegIQs9r8EIdKjQPyJwJleVtk+LWtVgjqZeUBmL42Du4gMC1aEpcPBmjMwXv75Yn5jdFLLn2e1KYi3Kmnv+6HTlW7zV0JHy+Yq5WVEG/enHD8ny6R1/vOpoIzos0PfcmIEBkbmRr3H9u4Gh0TuP0vwiC7aWUJA1OH0xt3WvH+3Le439ngF1uMCpy2LCsh8sae7cndsocBelve6+dCLueH01ZikH8r+7bxUmPH/d6ucP95+h3mSLFRuV4sc5M5nMTjXlyYvPH/0pXZr+4tzy3AtzyzevomYyN/vWkYbVmzFmueeee2VrsiXHXjn6lzfedffi3NIyzKrqcZJTrgiYEUV17Dp7AZlQcBoXGUyZLdpgzlnQB1biEgPHzNFhQszcMbv5cXQyfkhl+FVTOtqbZGZYPUna5fjrr9G/KBFu3sLXUERZkS0KWONNGM9ijA9anX3XXRR7fTbs2iunNuuG9swjB/W9/+IlOX370lsOHZndzHJx35y8+NCazF2aOpKEhgHtcXPSjGtSZbH06sJu1yLdOecq1z84GB7T731Ibpi9dJ0PhYP1FwFAsKs37nt4EcvwwQe3Nf8N75MzGfRecsZghcVUxIvHv5HHlFmtOlyQQ2HSidLxJrrl1JFslJcJbbozWKhGxygKEiRqiHujFCTl1Rahp1ux+8fshONwtGtBJA9GoTZ7OXOUJ0OCUhVjiZN+6RBJFAOVloznH+/J71E2xtn4rL7YBKrGs6Xup0KCpI/BkuyCW5tFvEGl0U4P3gfykGJjCX4ypNoGOMeXlgs9WV22tWHNyT8GN27Tb7YzO8gL717XUoy8Fcc0pcCdbI/yhY/fJpf3zMjGS1erMyqqXlKNQtDYKn4r8LYaPJv87M5UH8TzSb0ZFWQsuUNGi7WDdq1Vvdn6HIdgesVYzkauA0z0oaIKAXsxQtTCEaTPkaEWIYW1Nbcx2LUAXHOb6nwDChMoSwYxEcZ6gXbUN1uK7yI5mlqeJpnfO7vvp/7bx5d/47/+nLz0zAlZWrs5FbSTcxfP3wRv4/W+TMZro1zcuiIf/rsfkEMb5w5tntySpfU9lvOIs8VpzGWfolslh4zmPsGWoMLNTv1TjlKi5yOm0NiuOEhQIzNr1KKCgLIPu4xbR3AsYpAL1v9KCBGoX07kn7RlRxkMkA6VhL08Z0gk6ZohjAbzvZZas5jToD6pZmh1VM+ChPbglR67cHG7hsrd89lT7n64NMg3PAE36SuIqx/cL6fuWCpdlvl0TAMyD7a7Zeer1huWwlKTwBd2QI/BUwfxczihhdI/mnz2Yrs6GQ0TmUDKTONmCQUqxBfAM4Kex2Uy9XiqfgG+wJLmUJpAvxFanVjcxkrIow06ZxLhf5lzKcoOLuzCpdHsFOc1lcdwPqFbqTt8eBWbgP2VUzx7nVvfulNrqS62QYBZ8OBVxSnh1yh1l77qyUYGuYQrD1OFHL9J/JAUWYTrnFpXB4CP2Fw/YJLmI6+w9ifiWVpaZ626zwfgJ/d78Hk+PNnRt+pg1sUBG2+iYMiP6+lBinxP1jPF0D6k5jfSdhWK/zFNtDC0ow8JB4zFU2Lx3I69dN9albOvnN6UzeW3DpG1XJ/VE9fk6IPr8vx7N2z9tas+WwW0QHTXouoFz4kjjBYLIBKtnnNca+4RR2YJpAwVigdAGpZ6Xgul7tC0JRdoh9Y9OOjq9e9QH+PBrZsUBREiJQhsA3St/iQDiWPiC4SDdE5s8FTWLwOYY6Z1XRKJBoXu7mwWCn6MmoQGhgJDqlqA1V5rtHFSlJcLc4t64MChe+dn5p7cvLwlc/M35zqZHH3p+Zvgbbz+19aV4ieS5Ccn79+/tri055Ju+szNcsooEZWdSKwQH4gnzgaJwZlK29eNyj/ngILd1iSL3ORy5HUozMsspL+sZ0PwCWpKlyxqtNnR5gbaFC8Yw1AaaGFjkRvJARvlSPF7/ROwmU6McGtMErpoJlZQ5CUiDXRqJ+9c0mceOSAf+LVjsrm0tBsGvIlf4DFWR8o8SfUgBtnPYkfv0kDayLZt7LvC8bFJ0XRLIqONHObKj/ZUFaqTHI2rv63c8Ej6T22wF+paiWbZX5BboeQkvR8cDGXb1KAzzIX9/dNyN8xNKxXatz/aNPVTRPosUEdLDw9KyY0CQz4P/lWswZRCFVK3uwH6U4AcmEJBps4HgBU8Zl4dgkHD9CiaUM1To8uRJYCbmJpK2M/vxrKp5IyJaZwKTYUDRMQf0yTRUWrvwCrwj3VqggbPqiqdzJRsXmlS5JjTOQV1QHNjrQkmoTG0uH4TEsok73CxKRFKkgBGlR2w8M6V8eS1qZ67dVGOvnNNvu9fvlxVNW8VhKSQ5svKfvKxW2xnXnX5jFu1a6YaLccJn7ihJ+gOcmM8uRmudXeaJC9DkJwT7LLFNQ4nTNJARGPLIJ+UBpYhRqSvTA9F+oQxxUPWMWSd/e31FKtp30+4FnfB4A3z8XmUhZIO5mZhJjIojzDsFpmjy7Z/aDWdKGOj4otVqA0pnXjx1Z86f+r8p0XkTK5nx823UCbyFiQt5q0sF5565S+vLi/dPbM8X9QP8OtNoPchyCymFSy3A1Xndwrcy7TNSmIO3sepN4IGtm0v4im543dOsWHyWytn5kZetP9V5UbosB7sGgjs0StBOykoa2Kj8SsHRZm6c3BCMKgB69/PCyrpE1PC0HVp0qULO/L0Rw7YfZ85pQuXdmRz5a2RElDeaxktHbt/VRZAXA2qmHG7j9msAhzivtH+YJxBwMehjBUGzibeArqh56aFRV9MtZVpjJp5lAskLs6hSzH9Q4esxLewWnSXYQL0g5wXREMVFqn4EAk/3NIgzP6ljpHdd9iHak/m5M+JRda+bLTMhxS351B17huhD2nbaj+Twl2BARR2Yz5jFR1whmsYAXJkZOyOIU8LVCFGJm3aFY9Dkkhn1nCSZTcRSKeniBDHSGStogwHZSbzPXefz0+YTO4ga0f//jn5LUo0q7PgdRksLRrjh7p7MJyUJbIEEZLXL5gNgLEyPzL8dY49uCYP/N+v1Tyq/BZQxZUqYc+JTfnaw+uFQK/LJzfhtJoADeA5dKveLjdAAvWNGSF4Tk7O0ap6SRbxghzFa8OWUKq0UQhOheTy3WTcPHs5pKOG2EWxc3Z5Ug7OMEBABSriFhVAUzKHWBj+iGZJfeqPTx1ceI0/1ypriaeUuHibb/r3cmI2toNc3/HCwoKePXni8a3x2sGZ+Zkz8yuzcjNm0k1Ml26Ct/HtX2WONjdXqrwd2d7akTNbJz9++8xdq7NptgjvvPEqS6wWqim5A5+1fZHNKeEtbuawYGa/iqEuZng5yHcW27kG6MqViQIg5ugdFUVCCIbCO2miSIetOdeWNl9JAW+lyRs4gRZKU/uH0yxcCuvwxWjZadLKeZoAoapG1H0pghYu7uipw4v65EdvkQ//yotejNzkr7KhlRTTpz62JpcOzMvaq5uUwJggjFXJtODx4lTzCGVTjljgP0EFTcedq+TDiDn0KaAPi2kAQx0n+i7eV8x4GlFDQZ3FFLwSPX1DIXDWuKmWg7haNuaQ3aayzY4NR46XMV7DZ5TqDXqdulQ6bR0cVlaCV+uehsFno/iRwBM1/ADrqs3hNSmx1B0sRzJYuQ4BTjS1M8kSPMdbXdbeMX5NsVGC4Toj6yxOYBxENZ/JeEj71zGXNT7Z5KV7VxkeKHGuV9VyaiwvCoKMFVeQD5UHDXvaBr9XvpFyPwhSZMBIYvweEmMqkQ7zaDyzGP1jEWqb+eWuXrQYEHIT0pgBLV3YtOPvWNZX3rEitz99QS7un7vp0ZFhJ9ecrCcfu6WYE9qwXXSu3btOoHJF6cgqlbzSGEjXcZhECnZz4clUncQMhIONBmRL1JLcDSyQJ6FHX5z+NI8KylAQvB04o7NUIzuptSXPqsSEBngC4lqn7CP/hbzEUHKCFEXTqgS+4a4yJQz66oTTPFTEUnHAmWbVuXHlx/6LD8/87v/0jLz67ElZ2HPzSXwna2s3fyVdXpOJyGuvTmVhbkH+4//yByd7Hrx0x7UrO7JncdY2d7aqetXxaHBFuk3QV1ZWa9RUbOCJ5BB3UEwss1mOBj/DV2WEDrBdUaFqXDqwLEWAUYfpxdqsx4vHYWmnYTC8DYDFycmp5C362lVrkgfSnxTULVInoeJoLiiBrLvoIbPM90j4uvGmYhO/I888csDu/8NTunx2W67d5AXJzOZYHVefff+GzG0Goaw2SDl2HVIheLOMNYoZG2zueoZutmPY17lcPbvGOBWZJ9FuMM9cgOqeSRQqvjANYMGQyS9Q5iISKdYoX4jWWGcOX+uYHAddW8W463C/JtMuYFy+0RwbcjdB4Tt3Ux5jOcRjIEzi4s9bk6tCXojU/1DNSOzJoU6pr+pk7HmQQuJGopKBMgTNRgsTeoRIQI3xVDt3hMb03dAHY5JWP/SNBLCv7OwWC+1y3MgKMAZRVelBpBAcN4EcSV/hzc8jJ+GYM/derr9OJq1LB6aF5GJ6G8WQFy5FMeDliFGiNQe2ghlDspLIrVuLM/LV9++TI0+ev+kLESpoClfk2AMb5dda4ms1qHUZxAvG6baz2okcleqBgrwpJn2wwiViUbSEHBo1sk8YwRoRNo4kaWN3rXkvqRWs2DAgOOh3df+dXZzDuINNU9MejnrX4cUMLQWMMXPkG1Bj1mBKTjRdDgqEheSn9snrJRpBr3I9foF6ktkoK0vLcvudB3/g0+mJpy6fvTYOk27d3iSvyc//dxfe3MWHf6UU+/N39drYK/LZz4j8/X+QZN+9e79v9aDuv3xhWqUhMmYYe7uewH0N656TCAXD1yCRApKSS2KMCETStuFl6B8RH6oI4sBBzr0FUXisejWohTG37Doz31xrFFnmNkhb6t1PXWxdWenuYJ0KM8MNAwgO3R0wG1CSrHEqgzRoxkS3QJbrLGf07A8tro47cubQor7w0Lq87zdekqt7Zm5aZU0lrp7blq98cL+8eveyrJzaiikcZabFJ8uNM3NDllz2YBYGXm4s3WtswenEtgcfLWwsEWzlUz100BZx9yBoKnUnzWNUYjF51AhmZR1XwjfW3CgqZl2OvrCN5+ywhbvwe2Baw+675lsgf6kuyBw0Om81jRAEJ0CQjOeOMaQ+QHcXKu6ODUx2QCc7xxPfuc3RWRY1jUzVdAEzDDfLLAyBU1RoHKt5h+gQTV30HLEhMMb5tJJ3+XYTdWL+VK7e27kHE3Z3AI1CgPLIw9N40PBbWjDPULJGb9Gg+BSzGetc4tA5c46H7SPSIKyrsmDZW0HLNsOt50ppTtz5fkTejw8Cyp9dPL8tx965R07fvigrZ7Zlc/nmbSQSeMBf/uB+m86qDtMxnJAlEkK76alICAWMFxO/iwcg/B/rOAZDwATaN5CrQjxV3x95t6XBD7QoC6VkvcQ0TmVwdzcoMURdgo3XXJsb5BL1R26fxmFE2E8g9iwzPA+Dz4yiMyqbVkrh+abhXwU/MjsOMMwyrIdLKKpWx+Usw2QmLy+tpNeeP/o3xqvjJ/ftufXL62uLNQLhZnpNDh++DgsQe/38fPv1d/oqTrY//e+L/J+f3pQvPHns0UduX7ttbmZOpuPoGoBUb+JguWM3te0TJYkEPM8eOCevUTi7zYH4ssB2RiODl8Y2AG6GFdxYEiQTYrukhuQXop9D3ELD5ntCXHvGDF7UdC1pNY+jNNaiQnMivy9cqeqpmljWhy19G1nnGFHGVGj20lSefPSA3PPZ0zJ/eUe2lm5O7ggaezn6wB7POBmjcwx4PPCBxJlDc21nqyMEJnLCFA9OJJn6WYS24UwjmbEl9caEtw12jIZHnJqBhi+BUnWQv3J0wjK3a9ck8BTUpB4KY2NlpdmurS8idqtCq++oy/oaVHPNUvFj1jdCyEayd+CGy4CslwS0hW08QQYOX3blfnAYzncbF9lY6JWnJQWi0EirxJyZ0mcRtOemHoME4ZzXr363TLw+1Ghhv2DxZLuM1+fxg1AshC5S2fHiI8QUt5uAutqFkLox4T3cJ9p9jG2AxBRhd4IxYMq53SRw4nHFLIDKUH6m7t5jHkWSWEwdjET0ZDK3Oc3nbl3QY+9c0/d88nhFNW9GhKRyRV5zBc1X37chK6eugkUcuJ3yQWqUqM4qPcUa90M+Y8Ozbj7bsEpOWgNvMOoB6pXLceu8inFycmYgkgdRBntHoaqG1bE0T+D6wTKspLTLfWgbT9QT/VQldwTxGlSlQSoFbBu+KpZaBcW/a/Rd9J7YnAwY5HsHiWHjl9K4ubOd0my682f+2k+vf+qXPifHXntOlpZuLorG5OLFN/cHJMC0Z86InH8dKuJy1Yv1SfmnJ/zuWRX58jMiT39xRw5/9NTjMzMHZnWcyTvTLQz9SjHofyHgD+oOpBkTkeIqtF4mySiqB5LegzyE+aMb4GnPG8zVZZ4S9kYBaeuKluQUtgsyR0ltE2/xCpfEIm/a+O4wS4EIMqeiZ4iRUKHK+OJGf1A7VMcxUXENLhbEXNQ7fW6cznTJ0o5wWy7ckbctyzOP7JcP/uqx2mHdjJtaKZROHVmUl+9fs6WLUzpnGg+QmnuXWtiD7+1tblfp+M2+BbQDcYyo6myJbfnQRVufQtZQg/59MzI2JPEmjWJr9PxG1jO/HOeX9fdEODLmMMQAFihXa4oq2d8i4GRr1MduiRkogCIS9So2U41GE0sVf4N5z81GxJCDGmoAfj48LznKQQ5lIhTQduN/hCf8J5sTBpV1FYuxkFPDF95z5cxNWhuFVyiUEyA0AvVE4jUmisQhaNM8C+dqREp8grPLhhYh7fWkUM6SePXa1KW24SzbpF1dJ5R4IGasHDS45YoMfHAldFOZjuLZB4opMbUiLGyUAmG1ZvZV6rYdkaMPrMm7Pn3ipiWyFgVNuX1PfPSg7MwOtrLtmxrMxiCrpVIXZb0DAVT4JrrOqMXzEzcqMEQLxmo/JQXAR9O/VjfXCIiK8DEdxGr8f53M9JGj0B50g9yK95ET2+xZWeairAJ9iJQAwkA8X2IPsMBp6XDn5QULNqSfBXnK4F3Spk8sSAa8XwdOUq7rPg1ZjnxwYXn41DU58dQrsjJdk63tdkbf6Nd1wfMWFkS2t0V+/ucncuWKyORbyJxnZ0ReO+F3e209y4i8iJmJyenT/mdWFq8dnBlSsbAuzU9yAVO969kIF1hrc1rb5AMcJFFjn3bFuDdNRhtndi/k0pHZnDG5QdQi88KCG5CrwV4WmkKinQlrKG826TbBZYtoYOyH7gadGv1Jg/VEzSQiTf0cFE7c63/rICRZB7w+dHC3hhNEF95SH6m6ipfO76SnHz0o9/3haVm8MJWrqzdfQVL8UJ5+dI9dKMTVk1cFSRb13MuUJOGcIeXBxdG7+GLEFcw44aMqOjBh9/MH7suGA2mGOLK0YVoYF+96tBPTXBLp7yk6ejiCauNVcBxS0zXdVUSh9IgBXiftkYbgObelEfwERWnJ0ss+UxFkt4CXqmGP3ZJ6feaBs9nPYTwcaOo6FZdF+5lrTRHMB7BNg/jqUDZItW66UBFrn0UNAk2wBsM/ofT3dGuGfkQhgJGJEUEywyOMWTmeE+kdZhPYCIwJZPQw/P9JwuiYKcXRNex38aEzYrMlPNh4ImJKByMX2tGAJ12vr3uK52CroALB9I4WRUJucseVhDqiXmCPFub7tRCE6+L5LXnlnpX8yj2r6fCXLsjl9ZvLzLI0DGsnNmv8xNfes1dWT22C9lNLDJ+HjsYnQJNFSdv07yZwsu0cF+Jf+AVY5fWlbjLiV8kiBdMEXgmVF0Vf3roiwhg4anLe3YzJJCKN1GdLWVo4eDFDy0b9cCb3iEcR57IgKmaC1hmsD6ziBB+93KyugLLFzCeUcm48FfsBPh/FFUxNqmfG3MyibA3n5cSlZ+/dHM//TiGtT22U9fXCcrghS+IbXtelGLl2zZUwf/1vjDJOv3UltrIi8sorKn/3Fxbk7Jkkw6znR9h0R2bn5+Sn/9NH99317jxz5cpWbRNp0ZWNofBuk2RsTXBuKJq9DP+QxEgtoJ0BncDlwW90zDcA5ymcu2N64qaddJ8M4B/x5BQHg2CUaMuorAa8gYqfHKQ6E2tuCO7b3pZlMP6RlcTKqW20CU161bJ6a58pFAoWgxoZkg4W+Ja/eGlbzhxakmc+clAe+eUXagjXTTerUZWzhxdrx0/eqfu3GM+ANhqrf4FImcYB5Fnwu4ArIgwEGMCVRxfq+SVOGYPBYbTndU9wvkg1u3JGGqFctlY8CdEiUX6uDYKNkoMSc5MI3Ig3RRghuixjoR1cVUj8QO2LKGreeRDnwGcABGjAQIIH6+um8Sws9LUNsUR4GN6q75SMX+BKp6ol+/rOXpcPg7kzPSoEtqkRERVqzl3dJeZcfoXqw5eZINPsHOJJ8JwqSynQf2kFVEglwAV1WWd9MVg7HsaGeoW+VsF7qedWpr9mkyYn3hq2KVGq+bQh4X36yYhKllolzl/9LWWl1hwcJHzLRJf40oJsm1w4uCDH71uVt33+rNheuamaiMl2rmjNE4/fUkM5JzumTuRQci+oksHNb966FFGFF1nAypiOK0nD5B95spw0/bRgGB90/gALsf1ydMcBjZuN5BrXmNuQMDo5/+teJHKP6LwZhLsHQfcIawfi6KIufhofyLgrFR7vWli76L9ZCJSljM4RqjwPtSFVlzmNmEX6QTiWByQNMzozt6iXLl35906fOP+vtq6OL/zMz1yRxz+yIydP39ClEa/rUoyMoxcg97zj2z8dOzsiH/uoyZ1v25Kf/VuLMrfgXJPNKyILS6KHH1z66xuH5+86d2ZHUmFwDMF5Y8GK+Qs7XCX8SzTNt65kfZUhypldXcip21GJ3aZ6YgfySzcq0FH9O3e+7vHEsIUDDavN+3i4+NeT0kSEJl0oq4Qu2oSV/QhJdIHHQgz+AIfQMZWuD+QQ+2EbWbC6cRG0UbYoy2e25E9/4Fa584vn5ODzl6rd+s2ysc1dmcqZQwty/N5lWbi0HVRCDciUzQ+NXNCHslnxBz80dQ6NwANEuiGAwsfRh37SADLfS5DVRX4EHPN48rhhlsCqV9tIwI/WDJuDYB0wxpbzAnXnOyU/Qrr7GgrwYBk0gQsrS3aCDrqxwubCMzrXx/tvnidtdINke+mYg3B3C7GMxHSkTShhOlYPGn//nbLaP0YZp9b+Hu6SyeLIFWpsA9ikCoHgJu4ekl78/afmJdVuqF8LSi7ZECjHch3ijjj5XTLO8CfhAKCBbaxXff1An2Vk/GTp1BSo4TjEE1dQZJ5C2i596LoNQ9kgroH67Bk39YNmTgO1ienKQTZ3ddTiRFzGqzfTqKZyRU5ek89/4lZ5/sF1WTu5mcdJBRtddR7HfQL+S94fqFSsj3H/MJbRtGtjhVQaqJVGKGbgy/4IZkwvox+r3AqIqVJyjlIUDP51XMbctn4QqX1XTvwN3jHgzuZ8tS5Ql1+s77QH6WRInNT4JYMiT5mqhp+kMVbH9wrnKWHCtzejOaZYFcIpcN04P78yOX3x1PumInesLtkLH/3wdm3+/381pmE3delS5+Hwb3lNpyJf/orIYx+Zysc+elV++1OD6LrJ9uZUtra3Js8+/+Uf3/u275mdTGZl3J6yCUru4aGxMfNGC7nYHEojAssHNgqLXTq8pxJhExP7hKyBzvrRuPBJsKI8r3rj4THJ2HwH7I60QfBxeWp60jjga/x6djbvWdMAACAASURBVLc90T4qiYPkKgypf6RNLIWjQzfsqatx5CeWSiH3xzZ3Ih9r02+gSrBNBhdCRWevTeXU7Yvy+Y/fKj/8P15EDPv1WCnf+lWRmws78qUP769mZxuvXvNeQLkzdLmEQQgQEg/Zydbn01UW4S7R/WXxCyvMJ+EJlkh3IN7V3By9ua3gEo+WGBCHoQ07fWkpFUrTAxJInAjg/k1BgbAcb7DVo4VoFyoUUYTLGYuWZhmvoDph47SuWEkEgDGKxrnpXVlZaKPXYixUYvQX23kX7Nhiy8JlI2GNZ14ty2E8hoYwLocLBTJHVuj5U5Ct/GRplD7D/aswj8c/SGa6WmJYYBJ/CCm4qB1q8Go4zuK8rQJt1XYbXXnouDu8CC82uiySNEU2X8d2lPado+jzYWzF+4dgNAB4sq7mNxaRDpIalHGOGtR5RuLqrgCe1uK8eI6cuGtZbn32klzee3OMakoDURqaP/34rRUhqUjdwK6q+t746iICBW/JRIcfsKg6gjQjD2ghCeAwUyTHbTk6u/ZLbIEpMxfA07vM3Tuob2O+UMSUoZrOFGCF5zEe+tggKZDvKUaxSWE7sY4cENx3fpkgYRMXMX4mtTkx8Dlyv92ykz6OvPBQ72dPUVCxmUrK/8mffXTvs7/zBZkdviIXLjqF4ludydfrdVNqwMpYplRr+/f6ZH37WpadLZOlPTOT0cblXElqOo7+cA5AGOrkJRcRScTmchHgqEEH7P1z0Ny6FRNRu/5bcCQyyjA8V4aWWt199zCyWtX4yoRoxvEGJxKE/tEPAJhmgQAlZOnxLHT2Cxa2D8bpscRcju5YbNlf9eWIkLlPgwtQMwM52MrmYDMIJhDEViwPSddObslzD2/YCw+u6Z1PnpfzBxa6NKYb8yrdXlH4vPiudSmwdCgLiBOw2aShS7s+OCSc2VV+NbLFcZUz4x1wnMHKF7i73zZgAw69ae+20e4bcVdydLj6om33E3CI5jvYDzjyObgjWZ8kPv6YDFyZCTw8S7HKqJ0yhjU7myS1jdEYC8h32sSSvt+RwlnmBSPQhASt8hA7LZkVGvwnr72y69IQQcpCDveoslUDh5fWYrKGo0VyRMEjjZcPDuoti3hjBzyysROUdimdKGqFWOa8BHLEYA+H4nUXG0UolIp2QeLdUi5slNOrAUolS0XZ9+AaWnTYHKsFU0RZpQFc5UjOrSxY4AgvA/XXgLs8iQLoXjlWk1erw1Ty+X1zdvSBtXTkqfO8tDf0VXbC4ivy2Z+4Q06+bTlvHL2KOSH50jECVM8nRJgdP6+166fWJ2G7L3xDgQmc0SxKqcIKeI0WNqhYWTHUv5+h7NUongfzTZrbtkp3M2pdTJIskBALcQsGjr6iLdEF2utcoOJk2KM8qiLQBK4q3zj4hkZeGkK563cxIrIpdOKWaGbkABL2RD4Y9RPOpEE23rbwyKfPLP7WU0/Ltb/wgyInT93YNcLXTVmMlJtQ1DcPP2zyq7++IHnckf23zMuP/+wH7l952+b8xbObsjQ/cLwWNjN1SQ48pAjQGn2YK/sLEr3oztIYehvvgKqVM6prrFzyrHZNgxApzXSTLNOKHCpDyYOFRc8A2FYQYEPnGlk6LLNxjrlRK48X4XJKwcaulC+GFIh3/dr50uOdEl7nsxeHdXWgwPxehOWY1xtZbGbL5NK66pMfOyh3PnlB0ogn6Qa+Ciryyr2rcvyeVVu6MI3Kg1JfYeCmIZ2ZJUNGQisP/tzGYFIRLOPMnvJCRztRP9ZRSaJcqnWvmAhjmoyu24D7k0TakRjISwFq0OQ8MWrJMbpRhyfIzoejSWo9d9d9EdDGt6L7rsX8uoX2pVh40uxQUvPHCbmp+9bneIwkyN3+68T0a0RzDGSM8vkS8iv5bTIQqowZTqI8t/3Z4O0QNepNLqnbxSat7nOYR3++bQBOwsRqDtRiEIbhphBRx/0L8p6RXdx1lq3k5FMaxMmOnMs/QV6PdSUkmPLcn/wpTDUyHqOpJlXPbHXNsSplmZTJUI9pRPtgGQ92ruzZtHhlKkffuS4X970qM5tZpnM3EINXkYWLO3L2tgUppPjF8zttnWmTu1Gd1vjYWGi0gsdNiobLtJtPh/ZKWLhEAlN3g4Jxx7UkDG/gsd3FWnOVacvhre4PDjM06jRjEoSlPNBCaYNjkehm8K8c0G3s0q2lafRblVgardVxJpKfVCmuV1y/BrHkkHwCLC1o3GRmRuYXFuXkqeM/9tprp//JP/zHM3/yuadmqqjkZnhdt2JEEY08/TYE1sIZKf+cOCny0Uey/OiPTeVXf3kiOzLIgXsWHp3bP93Y3twpB36wfXJV1QArr+tgiNztrGOw00HnKyIuZDfGQx2ldGDxiadSjUF3fd3IRauRtaGoTAe3CI8GpuoSQ7rB7K8Me/gEUUvMPC2UpN1EicRYF8i4gY2XEB49HnNPWpwAnqaPRkwlB4AzdPxJjIhLja8QDHULc6Y9Z7fla9+3Ic+/e13e/idn5dytCzfMCK18pNnNUV58YI9cWZvo4vFr/oWIw1NliQXqb2znNjBdOcsUeamJ8S3an0fWuiixUKqaErcwyrjpn8tDCcyk3GOsu5xwndgaRa//f0t2RQo5NpUk9FHgevAO2rKOFK2ktnSDjBmqnIb7hpcfpgbZsRLH41g1w/ynpusnJkO3qXMQVAjn8MCmyhi5IlUimdgWRIUNMiczeLHGCF63yxxz0LrtJ8UPiFFYYF0+BTeSBZBHU1QBfjHBao/ChaN0FnXwvnOdO9eAj0/c/AwEnhzbu8X+UAIsi+wzNdhCRu4JlUobxXFdSSnGUnjhQ8NgoFecC9i9ouGbwRG3V30sSgSE9LqOfdxhIxbl/JVtOXn3orx0/x65/w9Pyblb5m8YOmLVrn5bPv+Dd8rpI4uy96UrFZrMqLpSnPyIp3S7jzawkC6+kNOTJp+KoloCRHKhebOraU0n52k54rRzREB4i4fnL40i0Z7heyYajhBXRONQ/v7giLiBrk0VusctkXHd7mNGblSpRtWimsfPl/45bs2GExzVcHqEAQTrjaA/wuA5lUjLLK7ode6Qtx3ZZhbmdOfshTsW5i+tP3vc5JP/LPHj3vDXdStGCol1edn9Q8bx3/7nSiFy8KDozIzI5Sti73nomnzynw2yMHtt/sSJ4z9w+4HVufm5udotjSycEzFtX3DJQ5Sxo7Vxt2BfGfArCZJeJk4SrHwuRa9MGagHOUWJ82fENHkbQYcxpqNLDAVZ3Hs4ffx0L6T4gzjm9O9dvlCWdH04vIUDGgk0uwL2CQwm9yXIo6c61i+jm1eGupU/PvohVD7fmLNEq8vmKkRAfshNdgoNO9kTf/4WLVbTQ2HET24MOjK7meXC/nk5+q41Wbq80yeKwbEiNxuqaIxTmM/xFg6UriivJjcrmtDhhfGVg1NWL2MoSD1Fz2l2yWAD4F8Mn4LsNQFmGX6LXdTKvUboTJPpIo6qYLBoZrzKQJy9YtTubzeOs4rF+VSkY+M3PEbaxmY1DycWLq5Ulo5HHWdvlaHgytguu3zGmmcO1C2i41qdEgiFgBjtiOWgqT1ZlrC9ElH295+4huOs0gjSI1SgcJg1jjgERZSSL6Lh6xFFkxeWQsEypq/+LXKzHUnAWg0Jk+yOq4HmkKsiTcehFmH8fiMBSMJf2dqZQjwgt7bEYDjHMo2sW43uPMMhwJ/ZbDl4OYlHsKcP1bccZrXmqpVjD6zJfZ85dUPHNAuXpnLyyLI8/ch+WTy3CR4IULQGT2HbJgvHmBJgmQ+on+woMjRI280Kvj23Uchkk7Ac9u3VIPuPVA/D6NZBDq629HUighBD+rpm4U6EKm44gU1vFFrwCPUVXlgk0J+M5imMmmaMg+YyIPKZTMynUH6yOeEYOnjvQUogvwXnA/reegFGKbFWk5lZmZkva7n88alMJpuiNwnR+bpieKUIKUXGnj1emHyzf/btE7l8WeyVV8SOHhP5578xyIF9U/mF/35u7r53br/jyuVFmZvMVwafs+woexOMTxJbpaD7JT6+GVsNCEWmJApWRLCi6wlzRfH7CZCBv1uxUKsOmNiI4qHwoh7bhYa8WIJO6F3PIMmGShqISEe40atS8kCbEBij8GnU1NEEfSYE8kL9WQkzHCzJBLTOARd/RpKhG+ehnVkRWVwZWAnWgyKJrJ7c0qMPFW+ADVk9vXlDiKzlUF0+ty0vvHtdTt21LIsXR8D8QFBja67wN4bw5f9GoQuiYvRAAoD1F4YAe9IoRyGV4pgelAm14rqShiQRBWMazlopSpLk2SLJJb8JfJ1y9A71GEW5i+FwK6GycBpcZ4qaybagLWdxU63dWFlJ/Py1yISTaf3IbUzX0An8K/Gnh8yR/+Z7lSZdJbESNz3VZE1Yemf6Lgk+s7Nf3DqjrMQhKh5MI+IgDlRlyFzaVNJWAKkRF/1QYSNMcxC3FUqNMxj8HFCs2of3w62bYaVyBxIPIsLr/jeGFKHW/nkRaRlgWfJGRuGmmKPrLkWeQciQgCx1LOosEEfRC5qITwym+PZQKmsESfEQqiR2t1+ryImvUaCgzuKuK0KrGm5HXvjedXnlnlVZOr/9Bj+Nr+9VbmR5Zp977145d2hRFi7lure6iIqEe35uvP9EkJqPRRvzMe6Dc7xWMLTiWzCJrGhUIguOUmxfP6HAaSWgg80xV9W2hzLX2bQ9UlEgKNWHStvuQosvI9/B0Yz6FlK1MsGM1GgB3D2TmDiJxwk4pmPa8eE8sMwBf6t5gvzbrXlysLt87qFm5Kk3MLShyJwDZ0ljkrnFBflL/+H333vr7ftkHMc4Lm70P9cNGSk3prB2i3FZkROV4LtvZo1fipXi1FrmWHceEbn1NpU/+cJ+ubD4oX0yf2lxfnsQHWayjZupolfRIlt15JAAgwWwbMOEIwqSa60WjPA/qKd0LrCn5rG5dsSkEtpRAIAuA6vek2M1GnO4mQ9PoOJ0MRB2cLkXW4iQD+6racztOUvQrAelMqaJ3dC4LLbRk0hTvEsX5SQs1jJTH1D2mMex1w4laWMygICAI7wm0jqTrzwEO+WuyNce3iv3/OGpG6KsKXyV7flUI8fV8AETC0xUovXkz8GR0NSUHnV1DG22qjyKzfnz2gUnKdXfwlwaN7qCr6u7SxiTutxV35yUynozmqT+dvnBlGEQXlZqgWlHWGumEAyi18XtRqECJxLF+TMGl54ueo5WKJu72KWcb10RDiJCblIAompZXiPrgfh7GYlFAgKR8FqTm5VRXCWOffDlEbeHzsvuegn/HAXeoAE+K4m9aYD+1eU1ozeIdDIkFMDKj4L7Ng+nA3LkcLcZB+jAzsHKGLCCxyGgopc3m4YBiAveY7nYdW1lv5cgjJJlrCHtBqlMkw051ED1yM21CsuW/PoFBySjkFAwgTJmBWUG52Ml30DKeTLWOzS0jjex9lIJKi1/JvbTma3Rzhxe1he+d6/c/kwxQLv+RNZiTFhGRF/9/g1ZKhL8obk/kYPtqCwbooYgYkpeeUR5ZDw2qae8aYpUSjwsSn/8DN0BtUbozSpWOmLHS+AdW0AYSEjg49skLnUDTTFSQ/2Y8cyW/RcIJQ18tEmvY3SOjZV2EplPgm/KMCVUpTpYiZrWEUKmGpBkE0HrWK9dhLIiQFAYuIif7/beMEv06zs7vyAH3z77uKbpPzazzTxOO++gG/e6rgTW5JEXtdAotvgs7frrsL0lsrQoMj8ncvCAyCc+viO/8ZsqTzw39+5DD+ysz86keoFHYOZhD2QUuyDCjhZYxl0AmyaEVTieiXqB5px8M6r/MwYEbayF0ULnDCyvSRutSSzb/I4z4wzCnS+isfBYtBljNcKfDinweTZVSrSZvSW8+oJbQDkhdiU259YeAGnKEZdAUiSIjI8AEgxoSp0PEGRJKktntuQr37dX7ntovXqPnD94fZU1S+d3irukHL9nRZZLp0dICc5GFHnS/MPj8rHYNAYI3YKzCJpTCrmz97NwME+GgiZuKJ5xD8azZgqNGo68pMr4z3CASG19q3UcFBmrkrDO/HP1L82xwLzbrdsQJaIG9WAyzLyJ2ohvXpY0xH5GrJMdZDTgwI/gzsGkUf7Rtt2PTrQ1BqeGMIhS9xahjsLQP24fV5eb9BWC6ip1r5+Zt86iAAII0EXqsZtgtgedRn3IVc4HcdbYroqgktdj3NJVzclaLBFVHERS1D01M6ooJqmWzzVSSBvT2BTweITFiAt2NKS2/eiWVFqAPwymyhY/P9Li8fwSBark3HqbgRUN0qovDRIkIZvwT8J/6vzlbTn6rlW5uG/2uhNZKypydls++xO3y4m7l2Xvy5uoFOJ+YCri11vg20MORyY6FYNrqXt2SBaAGTZkgepdzCtCB2XedPmuptyDHejIsXFSR8WxTH3OgWYxaUJFoyiq1iK5ZoFE28vFjPyROlW05s1KYWa730Q9iI2EhJMvutVYCkegTsyA/4nP4CMtZA5LOPWw5CvvJjmPf5DJZJAzr515z5jkwNzy0rGVjQWRG8QF7F/XXU1TbWWyVE/8AxsiizMi069DSAgb7V0W+fyfDpKvXZKd/PKfn5vdP5+3UlHXqLG4ME94dwyMe3HWbAmkqCw6dc5EERwyLjE6LmMhPNY5xhh7Twb8P+BAGZHhmpBSDmfmwi7NNExDQ4XimiocZBm5HwA6TieKQroGiCjFpo5NEwSOIPWniKOgglT95/v3K4FodQ6UPdzTxwTi7DaaRSWafWMYGiN7CyCAhEOEoMvMlsh0b5InHjsoR544XzMm7DrNGStxdWuUF9+5JldX5mzx1auBOsJ6UTQOtnLb6+6lhROTMHB2TqWxbwAHF5uLQw2M6AJ0JWGcSXWDYxqeLc4DOVHAjaOumPond6/BNeZ0LkrTDiTJEiUn5H+5WsNwUwqGBP+QW6JSBQpKlFqcuySH4JbWgDxfJlMY+XY1Kr8/RzG8JAJzWkHHVrfJEUrhlPypomacU3H3CPbiqnTzBlIYKBwgysYchevfawYggmFEm5Dlz4PKP0wVy9NSllRhckJyQHu4BloHouxKh6k6l68AjLAzqZyQwang9ecZrk/gMRg5eadb/3sSNg44FxLULGNYtgXvYDSDc3t7/uk2205ljtmE6J05wAevIvV7CIchlrQEWOpmU8ujERtN2FGLzF/cLlJaefn+PXLfZ05fPyIrFTSHFuTpjx2ovBEgxB6T5RoVt0YBVcR/qy7i0XsCTx+n0GEY0SwCQMxAOAdpisIg7IFXPpqPNLvnA0busZ/6e0EDRwWad7iOktMZQkPNJDEjaZNuegn6/S0odEHswwtQ4HBJ7q3AaooPHX00Uww0tbFQgGYYkNeuRmuIPVnmOQy1A+Uk2GnCaDV/J+NE55aHjR/6Wx9f/N3/5fNy5cJ5mV288Z40N0TaWxZZCYT9N0+uyee+tl/2LHzjXHOYHUS3tuRf/dJ5mcxsydb2hYdTOiwyzE3NpjoUXnatbKrjLfkgzjZLhnLSRyQpR13dho65PulYnJkHip/VID+aMPAjI9WFsYxB9WgDIX94+HuoqfEfkNk0728XMFTHk4zV52xJosctAKyswDETilbaU7kQcMChOgbjK6P5rj9d4XrGKhtBO9lT9Ovnr2/NoZjanyNcTOhjTn3cnpOb8kLJlXh4Xd7+ubNy7rbro6wpxNWLG3Ny7IE9Mn9livFqpkudG2MFgTFTHlM4fAnFI3odayQ5GGi5H/XgaID3ZaCTFW6hKq0/on0icJFKPHSLgHB2v3GMqxwJETiuX8/klzY/iyzNQrWOOzKWWyqFlAd2lIOmpsYPAJzr9xz9/pFEnSEcj7lG9nli+Y0Rm1WO/BpyBrGpIqFXaO9H6xKlqVLj1aBQDQtsowE7VTCttSM1M6Sbxo7ThaskSo8OY/nPpj24FsaJx5BAB83OEKGGQU2F+Qhqo1H9+UWrPEDzAnOS5lEH83APvul2f6U9KuY5KIY4Tso8D9TjjJy+oe5AF3QYf4tD7yGE8tUk9T1uLZg0NBIcLvtYIgAulUBDFbPgjNRwv3W+/jOI85yODeUiTSZ69MG9cu9nTl+3MU35FIWn8vkfvE2KG+y+Y1d9+WWqYZMnetJ8QX1sBr1KwhDOhpSa8oD0UeOVQ4gHYC2/gtg14YDu3Iuk3uf59U3kasXcpMn7M2+TV0g2IYkJIzUL78AIsKobDLYb7D/Jg0mdwoeKkdmMGbPJWksJhblwVOa03h8z3KwE96fs6gTxmACtsJJv0Uli/zEJIUK5aAP2x2yUIxP+Lu9oovPzMzP3P7T+jt+T7S+fPnpKFlbmrs8C+RavG+YzsrIg8tVXVuV3vnhIbt248o0zq6S1u5jfyPKjP3K/3HW/LG5e3Jb5+XkdM8SEo/pCSC5j8lKBkS9qjCTLiex652BYYkcVzZ2XHdZ0UmjgkHljLbyrfZ1hrPU5GlR3oco0PWvjFoWjnzOmPNYPxXZiKewLPyU4UmVnGYhGwQ+fC5yLRpdQqt7Mo6HUnwtm3+TOrbtqNqiemDZYt1b4GIS3yb7FTH6Crz/5+K1y1xfOlbm0TGfeXOi3PExL57blyx/cJ6fvWpLVM9s4nBAmW+NfMrzc4QvCMMSQexvzrBqITt5OvWTYSLBpwN0Dsb/Yjlqa0G53CU4CEnRYoyjYku4f6R2tj/pjfbnDp89zhkApBqPCFtLhDDIINSRGzwNjbF24J3BLherErf/Nz1SR7pI1cwPswAZEoSkP0LvBJMfCf2Hg18ZwPvduHcOVCauDwkEBtMTIfo4ZSW3wn56a5Zu3hpiXUnbmo6mOwcFCB1kMNCiTiD5QRznoBpeRCSzk87V5E2iuOFhA0ADsMRLTip8vFXXkCJWLMxpblhX++zlQtlgrZQ+hgy7vhzHomzwI7k/4cz4TLOM68pzAcciU3OD59hvt5/WYakeBS1nD8176nj1y+o5FWT29JddWvkVC6RvyvEotRE4dWZJnHj1gK2e2GehGw+G69Y3WAbGJsK9vkpRbC3okA1wwhHY3UzAdowxB8VbdIIE4BrqJ799mIBhfQDfrhVwDEgCQYmkh3sNzEKC/FDpv1+fHsGZB+6s/a0SdWJPk1br3DzVEbCFh3OOookgf1Sdkh0ko8NgQuOjAaiO+y46gzVfRAHjifPb1i0lBab6GlNK1M6c+Ot269ltFxHozkEZuWDGytSNy5OBV2ThocnA9uzd/nJdVOC/7HjooL14+J7e/be++1b07c1cu1ZuSphkZciQ+11KUcrwmgIjZYUuUwnCkXXjuvcIOCMs7s0T2qLnoDtnjAEnoNOT0eiAADUMy84OO9QUn9M5fC8SizbElQipB6kMH0IZ/zRR5jIPG4Ut+dy96It2mH0b2S66OotRHURbvuD1gQaipmayqKye3qufIE4/dIg9/6hU5c3jxTUVHhjHLdDbJV9+/3x/HqcG4EDVcnK1kxoNhQXCLHkehnlKoE2DnwOEam6xACDQ2IQa38+/TXCnDLpr86WC/W7hT8D0CnCCwotqjJDCBDUK10LW+vE3G4hABsMxsltZIo0ZKzmUSv1tYKxq7q6/tyE3hrAHAWUcQpLcBDacYW5DjLLUwPuHVh3kNL00UDdrNf5Kn1sbXWUtozvE5pJ01wlGnxvNNZnfLACLDhBo0CcIiua5krqQ2joVvP93ouoQYwJvG4GUvATP9I+ihF9I3PN+54465XyajVNvq2k0Arnr+en1z8zXJBO5SGOAljuqUzz7CXPxmwHMGnzCcKNx8r7zXmSvTimA+994N+cCvHquhl28mQlL2w+IF9Md/8ZCcPzivG8ev+aUWCbuD+txkZwBzm0mkU9EDjpsgGzTpEQ0Nv5XE288KlyFQme7sbb8Vkk9jNB+CGFHKSsmC9jFeROsiKKrn18Yozx9YZYAZ9kzrS0zmX2KcwwcPaAkLTaiRYw5ETxmqBbEuspJLY0DzG/HREFYdXpgYMwo0gn7dsqbJMNowO1y+euGxSxcuHRSRl30zvbEFyeTNDsmpJHUTjAOaiuXMZZH3HzktL776vPy/Jw7J2vKIRFlfFJP5QU5+8aS8/IXj8upHbvvR1Z3Vw/Ozy+7lJWhUMK/33TrDTKczUcrcvMs8ZnTXc7LOIDo3VC/YH4KGR2F4pKQagLb6DFVKu6MWbXE7gs6ZJMd06PxytiieBITWkLa3AieemXjCuNnn3YasPCTa221D9Czxh5rRFJlOEi6OFg+8sWWIIyEyRKJwKiX9aDJ7ddSSMfH2Pz5TGfNbSxxUv/GvMnt+5d4VefnPrVaZ4OggLBijQKma+RcMRRO9XbosWNxngg3xuy0Ei9fPWnkRxNRAIGhuheKT94+lR06iDN0IoKBJ9CLW06JQBvasFpfQyKjw9DcUhvR2VJrFN9JBW6wxKaLJ164ilDtNlywby8x4zwErc9bNCwXKqiUNvoIYi2gByEKJEoW5IJNGQ9i/X3NkhC2pRYafyNAWdFyh1C1RrNrmHd+kcYZigjb+wS3icIrFUYQKY17Kk0A5WsJhwGmrARXdVZK5v56BcKkoXr0wcWJKa4ikFXm4dDTEEjJNiICQFcnAcF435aOc2v0n5NR5HvmfbZSEUpC88NCGPPB/nZCZLS/u34xXQZtXX7smRx9Yk2c+fFBWT+6E466jjkSFtT1RDPxPWLkVzNLuQ5BKEfWtf/AB06xo8LCHWlQmwqqD1XzGsmnBiQ4ycDOJ6FMXXblCEY0fOhGzKCWoBkPBYAn8z/bzDT+0vv9EgnFHzmKj2mE8Fk9mC9HsdoYm8CQOSmq4UfROVTsMtyLN0dFhrhuVmWlKc8PWzrV7F5dnFi8NU5kpMtYbDI5Mvpm89o18cROam9tdjBTO2ty8yM/9uy/Lf/S3t+XZL8zI4kJzQ5vMT+TMc+dk8/w1ubpz4QeH2bWZyXQWYVgWBlEUaAnrAtzLeG45rOZk0QAAIABJREFUbzGaIVp0uVzgkWtKZySWIBXOC4t1pX9N08hrpC9CdgagJfnYo5391QWUTSUfBNZNJt0STzzJ1JuuxNrKI/CSDn4WOpXSwvUeyGXCO3KgkLW2EEtRajGhF6adj8ZoO3xLtG1vVDYmkZVz23b6yLI+/chB+eCvHZXNpcXdB+Mb+JrZHOXl+/bItT0zsvf4VZROGps6nx4fTVnnGJHQW+VWsCkR2iq19KlzfeW44AJ3xN5JOfS5qY1zAl0n7aL+9KwExYzWSuFOimucgbQU/bjx9JSmAoh9CNLDDJ8TzgiDXQzGRSYEYZh6uyS2k7VA5AhAGlwH4bHZIvIit5EOK2JxtPpYAzpdwTPThJgUmgYmoj0EzWOy/SH2wcpgEr81MHzw5wK2hDj8U3a420E69wEnMZg3qsMFpalxQPDEKKMeL5S8YEmr+3i03EprzUSzEQEU3h2gQqPbvjAE4OLusCmuUENclX8M68iM/XzTZGb8zYS1melZxKq2pUHGY7CrdIZhi//k5UtTO31kUcu45p4/Ol0D696MVyG1l7fzxOMHZZxTGXYy4S/xDjI3lMCl5m2ETTREpfUCJL8RvSyjDpcRBFyU245aSDI0ttVd9yTBgA8h3K7PTxVVSqwCJcxpXAeb4gzH9uglZ2eoyqLCYmdtLEL8MBaEuXGyNFzllUL+Xl6sLtNBOG8KbIXxeDBqFeYxUe0pPu4ildXrZxohhag0NgQrU4fiL7K0Z0g/83OfWPqVv/dH8uKzx2VheUE2N9sZfb1fk5IB82a+itHZ4qIbmvWFT/n1gdtE/vmnVJ761ydlU0Qufd374B8fx8vrM5M5PyR3sqZUlFXWNpW2GQj7JBxE7qwIs6AKhaq7lGZUqm5+48ECCNPyjY5R3Zw/5kZRaxCitn5VCdLiqEq71a/gbGvPiRTCzK76YCRUwhwguokBQGyWWOEUZoROTLn1RxYPaVoti4y1v0IpRA1D8tXrIBPRRkh+BTwK6uHLH128sCXPPLpf7v/MqcqW31yZvOFVdXkX40yS87fMS9ohqZKBsYDX4R2Bzdx4vei7qBalBIQ3fv8TUC52rY3YqOCItGsftxyx+XEisY7g4Ta6DIIq1FJt+1ZnbMaDDh+0OR6B1szlWa/USXO4+SUJ4Ec954XFgr8XX1+599FheFwwjJLRzjqhCAgiX9Ab+DuE4IwPU1Txfm9IJoJ8EhPy6gkoipDZZosQsJJnefhjorAMM9ycWhqrcuuW5msJV+OYnCPVJoCVjs/aCqh258hJUXKUOZliIeN3NALaUcuxjtVIkYyRloUXbUMng11V462yEKHkfe9Olr4rU0vtUgZUEngTy0myZ6kYiseg9UQSoXIM0ONzpNsLSV67e1nu//2Tb+xDile5cGsnNuX5h/fKc+/ZsNWT11r4nVDSGmc7Rtfx7kkZdzIfo5wxZJOun8ycKEqUwcrxjNYDARwsy7GVMpcsUU5rqsz8xybdGFhYMIOvS+craZC8g7LO913L0UwWQJRWiJXKvcuDdqU5hRDtLrPIaT1zw2TaENda2ERuV64XZ/mGRqZ7lErAx/GvesDNFHL37OL8sP/A+ocW98x+YZxm2ZkWQ1LaAVz/1+TNHhNxRMN/BA3dHYdEvvRFkb/zt30TmR3w9bIKJoPsjCbz8zPy7/zNR1aOfP+4cPXyKLMTLSY4KVy8u/vQqPzVnqqFtmt7H1gPkIYh0YRLgg9wauhnIKPS0HiLn9S+StzWWIjWeb+wzJEw2ozu3LdhPAaYVwYTBDbZXkR5+Q/gXSn1akMVHqghXlc22nHiBOwrcHHkTWhopqLNM+jxjQPL6P1BOKvvefHStpw+vCRPPXpQPvwrL1RinL7By3fu6lTO37IgJQ597tIOKKhGYggbc5i9GcmlkbpKi3HGvLQ2F5CoaBCHoz/C7xmtwnnrIxTR/2BLxgiwTLDvd4d6K1wa+uWdvZkpfUG6uRvXnWuPwzOHCBX1A5nbDGOy2i4rLZwxd+qWnpWhcXq2LTW2Vqsuj21Nc2n5KLRCLBSYItlWog2FDIuPnaErdOpJSwY0/kFp9TxD8KOvZ7GOS4gsqV5V0f9vTzQQlgq7MRLfvyN4XcmTpeYS279RBEFiTrs2xsAjSi2VXS9HNK0xCTJsHL98yPj/wEpQn6Tu2SHaLt175biCfUfq/m4U0hlOR9rmkERcCsJYcqVK4nUZteY3WJZfUJAy/nnysVsq8jSz7YhgrHEvaMka7364xfJtl6CNnOjDwi9bjukL4+Zwj6quPtArPrdRznS9Y+whQp24xc+NQ4HyuSg028ZqHL9xDijdw0U5sDBpnRlG/WjMulIZCxleA6ZhqaNR+fNc8TzoaED4GMflHEkBUPLc3egRP8ldYDNGimUaOpvTMJ+OH3/pJ8+eOv3rInb8Ez+wJX/1r0zl1KmvG6tep9fkzYZk+sUh2PCW50VmBpH/7V+uii4Psr6R48MPkyTbl7Zl59QV2ZlO5K6HNj68dsvW7VfO10JhB+TBCSxsEH+PjgHTSC7RyPjO0J4MMZJXYM9MyPSJJVMpYrF2nyOikYw0T85ru7ZEiMAFd49287gYhhZT22PYd3mpCxGPysVirJzbHusvCydBI77LH6SUD7gPi0MgGsdnjGHACpfuESUGRKVQTI6od9BBFy6M8swjB+S+z56qfI5ry28cF7q8t5LQ+6UPH5AzhxZl/dVr4rFSccG1lZnCS2I4ADDcotuHUGUF/1wSDKM+g3LUP3/+OqKaKgxKSCJikC25HxFFEJh7Kzy1I1EjN4ujMMV9i06eP4aIVvfxIjWHppOkyylZLuT6mQVJOwjXkYBY9Mo5vP8j4YM/CGEqSvaor/XczGnrG0skOMd8kCRwcEahfnd6VWoLFupmJaKXozavYzYwORtJFuuAbzBTFN9aUH/X2gDtzskhbhizjiUEmaIt2Vfb6UYcphVM9Xq2UFZWmTg4CEEl9LjZCEQSkBWJQQIaWzYr7uYS1667Cea4F4X97StVfNdqKyXyRxZLCtEy77+yl7aFC1N99e0rduJty3rrVy/K5Y25N6z1LZdh5fSWfO3de+XFh9Zt9cyW5eTarV04FSvDaLmwvsQDBrFn8y+EY2DuimZLdPwTll0SOFECLcefeJ7QQgo4h/dBi7bUAquoV0cflxuahSe0Vcetiob3iUVzEmbvHv5RG4MqpGq4BUR0OSsLVum/a4pnJYxJorDkg+EFEDnZfS/O58c/5S7CLL4Dsw0KLJnSODs7P3d68/QD2+N0TWRy/APvn8rth00mNyg477qqacpNXpoTWZ4T+a9+5Yg8lQ/KAz+xs6ur3hxn5dDiOXnXzLPyj35xS575wrM/+v47jtw6P7+AVM2Kzcei1Nw1Ho57ZmVqJ10dtSEbpZIJcaySMUTFAUrawMk0FKGZoIjhO0PMpfj7KIOIoma0juwO4iP64eaUF76lrgvFduc7avK4AnRcyFNxzDFjt07h8EADPqOrQ33RJB7PbnYkPTGlO6Uq/2zXpxwhmUCIS2UlCrM+z3vx8o6dvGNRn/2+Df3Q/3HUmfpvkLJmZnuUy2uz8pX3btjsdg6r+7iS/k/yVjcQpcaj8AG1ILcMhFDFfdLItLXRKRTx97k+uFvmVJcT0YbAxz0oWlj0KAYitAgo0wbUIImVk4j0aXJt7gzUIERAcDJIka+DPj3FliqcRtCf1c23QklqrIdcBuYfPuB7gf9s0cJnZVwK93Zzd1NoRRE9qwFY40IlFLR9wl74u7OVrPNRVZa9pB/VzBqBrsdLk6RksAh17v00q/7lBMv8+v8ZgxAaChNgCvoTjDDDLKQYnOEoyIwBxFNlXFmJzUHmuF14JnFZk3AJ4ZKCJKIeHOPv2lp3FDMfj/tGtqYaE6WUcUadUy/rVvY2xkwfWmhpNf3O0Kcrtf05hm3QlMLVs7ylybbIhf2z+tX3bcjtT194QzH4hGK82L6Pk6RpCv9mn4ckxwDbYEzrCnNyXEnhjJElKwxp1blQ390gMGSEArgEdBhLhY9Sdup0IltWumcwusj6iKYQMTSsUzpMsjrORHciKAc0YNBWUXdwLWTlfFx6hZ01xRU1+sEaEnapFK9VtIdxFkBQ8KhntiM8eyDNMG0+BsboLT4ffK9jidApc+RpkrnVyfJf+c9/ZPnT//PnZC49Ky8f9ziWG8Ebua5BeZNidjYr8r9++lb5rS/eJutLW7J9bZTNq1b/2bpmcvHcVC5vTuQn/2qS9z0+kRPnrt5XnvwhzRRN3pA1B62BplHovmLmUeftOcfZHbtl8xbyAiQTKOHvG9V4MOtsDYvSOlUCazShEaW/GXoTSUyZG/VT+mNCKAVgwc0wL+asiHT1RPtvt8nyxy53HVXr+AJ76WB4fmhDW+rnRPHE8HFAru6crWnJvXCh/a+EctAhmmTFpl2/8v0bcvbW+aqskTdgAZeHpniLvPTn9tir71iV4pWQUesnH+RqeNeKO1Nm8sMa6zg2MY3LnEJtHVIWGpAH/UFhQWORciuBZMDHwCX+QdCw1Kk06u2peSZuBl+/3ohSwVH0RBLcP8zIOa7pRsjCpViTPLkzErqCntiC3xZUbmrX/dNnogqNdh2QNCq7FlQnYfWpnBIgPdaprSCPGyhWAQ37B8waRBtFfHmo0Tg5zcgH7OCIMVh2Cj+ntsXHWAn3I0rA5FTchPfnh1WOGo8hy+2qEK+vjn+cenX28FAktHa1cli0e87iDrlSGZ3/GDJVXPwgB/cgZgI9RKL2J/hvZOeAv5mBnuBYq/VTA284MsSOUNdX/caxkPnLHG1KnogsXdyRow+uW0Ea565M/+wPKj7ryqlNefHBNXn2ffus/Nq86k+cHcWKq37v2YgPdeGGoYGhtXDQfeHKkEODLtynCsZHalFXWJa7PvYZu1iXOCxiIYQ7E5yFcVeZCcBrCQI5FLTugtjD0qR8cf9V4sn48zX6r907GtXFBKlVn/73I+a7G8VzRyapiJO+bM3SiJhSbjAl/3BA3sY9pnjXFIfyPJTfn5+b1fsf2viea9MFefY5j2LhNON6/3PdkJFyefYtifzRC6vy21+9S+49silzMzgk8CrraGnF5K73H9b/5n+/anf/J98r66ubM1dOX5KVvStWjfUxLWQdSqSYyCY1CRbCQxNt8W64P0noPOMtIwptWCSyy2IR489ddRELPWKShgo39ok7ZSWK15w6Lhj5K6cgKHIZueXfKJEPTypDm3NSPiZtUwyNpTFelgZPHnoq+KvkP/S8xmZTTPCRY//k4soArhVdP4Or6jxyJHtfly5sy8m3r8gzHzloH/ynR3VzeVH6JuK7ebFvOfrgHp3Oqlt1qzKmBUVAAxUaESeR4OofLcUhqWqUE/roiqOL6KipUTBQRnlWT8i/8KRYMBuJtik5A9nUOfj+0/w0Sn22EYOL6v1Ku05bFIA+4KVHLo8nZ9Zno+K17vGJG1bbo4isVdrf0GijgW5YoEG5qyFSxOub25tU0nKXKB52Y/TQofSZlQLr6kzPKSESkjJatxT+EByxCbrRIFInx5NGghG4WwlECRjMRpSwlwqjBBnVzUlcgFGZ5pHLTf6VYzSVpZoRwuSHkDlwYUMtMVVzxGJLcz51GVJxwW2FI7F1X0A5gRzO3UAAkDg/LXVbSXYT9wwVePC6OJ7DKxzi0CRRhF6d3DAqc3YtnDda8AlqbcUdqT9g7uqOnLt1Xo+9c1Xe/a9flc3lmT9zvlQJsCwX+onHbrHCGZls53r9mrQgM2HYIH/SGi68m8jNbUrDzk14tUghJ3Mdy1DC+Zx1g4dIlsyazDF9W6O99ii3axwcZqVTJkzqY+MffIRbKScaNNUUU9io/MQ4GudB4htZDsTcL5iA7woUB789eta44pmuqahedNMnB+NpxpsxAKeDQjXq8daTsBg2xHEaFisCK9JkfkZmZUG+9txLPzyOZz750INyau9ekc2tZsV/PV/XdUyzPbrN+3/wkWOyZ2FrV7qhABgoEuB7Hzhhf/MXp/LYwxu33XbnqaUrW9UuPpW8EWXYI4Z/FhVF8ZXzKXVqNn4us3NHEGx91p7++FfzHSWm7DzGwR/uAXFrtDSJgojYfjmN0KiEngaPAA4EEq7It/QSRTE8IaM7IP8gHyZu+KkllLHPxfmArb8OXlM4fXasb+2ipJvcMBE+FVqIc1jVIYyB/7GQT8SHRq/3li7syNOP7tf7/uCULFyYyubqn01ZU7q204cX5fj9e2T5/I700paceATkKM5YW8U4X3kIqXR7u4bOvjyFA7JNmLKbgGiAkGbglA2R75Lj6nh365qdDNlgCQvHnyA/oZtLaLCXWpSa4EYqvwqGPysjwzsOMkSNGiKPg5FiMeuJwVzMSmrWkjeBCUT60Q+uRJlXjvtUizCSKfn2uzUQYB2n6wQahBP4VimnboM0V1Pir+eONNxM4tjpgqmltP0IpAHPdzQHLPvL9xvd97SAzhYGUgz55WGU2f962CDKyIp1Iyoqpai5m9beQGhwJbwGYEIGQGaNnwL9DCBVyZjmgrX4+wKkn9WhuypmYPN08YxbwN8Iw/dBYs+TEBKJYI/T3l8GlaPFBdUdkWMPrMs7f+9kNRTMaff++528qKB57j0b8rWH9+nK6U2rHNIUb97iuM3IJEiplQRUF6F1p6aAjZJHcGhd5ynh/jc5bsOSeAg7u6QjdTTOGAfY7p6b+rFLeO/5EzqggR3x7oZYnxaeTSjOSf8zTkdorsyxe3Mero995s9vDwqb5nj/GbE9KOKY7hxUKZLom6IYWzZGrUwIyZWtjQEWu7H27mvUbC7J+cnmZhfSzvTso6dPXz78+38gp245JHLx4ne9LP5Mr+tWjBRU5N88uyaffPIu2b+y+U0PrHFqMrs4yNW798mgX5T8/AsfGe9aODSZWcDhyvTR1mu1UxtzfbA/W93Idev8utgbK2M1cps7dY3wMAojBP8mWQ0uZ7VCZ9WK3TaDQiuMroYrW5Th0hQIrBGYCpKgwPG2n51F6g5FibhwYhzYkDhgSC7M1wyyfZuh46uMcuEDlnHwEmlBs5Hrfg2nzHhm/XEjqdtroeT74Pz5bTlz+5I8/ZGD8sgvvyDXVr97ZU0d0VzYkS9/aH8QV3NkSCEj2z9PdR3IGF2lOMDFO0gQMAmhtokAqBnR1hOjj5Wk7SwKf0dVzu1DaBqLiNgD3Wo6+Se1h/1MHK5rfucDgXFcAeVjwFQSdCa30PIDNykrcb4BUJLRfCdSZ4TNMlE2nq6d7FZHrHmy/4zcJNwQwOWJ6pOY6AhtMNQoaWqE2dZcYknTCzygdSgM+JTimVXCVd3KNph/10iP3KheBsWZIv6rdJFDxgbeRiT1+g0EwkKQi9ueJYgp1RexFJaZegl8pu685vTPOCPhqMaivwcRvtHWUxSQYCwZHV2RGwX/b03xiIdek897wjiQqF4Uufy2AdbwJ0YMQbTH5V0sX9ixV+7boyfuXpFbnrskl/fOfteNw7CdS95aDc8spehkJ2sUN557x9q6FbKlvkiIjTHhyMJ7DVBWA/IMlVLna4t7NZoE1pHojm65df2RB9ONKqLV4lsEwakVxYAOrFJZSP2hKUOWqRDBad+bu4Bqe8r47OAhzX0NDS9hYEHgqoDtTa/nmJc30tCusUvnVM6/KnR4IPlxwHppW583Sv71sSRv1Qo+2WSYlZSu7Z2fG2d/6Z+I/OZvDdJ+4vV9XZdipHiN6ETk4P4sH7r3pKzOf2MwntQCWmR+UeXt85dlZn5HTk8v/cV3DAvrMzJfN5ak3QkZnWCmItKH9kFm5VYUZna06SXvMFAQc68NCyk5ydZSjaxc+h6VDEpdyGyZnlEZArkhn92RVX9zCK4RZ5QQFOSRKhch6U7I5gcWmNE5KOdDat74aoVFscnVUiJBBhzDRSQ8SYiNgBU2JCEo+mHMof0YR3Y/0PVKoH027HZLZ7fl6UcP2H1/eFJXT23J5fXZ72pcM0xNthYncvSh9QoBVyeADPYHbzK9lQWZHMxZwybsh12C9t9QP5CL3OqFduI2+anRCrwi6AZqDTX9KYdmPCWQydgduQOXm3Vi/JO7a6gk1wlOZCW2xcBd5gfjT1PZx20Lc7n4CDz2g3cg5OeiP8Z4JBdGA3a/GNZ496ohKQw0oBXObXpg9Nvx4IyAkmI2rfEowo7Kf6P60Fpoqr22hitcVRIliwIoxSpLdVST41l1JoegY9wtAGIkcPQfgbtTZN9m/OqMDe4fSqSbV98fUk4lh2h3siclu8VlGC2KP+89rBBAjJdTQ9RZJdQwii+MhRJTw5uNqE9ZE9YibAGqazMPZ2Jh2rkIkL7mhzO7cqx1pCyFBlhssjPKxQNz8uIDa3LHE+fF9squD/F6XxUVOXlNvvSh/fLi9665r0jheif/tBqUFziBJJ693MK0EeywrYCfj0FWDGZahWZY3xySZC7pTPEWEwMk5M7SNXEM7NnlE8KhfusXYo+sZkQZuTOsDVMbNlYitUOlFN60ndfXLiNAWLBqApnUDIm8VGDU9WyIDWwrKhqg0OlxhNUGT1ka1zfRkwBs1sxyndtGpmbYzQVy1p08yjCn8jM/99jGr//9J+X5p16SycLCd7Eq/uyvN70YKZ9975rIK2dUPvWpWZnMXCWt5xte9QLu7MjnfveqfP9/9onJ+tLWPVvnN2VlY9ZTYigUyRq5n7UcwB6hzYWRaWhYQ8nvY4Qy5Sb1xv8Ab/PNDMQBA2aaqe+P4mK0nMEaiVR464vatiR9oyHG6E6qu3wQtG2IHIE0UlY9ABhRSZpcptjUF2O4GpBDhakLHpKo31HI5XhaoUyLzV8JywRQ1Lpd7as6XD7WMPNXduTs4UX9kx85LB//h882hs538lKR5bPb8sK710u4l62c3g7fjMhj6VpAlaaZ270nVPqMkBbnmAIf/P79gOHOkkBSxAMYNlQ11nIxKuBlxwX3REzmEXFaIdW+CSoXamKtk3mHLMZCyNEwAbeZpxTRe8I+2wR3O3NrMuamNAas7Sq2tMjLVBp3jv/D2Z3ztpJ0ZhbmKErbEhtEpD6iI6CB4pyJv8LZQKtrgfC5h0fhADFCMgdvRzlt6qATji79qmXPKoucGRUWMU3YYAEW9lLONuoRBl7i+Wk4Ke6jskiLN6FIiRDe+zAUbFAEX8rARumKmYRCeDRGEarvKBxJNBStFjEgoxrkMSw4sKm0RsXI0iGwx8uvzMTazb6gtf3ihW15/j175Xt+74TMXxlla/E713GWUeqlvXPyx3/pcOWJVDQpuX06UGQ+MygqmUHQacSJAsa+0tavdpyI4HNLn91AF7tYyqFc4r400LMal63qGZpLenDYU4zQtHKUMFYKGIU7MTuyOswhcZYFrRvwNJg54x5XFotolxzOmRKC0hOZMECKjNtHjmDp+Lnc9VojzoVjCc8aglhT5FSgqMWwRvPAkIQsVdM01h56aXVRDty5/4f33T7/+8df1Etr+29MZN2bnk1Tvv++fSK/8A8W5F/800FkTr7+Id792jSRxRX5O3/tyMzC8ouzF65sOQltnHqOurONhmYOFAVD0WkGNU6k7ceQnpRcZQIou06nthd6/KqVGSf27CxN4OubVyZEW/9eUYcObNgG2TUmUS6abBxkd6EvZJPgYBESnfiXhJRrC/yzk0lYbOI0Y3UxnXli2u4r7DbIQucH6zpqwcYFCYUFn7GNMuL61gBtBSWHnYn4AbV6asu+9MEDdu8fnE5Hnjgn5w8ufGcEuXKJRpMXHl63zcWJLJzecvKmdkG4Wht/g/jI71pWPqIV+q4/dCSVt41rAhriTWH9hqfWiYaV+lP3qxHVTcoc7oLD5qpDXxTdZSbo246xAc2Mv9mM8xT7GyStDYCNkCRODlhodChOk44nDcMSz0mqJW6CGyo0AOjoUhwAFibkWP/d9TEOp+smPMashWFcZUpiQ6JVTTDynHDCT6ruduOMlU6zGuylSi8czSKdtC0Ri6YeoilhLW1xOHWCCFoMUp1S9JyFGhoynbBQbbOCNqOJflGbKVzAriOU+fF3XcgfMFU9SAKZVVgO+PoI0ErjmRYqrJ3hrhB3WIRosls2wpXZ/Wm1ERDqHuLU2xbSSl/TUFPjGM9RGEm78W5QLnOXp3Lq9iUtGTLf+1uvyubSwneEYpZncuXMlnz2x++Q4/etyv6jV4pDQNDCie8K1y1wPyxbU/f+CHJS3fsSC7RaJGJvTq1q5/33+ZOPwTjTaepaM8ZhgCWVBkdMCZbBOkw9aQGNVriwATLooMlAFVAX2WCsd6PMrS5vBBgVScOsDYS+7cwbMi56L1GIx/j6qOsX60S5wv2uJmn1E9HfTl0kXD8gh0Sh1voTkV2tlPs4D0lTmpGFtCCvvPTq4yePnjyydXn7qavD5de/IN7A12Rtz5v7A/aui3z+iSSf/M0ZmV+5JosL3Vztm7w2hx1ZWtmU7ZdOHZoc3lmczFeDntFyfQ4rxpGJEewiFbfBf2M7k5XhHYOihDRwC6KHySAZQbSfAfmi34MqoE4lfUvkhAbjgBw+JT7coSTC73kjJfpWlWLPidg0NjGZH0cbgUWI2Vu3myaJUjx8ljEoZX5I9xxpRGbXZwPnSKpOtAlpyYiFCo57G9OkmIR22x6xf8E7lMnWqNOJaMmmuOPJ8zWrwr4Dp8fSbZUU4GP379Gls9vGUVB8lsDHrfYbcd9bg8CqLsjoDYtIHJxqtDdKLY5R5coemvxASvW66pk/zZ3xDTWBYUOtg/KMTgjjh+AXhk2RSIyNmTEjfWyoxEgQGx13dvSDNFi0pgZwZn4t1RiIp2SrhH+O/5iM4x30hS7HBmSJaLKdTZowbonU3MytOPV7oUQwCK9FsKMVEgbDUcaguw4JEkPVb4q8XGPpbYScFU6wvEpKCm/8GMcYUlfAxeLwSxLFJKZAKTFsL/4AXK6EAAAgAElEQVTt3y+5w2G760biPIo8jXkRRrgN6DcYxtQPOvhSS95NZ+B0fpaCSSJA5jgGo2GEWIB3bQXGmZoLuT4ma3X/8l0IJqBtiqyc0qG9LiO0bPbig+taiKylAbDXS2RVD688e2hRnv7YQVu6sBMyN6JuavEUeXUW86puffPBbP/J3s7/dKK0EAV5AkLYW5aQVR+Ef/5gJ3+QnGPUGw611VDCC0MlhbdKVRkw2iFRWGtBuuEwqFFWUlxXEq7U6LeNH8WHr36zVEEPZb3W7jSIcCS51t1lN5ZrvNIEw+jQKF3GDWKbMJuizwx/CmuYOrlNXPPDqDY72bp2/i5ZlrX1+/bL+m1LkqdvcmjdN3lN/t7/MP+m/oCSS/Pc8wXZGGV5j8m3C+bzGfVYwvE+vpTkltmZ2VKLVDhJteP4ZSr+Mm8NNl1zLNhpbdrcZ5LXCjAHqRrdRBeI4GgwOzrwbnI/1FW/rW71nhFsSfjMlFQDyyx/RnCmO3JZAG04ZAgattQBBUar/gnhhtC/AAuCbk4Yr1UuPqZwNyAF+427mnG0D6dSLMng4Uulh8UOYhq4mXP1PFTCJXiK48PxHK3s+i352sN77WsPr+vb//hstaB+PUZo1XH14o585QP75Pyti7LntWsKqoyfqHiXzR6AOkrm3abGMOd+LSSYA54n/SB2dteAjgFn4hiiv2iIi4wHv7ayzC8U9Bg8lN27RQEPM39Pu2FBZr8jhKo6c3mcaJUnA98m7LqdLgojBhNuZ4bQJNXEd1vvSOUXI2BOqPng5uVECLqxOtcjSWvxKunU3bWi6BiAImfgdUH+xR3gkFOVCcGIXbHWyreNH5m3wuF/9Q0RCyMboXxEAW+Hh2pSkotpdxgbblXtWkBLwHRw//mdGvJvdaZOMIh8LxxnlHvW+wl4Isxj8Q4H1JW9BaxwuJATaq4WkERVT7gtC9v+aFxxfS0GzTlMFWluC19phixSvqtstPyhjYhx7IAO9NWixxbPb8sr966Or929nA4+f1mvrM9+22eUd6+MeT7/Q7fJ6duXbOPYFeUoW9kTEkaQxOEEDvPmOOvLOHtBz9055sW8VKHR1gyxAC0mR7e4Zcxn/SkDt69AitQJzxFKo7wuePSqXgWD6+RlBcoMslJ8lQdTluNnhStsRCNh2yFiQaqLC6XwsALITGNjHWWUxtowS+ChSgytNcjeH+RKoh79Qrq2KOr+aNcMVVCQzdFYoyxSWvflkrmiM5PRtm0yzOTJJ37+8bnP/doxOfPUqzK/d/F1rYk38jX5zP9zHQTFMyZ71ndkZ+fb/Lk6YRjlypVrk4uXTv2FA2nv4kTmq0+IG3MpSchJnIzj+xClvFRUup9EA4PrrlSjIos8tJa1g7mDJKA9wmehliDi7ttK7baZKe3EpbrXFRefshom2h+DBpgj+tycjPbMXHdo7cFKSoxxpG1R4lgilq5U/B2FM3H7yKC26PKN5u2hpwGciFIuMb/FOKnsN9Iu3IHMk8ytLNUdLkPxFgNKWr+qDjv10tgTj92iR544Xxj2Mr4OdKSQVbfnBzn6wDr4fhRYcD9JPM9iYlJ3I2WL72/DGwu2TvBXCr90pSK7weJG3SbAZYE7LvSvbsAtpAern+C1RqvDMAbJwuoUtUHTk9DZEe2dht1XisVi5MQiQbEuLSM9PkONLu08z+h/AIiZB/9xVBIh5bgojuwHpcUE6bWVJ1AfqqAFcT3UlZM4T6zL3ONhqsrKbQwGMh1g66Co15qhPj41plpV8un+adaCo8TCZFBhjz/6Uyu4VhV0LMmWfrrh5MgeIuyHbGbjn6thmsWkXHl/JYLWCPKI0LFEnXzsJ3btGLPHDvhEwUoUlnN62hzKr2WXqRuB0b7eMszFO3It65zINyNFmYWuktBo7d1VMzMCmxzVRNRl+AawZDXGJBnNfAnV5FRuGPG+YliwleXivlk5+q49csdTF+Ty3oacfatXCcU8eeeyPP3hA7J4dsu5DQCc4cXXGUbX0zCjnqA3QdhgxBCTtCj8DyXYvg4z+GAg4Ptfb/woFLTQttbyuaOjVnVruR1DfboSjgtkgmFgb2gyvDzWnDPy9ShlYb+WkcistNLhVIdIXkpG1q42bMsxLDqmVkzedd1hN+EVRzIcZ146Etdm58cyAwbJ0SS120y4jseF7/MZvkKuMnS+gmkaMMWc+mWYTETTIA8fOjD/5ZPPydOfeVn23rryuo72N/I1OXj4BhnRf5NXuV7FV2i06WQnX71DJwckTSdTwCnZe0JLbayn2PHjUQhYzQnpOnb3MQdoroHYVxs6a9OcKCVwXNCOwsH4anOS4fUHRNtclGXklZIDWgkMllsnIGFKAPyG39r3olxTtkHYJISH6tw/g58zKeRo1d4CrWkT8YStu7NnMr2dOvBIwgVsQBPmkAetTTsuTjjAWVhlsS3mJugnTna1oqye3kxlHn3sXWty95+clXO3fHvuSEFFXr1ntXRrtnR+O1LALT68z0NrrUjmcphneh2QcaUTRUtoC1EcuG5CnfRPyn129b/ErFhaEeRZ82MkveZo4RvhDq2TDyHCNinFdCxnmnVjUktbNN5Pj9QAyMr4uFH5g9ox5JFz0QdTjRGSGzCZcLJFkyhAEKPcEHqqRrSN8RuAoZugGqCCKxreseq+SHoBdmahtOKkM/ozdHgO5FTCDG+Bf80iONrfa4byQgeeqix34eljFCGrszvF52L++CfnGXcxbF5CZJa2pQ9PDm95i4ISBomD7GI7Ho9FXnUQlhksA791bv3qOiuBEo+eQJCzRFcTVLPwDoIKuHEfQZupOHAitk6YRHgtFe0vPftFWP22//IJ4jjCB6PvpesCn7+S07EHNvKl3z4xzG5l2Zn91k1p5Yqc3ZYvfXi/nL11Qfa9fK2Jkf8/5t41Vrfrug6bc+3vnHPPffA+SImkKFIv6mXJtmRbtmQ7Uhw7RoIGaYAgRhG0aFrUKAq0DZzCAZqkdn+0QFEkaFGkP/oA2l8JUjhGnAJtg7ZoUFsB7NqtHraVSrJEiaTE972X93kee81irznGmOswsuIfvFQ/CzR57znft7+915przjHHGDPrbPRBWd1AsTTWnzdy/Hy2NoP+OLebQjO8IseaqWxeyhTj+C+bZv8KDgUn3bVN4BbfMxa3rDOYs7czobWD3uO0VUtGQJK1IEsfdRk0vylJYd/JODMBrKqqLWJEEpUkmbtmP7LnHRy6yGDtOKvPaXwvBRW4MzQSWLt4vRAVgQmGKKaJZoYOUSYqOHW289F972DfrO3s9lduvLvfOrb987sxI+6tfu329783zNnv9Lp//9SuXLtg/8ov/uj+/rvWw/t3m1089IhTuhslLtB8jB80Sv/BH+MR6kkkWjZAb2gwUeewh2NyBkqzpyw12IPB3Jl0BOot28cz1c9zJkanOtZRqxKezEyeDjut0lcKr8xKSJhn2Io+dkvC7zKm7zSUS/j5LKvAfBq2lZKuItXgcBOU0MzORrxbyBVkaz0V78ZL4qnnHHOR17cSNgFSk82OBqe/HkDMU+Nm40tuGOLO/cuffMTe+zuvWeNM/D/s5Wb79/qo0m5d2cUjzx2NlkAn+umpoVPzbJiCOgW7rHlxGFmInD9sV5TITeW/A5UdbB/PosXOQMgOMfSQ46erAc9cCVhycl8fxRgZyc5ZitkKMaqXJv7J9tNrnjRuaBIZEYVA8Bv51qDSdofdnuphTOnbSvgRyzFMR/wQozhnlPi98uBqJQQbXcHGdWiclggRQBryJ9tk5SK1ohtZVEHLHNE0gB6S5IFWqsFccnyFJHUnFQOtppHXF4+v2KNgAEbrbBESHbeFCghjQZmRd1vy40tkkMdcdyxzZqxV5y4DYFlTBpIJyQK33KRbsim1zTjTASUtZYm3BZ40cjRiWpTjOIwaRiuxjOfkGvRjQHzKTmLURNp8X2XbYmECQoX/J7p/DjjKUldCAlSS4+z8jdW//Z6L/tUfuRY/8L+/4Dff/t3b9du4h+uPHWzDK+PC7TUwawf7MxoeR0dfNT1jyePjdOQ2FrQqSQTIRLqhExHFu0trJIBLUQStxsQQ8ddBYIx1pBE4Qj3G8cgDF4w1H5A6/3nk54jC/NCGFl8vERznitH7ATElv3bNNp3xLXbZEk/Nz28uI2lnPgUTkjHrJJcOtPrgqrADhM7MiBS5MpIFLZ4O9d8dfjipy/DJdoQ17pipsLXLdr7EuYuHfuP+rZ975fWb/9PR6enXj07/eW2MN/+1Ozn9I+Bzb9Hr6N6pnb9w3h7/4Dsev7N7cf/2nbGHlg5uDyBrCP+ypmuOWXIQU1U1SSZnawgAziKtyAdECoC3IiAuAU9KIB2IxFgWRYoTNRpnZQcg6Ua8MomiROTFL3ApfJrnVL+tm8hNgdEZK8avNbEGsnwjt22AImDhlslP8rCC476a1BRqK45OFdpCsHTsrrK6pUWU+HmQvxsrOMo/GX3xJbHr22jhXHrlOL78yWv+od+4Yu/+/I3vqqzZCHTHh4u9+sRh7O6nbwq2eYblkTYsW2mxIY6DB++mBKUlKx+ORZhJsqBBN5KKhbw4ON0SAUmBfo6fQw2djbNxB7aJceBwLGQahhTfln/vfL4IOXSi1hg8NzJUo/BT40znMTtzjMwR6sp3F5JFNQLrNzQhyrO3eQNw5d6FwYmLkjUpWxRYfuM8azWimGzH7a/WwP4YIAWsD0YGBPZNalWH2SQTN2ZUGmBsSuqac+gBQHElaSQcwrKzhGLC37JfNK6NMXtxKopGEABry0QhzL9cmC+ySxOC8KYOUf5H6dRyyj0os9sxnxMjmgbo5Zmx8Fr4Jw282C3/w4EK6VqHEnih5y34PAOLXqMM7gVEtqIMsIBJxEek+8zg1mH+wuG47A5Q/dHgvgEiCZ1cRgLdPdOs7a9P9q299J4LpCX8oa/tsi6+dmSf/Qvvsmc/fMUe/eYdJ4+GZHKhWTOgmV+mEYwdmRAzlPxbmd7T4Z4+BUUKarR0yE5zM0UrRCz2pzOnb+SCB8uohKs6aahI5cb03NxFWKTZYEuMxEy6lIInawZSpEk8/SQNwElmMhzMQ5V5g0qhc9TEghDQ1+zQM5cXXNrlfuLq2KA+EDcuf7qR6EW/T+J5OKSYEAHcIRi6KeNGJbWpgJeNaH3x/AV78dYrn4717vuundv/+kPn9zC++K177da3+AO/22u7kuPjU3v+2Rs/euGpfvXwYA9Vfqdx/wA/05coZISTow9YPnKcl85SYz/cC0DI/m4fyQz3yuhX1F5R/ZEUM5g/iJaV7x9Vsuch1MhWyD+xya9h7KaUUneEPGC9DZrzEas66kGngldjhNkP9np7mxG9VGk4mg9OhwxTscEJH2Bvjp2SvkgYTLK1WrLS7+TUddIBDXTb5JVJeIGmfwcU6OnO6Ov+nn3hZx6zd33hpi2nfUxM+U6vjZ3/0nsu2ovvu+SXXj8Z79wDXpeMC62o9hxAgSo8km9rCsCN3IgFmSZ6Zts9GbSjPeaKPNiTiqbABH4A1ODDIJo0TCgK6QsAuJSnWy//02BpagQ0SsbhSYDpGLfcBojdoRZZNHC1DxosPe64AlO6nudO55TI+vxgr0TzSXAaDDx3TDVpDHyOach1ENGpA1y3nveda9TSBhQAnXH/NY2SGceEZR9s9DTVQ/BqaRiciFEnmBgOBBgaD3ugT87x16l/cWVWmcfQgWaISdZc8OjYrzg42Bgbffr0b8DkDSBlZ9hVeJyNhmjcxQ6X7TGvyIzVpfYiyBoxkt/u2R9Ks0O8BVQ0EXQHYJyptiiaQVEBRpje+OcwK+kFzslRlILUlsDJZGQ7/cMJfBHRPL+hHU9cGATW3XG30+/UqpkVNJ95NC7dPC70qTIhycT5DpPVGJeXkcRlBKnU0cF1gdDnGmuMfroXDx6QYoDfjueXmUZD0psSgFSjLJN03btEi3zjWa6SK2khb6prXAQIQilCoUN8+eXlgb89sVWUf5pXeuucFjb8AnKhirLC1jhzEQEfJttpXZuBAlaX6nwMTZJmNUjPrh7TxF+MNmg58mkkPm1MBlj2FrMT+xf+zNPnf+NXnrPr9+7Z4bk/GrH5zXrtNsLo/y9eQJnu3bu3f/vejT91eXfh0q4fsFPB1kCMwAwRPhg+IQa0B+d4CaIMNkTIWeOfIdWIkNrKGBLYufM0y8lFQUorVwNYs7OGTLQT43hGEhtMIZuRawEAN1rpBNnI/+dWD+124o60kHe9/yTJZIOASUiASJBbY0ujOv28EpGh/RJPIA+Qc0ydK5iOgN/HrwIv54R3CBBQPLahG/bQK8f29R/e5lZctad/6zW7/o5/Vlmz/eb+3dW+8QOX7fVHDuzh5+8O2KbxDGfbM+jt4ig+TEZmhBhMA5xZ3RZpQW2WZKkn/sU+qyoI9mryrm7fZ+uerUkUcqc3EQSLtKDLU7pTrReU2MlYHhzNbJcnPSDfv6WAI8ipDa8uXoGAZgpU28nXgQu0LLnUK6+5NUYbBxedaFztxsciYsLuMrsNjOGcWTA6IwsYsnRtmLttnYMDPUr1o8CZyTFspTHiAJWB9JG0ANvKQ1AtgNKQNAsV0jBQQbN7nMZG92yLpXFSpSTMDeG3IQGp8agZ+BuFElmSUgtNplSAKAnZ5kgA0BGoc99Y8CJmrVIWZ2eqTcYB49iEcGZAJeMRd18HZr8lnyukPM3kPJis4OpU5TyfMuUKtkIs24gO84ztwjt093z+kR+DJhEt9ce1b4TUb7/3Yv/WBy61p/+vV+3mo+f4/aY96rYNxPydP/2EvfrkeXvb83eR4TdQGPo8B5L1ibfqbDOaDIYphrKobZicUwzpaiFb1tGrtUzBszHSUE6xnyc5qwCvoEApM3wb4CaIO8h9Qn/Sm3GHpGx2oIh0hByg3MiNqGYxmq4Vuxshp6dGKWEoUlsdn5uc+Z787UaFRPb6ODEwaBZfrVDvQrNWm/jrJf1S/OP+A7ZGUVZ+o3Jh9URE2RYeI4Vb673nKMCdNdvfc3v0h991+f4/eMmeff4lu3Dp4K1NRu7e/h6M53vDq4+hPWZ+6ub7dnByeu8jS7tirS+xrhReO/B6ANA9RAXDy6lCpOdVORLwNA8Bwl6PEIt+mEW1JeAbAmYkCmBcA6w8Op8o1ziSfOcUZ8Qp+SYYTcVR7NewpfE/oBMmF5IpppN0a5RNFi5X0mC4yxnVu7mBGgd0I6CRRc6QgBRLRVSaezCfkddpFYwwtc3CPM7aT8tQA/HzOK/3iz/9mL3n/7k+Kq91dxYd2Tvqdufaxuq/aufung7jh2WAGMBlCP14+rOTV75mRq8zhpYkHdIeBGEmlyoP8P0FZzsUpNC+wRIiSDYbqEin6Hcq/FagBSLg6ISa5g8Jc81/QU+jJUijyYMKXRlJ8gTMnPSMwUm+wMseltgdHTMtNbUg0sI+eypDgUwuAc0yaEiPdTWJX/CvjdNqCYDk/WJQT6pI1FGDEWOEFXv2FG1eEY6ZIQbL+oFUaTJU3orOc9cmpKLqf40C6NSQdsoiCcHn9+hEvHH8oJODwRETcctQV9BOSGZX2EnpKlrXP5w2O21T0HDihULSx9k20rF5XRy6cV1iCjYxjI1D8cc1J0sbfvIsCoF1Xo2NjrlL+M+VxryEdk3bONLRdtyQ04Pmz/zgFXv/b776HRIRs00G/PJTF+xLn3lbXBrkcktfu2RNZY7I62Jr1aoLJxlcBqHx/QbjZBWPS/gui4IVRZCGdrgKwHzs1BhSxqdJB1mO9JV9TgrnC0YK+fgBLK/pyCNfjE6JTNJ9WUNOXPIyt+ZoGNPQcFfojsZPdE1RhvCsg7+EN6tCEszDVE1gGTR6ShGPCq5foJKTcyAGhgUsB4HbZK8QJZIBxKSgf+vTbDnSsridO3dod9bdB197/b7duXVk9+6+tbyR3SNv23tLP/A7XsRiduN6t5PYs7/4l3+8PfmBvUvr0TbhdyNSHEufoJkdilSd6WkeCcSpUihTtFO0coPqASyF3hq02+rroDM5LksxkLRwawRAY/r74JhyAfG4mrInVmBiDcfD37EDyBZnPEqoPgsyfjvoUTEWqmyEkRGRKpAtlISD23T9wsz5s118lLwxxBK6a+T1TIgFrD39BmLkBDo4kYkMow+9fN+f+fhV++qPPWwf/j9fHtN4W9fGsIvXj+0rP/awvfzeS3bhtSMSzpAvlOpY1ULnqHukYYupQnCZnnHwCl5IlKqmxOFo01Gfpwv6yegCu3I1Bk2d3LTi5KfoACFDmtOVgcFyRoVMxIkhC6M1WHYEp8hoVAe/llvl3Q6da4P2SweQ5noSjF4MU5E4RynYKcnHVmEXrRcQ95xW1tMy99xgjcNGet1fpWM1Y5QoB8HmloOeYczlOd16JAYL2Dy0kW8g1OQeilYZQvi0k87U4ibRySR9RxJdqzcNMpsQIObPjfgjBiXzDg5ysE8OyUkryTzF62Bv5JCwEWdnN72yK0w6SRaycWC92kHzoanANorjJuawERgwMi48SeIchAuTOCwaqFbYMokk5o5Fug5w88LNU3/uo1fs1Xce2oUbJ3b/YgkaHEq33/zzT9mNxw/92jfv9DQyTKiQZGV+x8SUOGqIASc7Xli+lWMaJiZv34vmG0ZXj2y+oOOMGJnxrTfSoRN8zl+jPRBRZK+HGKBuwV8qVwHmwGiUB2uDrqlBPvsKjRDfSjjLeAACHzgqOZgXnc7mNgVOXWiwdGN8784nSqk4H9tUhELH4ET0h+QSxtyVq3ETyH4ezXYB5hvKh/2bT2vpalFve/Lc/oHffu3Op0/X480K9eb2Y9vw2jeURA/stfulf//GW/NJ3+V1/pzZSy+H/Zf/9VW78uRjb98d3rywHo3Nt5yuPacig+mAutsmUxEsocodmQjQnMlJbB1dRky5yBKvLgrJTefIzSaEBMAd1kbnuVM5iRE0ADEMpZDGFeSKyMwoemHkpSujn1p3DKYdJboKUx7wpTJMFZCkuIxnEAsClIU9GqOADIMZpqnPZPRzXH+ioh0VKDH6SvuzhuyYfsaDFdycDreobVr96ebM2uO3/tw7/Ynfv2mHt0/t6MKSwWWzMN+5baqb7f/DpKHmxCBzShSTRm0VrvW9t1jXYa6Z/g4ByUkeP2qdQIbSOZdEpYe0moaD0ltH4c0x5koznWJttnV0CAslq/JyxShw9c19oyUn6Z8msT3N4unUIG4FHiByH3qRY8qr1xQmJlbdIQPr+Q0aHMqCcD4bST3QmWaaQAtzrnIuACYwjed8ftQaAOGw73LRZYI4ZGScq8Lo2DRuAPsjKk7HhNHgRmKS+sJ2Sk8qSrYlV5xOslizOh6mh8RTiBZgPV09MytdkxmGQX1jSDWzyQ7KWUtLlHGrtjGzcn9HFjlQds4aMXmvOU1Tyavt+MZtdJimObRjp+PAgFCOZYqMRNbsFtG1gMu/hwjedNQfU2ZZyvQO4gzN0dKgKYDKaJI0zGH37p7Gxgf56o8+4p/8+9+0e5f2SM+xyy/et69/7Kp9/mceHbOi+gLEC5AZ64p8f+1/Rh0Vfcyjk8mRQ+zzPA2Qr7G5g9nHnHph8EQDitmzIaKSL1QIGROJyYLlzHUE4+9IBAKza3z6S1cCgH6hskrh8zwUeD4gMQgDz1uyYfotuM4DoSTIaDsUlELTGGgjZ2Ag41RqN38ZRXirYsZzUOGgj7UWnKHHK8+cETrUtmwo0DAyGnfrtLsdnL/or7380g+9fuP1R7dkZH9/3y4/ciWtUd6Amj2I1+7xx773nJH1xOzjP2j2j3/9rn3xd7/9kz/2RLu2vzy0WdIOUtC6JI6RPw3+krY9mabB04t4BZFPA2GxuWSIeAURTwhJmESa5NwdrgaDqxgcO2AkOcJzq7loH3mJCJVZZ7EcbexP0ld1g1KHBYOjnPfJBCp/MWS/KUyHHAFoHemdwLSAn5iRMUk0jvIgdGcyPGDi3ioeP+tNHhHp4xiEXASr4gAM8QTT9xX0jAVPaPUlzr92HM++/1J88ace9Z/8e9/0+xfPj/c+f/PEXnjvRXvmIw/F4Wv3RRB1SUdC5ocQATTWvIRILWgVnd8keUKj24vWe8xNa56qRUanC6qDemmpkumrEItONjpTN1KTYnJII1bEx18DYjlAZjyYhUzFKtZlakcvtjLesDAZkrZy2wvoONGuIDlGLEjw+Gjjn0+RzaKuiQR1XJvKMDzoKGQAZ8sAr4M+5RBLTraA6yjSCNEUtSQ6Otgu5RmhKuhkpylImtkEdzog3Pmws03fyP4BxsTbjX5sq2PPNHUBrmQw12IuuyJcEBMdzy/HvnjUiskTn3MKm4pNtYqBejt9lukGAY+Wjh5MS9JAyjG6UJ2+itA2tKGtPIW4DeFNyBqAhbXiFzWana5dwcSbXgZaTGyXacOqk7K7u8bXf/CqbRLf3fFq614b4xy23/7cn3pHv39x3y++dnszMERuEab/pdMSRYDFXQKhJiPuiJuN2J2RGqLzcZzSbbpQ/Yi51i/HMZXab8070hfesTS0ySZqIsnB6wMXnIuoK/6B2YtBpp09mC0SdFPUU/9uwgk8hei2Nh4heQ7lcCU0cFt2ZRFbKZfMTdfxdxDh5TODZzhaKTkRASS9wY7rBIAyh+4Uv3NeOM4w3F8Br7g/Dhn1+L2N+dtyBa19tYO9g+36z1+4uvPje6s99dSTdvnCw3Z0fP8M2PygXru973GXZruvV6+afeVrZp/7gtknfuD6T+8OHtlbYm8rYs40p6cbEin6ypq5B30YtVrESkvBI7WEiU4sqieN3HJac1IkQeeckgFQhVYkE3ImxqGRsxPFskjt49hZOF46eQGOdcgirsNhB9qrmq8UOnCzRm5Efzj9U9Ig9RAm3NroE95pt5ENmsap6Bk1CLh3uiOhGDOxqgIN9WYT0YHHB3Rug0WwTH47Ahi3f7/0ygInsVYAACAASURBVLH93qcftQ9/9pXBzL/30L4d3D21zRxtY/I//OzdHq0BxPHBS+xddAoc1rhi5ujAJ4bZRU1qMaEWHePNepfSgeVrOmc7ib9k4AfEuIlEdTIR2JHypOaik9whsMHJqc/uTgcX8vxo5FocNEeiyJqSMZaDtNTHS7Qu+Qlw3gsNNAppEk10IMzMCI5V91bjaEXVjQZJLDJSwsi8PqT7ZO7JSzBgJ56rPzkf2QUAqgh1sDVOGmjplItn0Wgo15JKB8pEJ6M1lzHlBAFxEmiX26/J1alVxwvEnEy6SWDEM+NKNqU125pdAPnj9le/Rscc5JIuV92A2S+Jk43yqjxvkVOJ9A2/UFOGubLSzpSioczB4UXbRuHzDVBbhPzBiriCAc4c5u1s/8mrMXPRTsKC5rxiXZOjIsMMswuvH8UL77tgz33wIXv6t18dRoXXXrxvf/DD17bxDnblhfu9L7lrAvo8+ojyJmgSMocwBYCEJNnAdHAmqZnroXQ0YhqDIqySuRYLa3NJ09zpZOyaTBVn7h+004UeaFlhr7jrSZFEDpahaX2i6ZZDp1niUsgF7R9Xm1KSsaoSwQQeVymOw8aeWvrqEjXCSKCz4HZMPqtexHMmHWN2Ka1YdABSZcaePLkpjkKJZRlYzmvCfSf3Tu3iQwf9X/5rn26/+rc+Z6d33O62u3a6nswuLw/stfvbf/uhB/4h3+21LBtkd2Kf/70j+8YfHNmn9q6/f9k9Nkz8T1cAaayHpvjDdjr3vE7jqWuSvjvgiwbPSTdZMFUHwNjFSB5ern/M5qC1dAIarTQhAPg6Ti5pNPIneFpmaGRC4eyMqlXvBFooNRMdCUS20R20xtHUjXGecyp61642r4SIjYCEJXv5ZuFOjJ3TggNWuQEJWRMwoJefWHRV1jPwkPh3dtqIJUYQHudvnW6zLHxLSP7Y3/26nZxb7Pa1/eHSeu5uH0RB1sz0gxgRZTWFno6AnSoeWtrbhPTAWXUaBZLwLtEWkjjpZCh2jygTpP3jfhhiQR96CVXuvIGgPRCtxnskcMLTMr1cjK0C0YGFDDfoRchEdpWdhtmOiKY86oh/uTOoEM+SkwYxBK5PwNMTvItPwhKwnL7SXJjxeOUAY6JDJnsmUUwzj1f7o0sVHKU7VH9PtBzmXDg3ecx2Xqxh2B7WYWQ/0gOTVtBhEzAPdKkpe3P9hdWBkkmiCZdhBtllBcMm32BKB5O0MEzt0SmVoYEMRj74Th2M+ULPFlwD7nv+LOdre9LsYZfD5gBTpAAaSfegPjPVmYhqI04Tj7pD6qUrG3xR4Qv4FYxYYU0VPrx+dv6NH7xq7/+tV8YYh5ODZl/46ccGWXw5XbNxGZP9sMjaBeTo8rqQapgrsvNNlrUT1HFj3VVkueQkSXPNnZN9kC4gRpu1Jz7KTLUape7BXD+baloZemVaB7aYw3HBCrw2YTgW9QWpnzCiMOSZJMFpXlVB4p2Kae5Z58MgGM7sIuMDIeLgUsD1j3iGbkZPS2mlvQmSTV1XRVGipoVWUY6RissRO7Znvds/aO988uqHLx5e+tKlw3fYsd2xW7dObFkevFP77rOfPXzgH/LdXgf7O3v1+n07Prpn++fNjk9PD1vb30hNYxQB5iyKmc3hS8NXrtF31wVhiJ0/UaGQuI4SrVVZjIYrd5dR9dAqizZmFY20rCx8TVQnDiAyjcvTolPFy3nkbziIiiHrGLaLM4kaHqzZIcOFp49PxTLvCwp0yh2YqWFHdbJGMqi3GZvOPb8452iUaUbOzrdkHcqeWMFc/RqOhcnvvSgMFJcXV3npxlFsycgHfvNlf+eXXrff/ROP2gvvu2gXrp+M31+SXWgsCRKXLdVJBh0UivIIMwObDtCki+5bwA0CQA3IFf9BPbkAkdlCkYH95waufidVM2C14QLsnJgRM7oMvTxl5AsXLlDE9Y5Wl1muUbQ5xWRajVqMM710Y0LNmJ8LWisoEIXHp6z0/OSJTbZ3N1k3MYHWxBScCX1OliPdbYeR7JIkG3eZe8goKaGQSjGbfjLrRHrP85rrrFDOh2dBYz+OX00sRoSoDsqBDC5UOtKxoXIB2r7p7gURQRMmMhFPiQq9oSaFbQqWOSez6NDM+ZR0yMP7uVT2hsofNMya7sCeCpwzPaltFtPA8ZjbjKQ6Jpk0HzZBRDeMeEhXwPQtL5cOCFYJRW63+OJrx/bsRx4ak7Mf/8rtYfv+zA9csYdevd8wbGeeY5XJXKnCx+e31pnU17RY0uhFD2LSpacwzNsId7ALgb7h1FYXl6nwUbA587aX+N+ISyHrAlIp1NcZ/ZnU4C6kjUsVDPgcchZzGgWA6dVJXBWpsOqCmL9ssEHCHkolY9iSNE7jd+RSRi4yY6E5B3m0k4KhFQwacPfEEQB015GoY9iSroef4FWhjV3aml9/5c6fvXHjxj86befuXLp83pZlB87Wg33tdt8DN/gN8NjfD7typY/T7pFHmr348iX7iT//Q3tPf3TZu3v7xM4flHQzo2s5ezuxcZr0wTS48cCohg1oHnOzj3NyWSz34YHUoGjvPEFJ1Y7kfCdzMMikneq8CSjGARPocDqr0pJd5nVATEhLUEe/oYQr+eDbYCjBeYMQIRMfAhbGc4CVv9FAWe6SPdjEpk+jYIEem9OQV/5EnAYM7g7hAetUfgVSybtjnFfq/BBCSmihsHLuzmqvPHkYz37ksn/g11+2r3/sWpzs78zXY2D9rDryvjQgt3mxjad+oBTK4AdjbbTKdJ6zSDIeJOK7UaiRyEEniMSdOX3LoHdtEIcSWxJHZjrnBgZeKZg4yWL8HZHzDDmysLs0R1VXR62UACUoXdjJ6SorKzxjUi+MjFaalVrZePR0ufC0ou5zs5MYBfktZOJ7JQTyvXRT+A+ieeyh9BpYymR1ygeSqslMKEcFtUbAokG9pUaCjMV9OvjQNZxGIjUWkJ0bjSB5/hIn/vDP2E3wME35bkYPnfTP5yNgkt9yIK+HE2ClcoJ2bs4jBEik0BTWJ+K48H7zGQfNY7HgCs5lmIhhjtlQLYWk3rxXVmAVmtBKU7geXfHRan0JMGOrEB99cOd0uCA/+9Er/vQ/eWXI7de9JZbT4ByVqkKqgs/GFa6nwwSv5muR1TbFJ1RCkJKF9SoTKkkpAt489EFeujBId6xvNaw0Y5ekiVbQYbXXTbyWaaC6lxF1dVyChBzTBxZlXW2QqW9C78FgO7ODRU9ATqsh6KCFh077YhqN6EYIo61JSSTok9+vDJOT/NipB3A/JffhHCCcqHZnOwBiKN/f37MXj2/8+Esvv/LIszdevfPep99tp6en3+U0f/Neu49//Pgt+aD5dW5Tz7zU7Otf39nDD6/2g9//qH3+i6/YUx9++Psffaxfu3NnG4QbwdnOeMnVAa+okGnsIFZ4RRbcTc5hqsIw4abwCYJ1UZW1xpLq+MlWkFjFlC4G+9a4qKxKmBLlhmpIJrpVicUJ7dUN4Y7kP4qhW4pDXRxTfSjrIynmCtyOscUQY+ScHONgVVOl6USEYtqWabKZ3NjhzBP6Dc5t0nInuOBKJuopsdBl1/r8zZMBBf/un3zcnv/gZb94/UQ0ePXwiwM3nYxikhkPI83IyqHCSKIgWSs6ppF26bM/QKUqzh6q+gnBg5cFRoFuAbWlq6oRJ1NmR7olYDSRcKGgopxn6jW9ASiDTim64Jum+Cx+gxFTA/NjY2LAZbFLS7m1ZziGxyAXCZ1REQXCEeZ2mxKdqZDzqFW+DSAS+Qaj/+U1X9tDfU9n76FxDiPf/2x2RPJooh48uMrCg4+F3hGE0gcEo1OfM5dCpWenYN5ypgglnKpc+Hskay28Rob8Xl+tqwTRiZs7XrgOIBif16zxhNXGrpmHprVI9AL/X++Qlv+urdAxGgmnGEiQGGbNSOUYJEBUUH7gebPl5RXy4t8dmX3rA5ftiz/7uH35x671h149EhWFqw1PzTTwnrL5fBi0QBdUPFEZaC7MwTMFJOjJEo/kgxWbwgQ68/N4ECv+MmVW7kezBCabikvp9S/RDXg71dsiOqrBcs4PEjxNl0v8TgbQBCuaTfCVcwilmUAyU8eUOQeHcXD0R0yyyVpVzlPB62iQwJzzrgTq2bR/yTg3+tB02P2R2ZC9pY24v9vbt2O7//a3PXrp3Au3btkr158fBofTufvAXv6rv/oWfMobXhcumB0duf3yL1+xr33tnH3fBxf7p19+1f7Fv/KJf/cDn770n3u/5PvLYV/XYzqF6H9JVwI33tMcPqNYMd8GKt/A2hMHyDD5oCcbpGEMuDJS9OqSsZ75fMP7J8GKlhYknbkLPq/AlAJ2ImZd51wBM1VI57QBNtGbxLMelSdAF1H+BRH8QyEAXktPQ4y1VnulLqROqMdSYFHINj3JOKh16CYFAplj5gVqAhSXZYPukEYXi3sIlDlFa/uD073F9u6e2nrYfAwI5DZpDQRejEmfSgiTUxR1gGcPbytb72lyswq2UI+5wQ6gPM9HlQuHewqlRlhhFCHiqx7LWH4rB4PA4roqWgIKyZIl4bcpaVVvhMLsQNtXfwuzhkYohQeHrKoz9FDwyE9FpJqACeehJk2WG01thCiC5knpbWIVQHjK7u1MWUu1U24yKyNe+eQCciijWy7GOpfGiK6cpusLvPRXCc/z6GhkKoFLEK67xK6EnzkQJOSX20pePMjQmAYvjg2BdbQgcEuROrN5M5uOVdKoIy/w/oVOmnGMfBP9mWMcQ/ONRNjNBwGDf+bf8tz3uT9EtofSJKjsg/44JPqD+pJvVbM8xcpRZsvv55pz3k7WcYvvP7Szg7vJFXFdLRYqNP/WhJZUyo5V2XpZwjslG7LbCxpAk2Cm9UkIl0NVBj2CiAeSEYZjhjlBRo4gx1G4Fd+smIU16VewlrzrESp7YaqigWDWHB5/sdAilAiSaiqAC4QWwYXjWhNRQo4CWRMpaeyBoavesHTSV8Y5osLRkGYLrPE0MnbnVER4xl9DMQUsE14ChRduiv3ubbdsMzP8+kvP37t4+9qn/s7f+p3Pf+3Lz9vFy4eVxT7A1+7+/Qf/IW98bcjHO94R9ku/fN3+xl+/ar/9f9+xk9Nj893Re8LO+24ZvJs23LPbon3IZCHqpAaTj8YLyFIcuzvonmPGXnhrpnhZ57SzEcJxLJn4r241Ji8U3KjVQpVELqOpU0dtg7BRpuCiuSXajfZuU1u8KoSpK0AIhjHF8MZc5lMaXGdqunAzinhVOOwp81xzCEia5Hr6B06QCPnD4pBn+TwEnYUhk2w/bERko29TKyWs9dXuXt7ZuXuneb+naoAFhFq8km2n7p6VD267kYNL4W0gQXLdajx3TbQIY2OH3260QhoDGuukvNMrgBmycrRCtoFtXRSHM8cFbyrGKHEJDBS/V+ZTddEmRB4/tqoMapDPylyRcXYqmEhYTFI8bn45z7AstfDKQZ3xd0LzzgxwNEx9nBJfp/IraXTJoOlesD3L9zPmgxP1Q8sGaRmSiY6prA129Vi/9MXB7P+opI37nTh82oQb7XedTRw6DkXtPF1CemSkrQe2Z/1Iab7R9kKbQF2jqdXA/AS/1TBCnH4UMDgunYdWgXgK0yg0Ha2ykwUpsqJGH+MJeMG69WxBBBsYhVTmzugwqW2Fu9IeWtuNWcEWcjfi6uKx1/zg7onRx5mrjmsxIAjIpKQFY2sV4k5NNSsBGNxBjINTGhDD3NertYJDWh1qfnb2U0rQzX6LYW0EuSy4joZL1Fqc10ehjJ7jI4OreRSKo8uzJGkDZOPWauGQvW908yd1Cmkx0jCXZGEs0tVzoi4p0S7ITBuRc/PWYSE/LrFxz+bVNki7MpQTzAWgpiGteVaO4oa+THj7VgEPXBig29t93z9c2iOPXbu6f2Fn9+6d2KkdTJXrg3vt1u+Rzcgrr5g9/bTZX/i56/Yf/nL+2e07d5/c7d5my5bWUzxtiISNBE34JJA4ArJACl8JRYqcXUZE1KuWE5jm8YqdFarqIHuhqkwkTrI2OWIt0trKiDIDMSbi2FgIYgOCidRgjlbNWGT+mjQpOpJm2xgDmvy79IfoDGYLlxk341y6w2rVcwB5y/snIij7FzEr34WhaNsWB6JkpSnec46UIdQE46PUQvAhjk19cLSO2eFoqgjEAOSbojimI8kOhZMTjwBTgAC2MX4dozuSPi6JYaAibjD8Ai0leSrya0VfKAfFpk7UaCBSEUq92JxXSKAdGIB+mqJJlDY9Pepa04GZ18dnlpV8A+8V9TKGLcvO1qjSrmVbIdrsjUPCWfsrIQX9JDG9xJd61nuugAQEgC3rmCMY5BPldOGC7F2wB7ozzUnX5nqR/g1PoLXiJapV2NQNYVJNlKPrpGNxiBS6KmrVJvwBtgRwGkwCoxArK+GXWta1oUYMwODjSPKW0zkupmrDlYZTZoXv0+p6ulnRMA1FdthkABpkN0/ZZyGD2wk+1nSfk0jpuI0KDwM0kn0JF3ixCo9SGFEDoPppIzj53jbUcp3c00s1LF/JEMesRTUMeL05cdODcg3Y4zT4PRM0NqCWQxzSKWIOvZ1VzUQqnDHjOLvKjbqRjF3KitTCCH2d+kX/Z7RKJtdTuudvi4Mk7GgCYROsdDXarMhyPGtijioK/6yUQSjg7UyFkJPXR9fnzNIa0xgV33X/lK9zvRMe1G3i/qljVMUmm77B8gEN4dZst1v2rl+/+fTtO0f/ePvBhx7qigkP8rVr34PRNNsX24izX/2q2TufMLt8ed9u3jzZ0JGrbbdnS9+z09OVgwvJbaSjkCvVFYOvj3FT9aAlHUiEu3MJZZBYhk8EKRgR05FTHANzaml5XlA34VpF3qumkmofxLT8MfUWdb049DGXIy+N/VQzQbTikIyhTh4oKaYMFevQWLihim09s1wO/0zIyIXPoG/PoyPfqsQymTYzJtK2AgmfiGPKkQv+Af7QC00w2qX12YrWa7JnQTBdmyM4Yig3CQNnVTILllAnMMxRcOTiAK3qNQQNiyAPlObFc8QRtvapbwOibMvyOTvyCDPFCgilJvk2megIyHXSDDqWCcV3FSczJyXXAICLrCbY+3YuLaOng8Nx2OmjOoY55iJmZzcnD8tNgwVfdQg50oOYQMzKChPPrszdSdRtmNHFBkNnty86eVI+JqWq7a0kIYRnpvvetCf0I9nWZm4CWhN6G7hLjgFglsb1CV3P6znprXn8NFjEEynDKTHuT5+gFkZw5kE5q7hRLN356CvRQtUZSkZx7Sxr1P4SgsEbZ4sv7Pp7n6b0BSwHHGMgmMpN3tLzEczOiGrwOm02VcsYopwZmJMoGVBlN8UsslzZowXoYDmdPDl3XdQKQE2MLgnlJKo5fHB6K+40IwR3sWfnCusP3IvumIZObARoVlmKZBRO12rMPkX4FyMIwz69Nz4DBeiGfJoWu5XfIX+VuaGsmppkNjZhiqEcp4M7vYDcDRW/ojGSAkLkI4CMULWYNrfrmzJJyOYJEytWYjIKgU8e44IoXiRSscZhVtimaacqITVkhCD4uPcdBg0OufI2vm+3d9COb937Yy+8cPIrP/WZuPHz/+Y9u379LUhG9t/aKcHj1XLelN25a/bup8x+9Mea7T/1Z+2jn7q7d/vWsV27uAXSEyeuLAyZDO2qAVnvT2UiR6eYQHxWQ+OJJn8NNlpd8LEZbcKzw5aGazrcpEfL+J9Wa0TbJ2mWkRBgTCicBg2dgIHIgGowpklVBrzGfkkgN1d3Uwx252mEVTjxzWGEyFms0wICLyLdr9OCMMoTkzAy7UVdc4Akby3YehyuXN5N85l4mhWD1GRLYDahO5zCwtKSO8uoM2J1qr5+dzqYlwH4mC2ELpDYncNuvWWzaGqZ1Yt1CvSGTLcKLcfR3YZtkecQi0BJjx7fOHBg1TjeHElIhwlio7lzqDoD8Ew4ibVYMOGAYNXxBJWnMSAp5TKSQV0qWi/jNEBZnS5tNAnhJeDOlSyah0zto9CADXE1K5kVzzObmQX+K0VuIZmG2ljKpiZhslMAZSwz+zT3aUpW6LGN0wIYe9E21PR0MDXry4HC6kIvOGlawHZdYn0edCkMJuSXMBggLxexAacz1ei9FcujV/7IAt0g2sBwiIL+sEfH9g1RKk1JYWc7mg+b0bHXZzj4JEiSLOju1dG+pLyNQJz4Tmpp67mJncSkwAWSWiaB7DuV0onch9y8Kf7d4tmydHYZnV5kLRhB5UXJvJZ6NrQlG5ERtmU6+KRqnWt/j2CQ2vszPug8H9D6hIppNEajmiR5/3saFnEqdz4ZkmTYDRwbpJUWAJsEVrO4/2QK+eQRotkJcz5uCUyVvOqs/TqzD2wHOBuB2DuKyyJoK4yDHpcQruq6lmoGly9s483vbMiP57vYq6/d+NHLl++97S/+S3bjnU+EHey/gY79AF673/u9t9aClVn+ycmGjrj90A+4Hew3e9/HHnv86uMvXnz9ej6I5Is4E1zjWAHwBi042g3Lt9r+5aPOeyfnMfVTiumYvwwsFGxLmndZ8zmvyONJxAhXzMQ+zbkLrYM0LY0gv3f2EINWmZ0INmQwpSDhaczRdbLvzqt0l6KAaAqAOiHqXlMQ1Ev2SsC9yHNCedV053mMhqsOObKqypK9lVX8qCgqcOfy5t+jVhBTA0VDvjepF3pT01FlFKLxywdML4oqXuMjZCnpjUlL4z6MujuEoNStwFzePhrhU/qB1HRR4uijzdGXIs0Z746nUG+Mfm/AnURGC3RJ2kZD6KI4enaUnTMPN9Cnw6YIwIVUeSTk9hrjWIleXt3Cyf+kJQCjYuuFUZU0UGO/ugcil5Q9YkdRSliEIb6ZkJvcVPCzSR5lwvpTviODHY3dwRydCgoEAHrBi8YseYKo02eVmYUxDwz+VIgQM434caXFoxBcSKrKlib5ntk133YHDMwKjsnDsKcUnCe6+IdcA6k0Bad3+ECINGAm0mf+q/oRVOZQuhpYOSH1jHiXxaMVRj+nSQpFxtpJ+xr5Thfyy55z5ck8TkMD3oRoMW005jcNPjT0vosxkNFhBErSz6pAYNLeBIn3KsRYjCllrbFjZ54ddizS0QiZJJpBPxUhqq4wrpmOQiMTduPTmkzf0IS9ZoLo0OQCM2jkeKimZZylfIeNGkfHVlPPyAAM+rgaYO6uwFYWOYKFVHy71mlg0hTXhTQNG+Ll4mYD1+8T/qOAg4wr8zXTyVOZUQbKZX/fjvv9J1595e65b3/L7IMfMbt122xT+D7IhGT3K79y7cG9+3d4bd95bwl7/XW3o+PFXvzWo/aNb3zLHr/17PedHu+uHRxcqJLPAIU5E2hmzNyWEjvUS7tIaEg+YTpakUI6II4lIrJBSvJYZqjV5+uYBzHguJruaUTbp3HWKmGMbW0cvo2eCVPjbW52dO0RDbdKcjylFCR0WMDKoGExcrQ0++tvYBWKkeVOqVuIoKEtoHyH97JgYUhAi/o4QSnsSxanhR7RNn23qWhWAV7QBEiYsorJJj2kj7g3Qlg1g0oy5OEaGNR/N0VsLR8OI2t185Wh0icpyuyKJHcIqIrXkXqY3hS/jPyXkDRnIPCMR8baJMvQpUo7Yd5TiJBeqrsCl6mD4uxLmwzxqlMkYqfucdRHeSt6atbqrZzz+DkG/XbPxCIaLr2yaDKWq/Q6s6+xxDAISI8+I3X6iujU05rRVpAnTDErac6tN+dNoMdhYc8mK6k564+qQDKWLNj8/P4uMmkhjhYlW2LgUI+VpCajouOMStVRroe9AUpxDHYrw9Pp1mAwZ67/TV2knG9V4KqkdTICDeyrLABkd+7UZcyJRKW//N4Qdnd1uV2FD9ouxVTFcxhfhmQ82qc1tkiK08uJgtU30mFtORxPmXQfxrYdw/KwsUQ0re3KNdJIYhadjjgTQq4nlZlCtWIuCw6slKNS8bJiCQx6dDJlTJRsVocx+RecWfzKe2N+yHkcICNtHIyHmFMKcYMql99U9Py6fcgEm74duW1C6BIRRfYVAITBA6h9vuQTXnkE2kSnaTAqNI/dsrd9k4Nrjx4ul6+c2M0bZnfvbm7p9kBfuxduv7Wkke2+nJ40e9fb7tv7Hjmyz33+efvms7ftE37r4xbX3r74XvJS1bhj5YMKumMivs5ZABgTctvpGMgw7L131SBOw6Hkx/YmZlGYzopIXGBLHcG9D9NBO7XSUYYHhp+PlBrT1fhzq7JcQxXaA3QCjmOZKLZORn4v/568ccWxguHbqFJMGA8WJe4PmbjcvEZUlbEikBjTA6W8wznAtYormF3rhpNoqiZM8Skc+cUCUq3oIAwBjMNI7eFeljDGymDSqxnHMlsuGENArK51KUmATowBfRD4aNyOeuxEkWpBDRJRB2k1v3ef5sW0Nxb1PMQhx04MtjsPxyrTjW03TNSj0D91dbjkUajLG0nHqgMaZBle2cmWLNcsXun10BhpSs5J5mVtCL1Htgd4guCZtW0aJecmkBc0QLSlfLLn7CDg2ESuDj+VpFFOFXNgyBw/zKkt4IyPyNcq45z72VWVr8ZmW4QI3ZMrRF5UJ2iQrQ7GbNSo0SF6k0cVgCygAR3ccj9zwBJRle83OKZVAghDwGTl4fKez7fItXIDpAcSRkvoFGm+4rxs49nAjA83N+jrMV4tCdHlvRguptZEN6ikjAcxAumYll3xFRW+YVIk9n8HGNBSAtOwunUIIxnozsDbq2VFkRfCsBh2Tn01ri9C+lbyGdDNnGp6Jr8SCaP5kEg4csf6zkRxMraZ3kZPYk7QXO4MWJqsUJCots5OmQMl7FhuoeJFNUbhVtHsdOCsaIC1ICoF6xySWsnUwPUi7YT9pXCM7Jt0Fmgtvz97WJPMjKPBy5oSBCox4J2evISI58RbGUt3Ozla7dqjF9pf+hs/+/jf++9/+3M//vwz9id/1uyVVx8wMrK8xZyR7bu8yNnPkQAAIABJREFU+mqzD//0fftXf+6OnTsw+4VfNPvmc6//0Pvt8uGoYfrKSntiJFcAbYXdkRqi1p+jw2fsL2cp3eiXzMo8RJvisYOjFOJGpcAjHgY9rXni1EoMbQTHDFfjpCM9OO0kk+6LDV9ZcCDBYR7B0xIsXFqITmV7toUY0oxkhiys8qiEu2WacM5YKIESyQ9hlVCSXyEYrHbPDm5nnZXE1dkdclK1uCqt5mcCGb8Kc55Au4BPAhelXMffIBd1xggxSIJjATLqd1HQ89t0gp3lawBVKCzoSafPj2g6w1Tk5fSt1CiXGRlpbwQw6lsG218l+AB3nWP886CkezmvFHN0BLiQWpjLl17v9EogUzSTJqbVGNacXv488KxgrzE/ZUS1rp5/xbNppktjx5xQdoEwjMOcYNaIViUfOak0Y6H2OhSrquxBsLIDg/Km56+3MoLjHBZiNQKfLGB+J2OBoARh4p+AzMPZOGfP52GCRe4jGyWOqhvX27SVWQoHdTVTU9ZV5EtknU+VHY2WC7AxdtHdJRto4H96+bz0gttV/uRvttADVwuCKJHum9l0bxRjBiLB2MR2r+wCuzvdZgY9YWF7u9UXNw3TUBpgEJNnmqSx94zJYlgSy2smW3fHumd0cE0GiEC7h3tI/k646AmZmKsFGsYRvJ1CPfMt5xwHxOa8P6RYiFfGFIpiE/k5oDcJwjvjP57NRJVjvAIbgLRf5NO078sCJPeDAnomQAhqizG/rpNtvDVMRHIdgHclrdmEnOJLNrbHJ55B+eQBbV5XO3fYducvXv3+Z5/f/18e/xmLjVu6ISMPNBl5S3ERJnFLt+e+tTcyrZ/8lNn5A7Obr548uTF5F29r78MJ3YkwNN4wz/G4xGoh2bSYjCnn3im8onmYJMOwq5zbDJeE4IMT4OnVE/p9LTqyVYmSTAKu5Jt09MIjd7RxicvTFSUIJvrD24MC4QDS1hWdCFsu+GZJ99q8KkhXp6SLA3et/NcLjYn6jqxJ2NMJzvrx6Wgl1GLKjPIk5ihOtdAKTeEsFGMsJaziqewYaE1wZiGZC6SILyh+MTyWzMEzhIFmsQDkXEU+lS+rdBqcKSdmmZL/8gnpPJTl1IxnjHJuZQlUqghMBEefndUdn89gbCSOBtkWvQ7YgFf3qDhitCI9U7wxUKWkCN+vNaMP13Qa4N/lbSR0gj0B06rDNCeqMip7h5qS1Et9L7LtlKRzFo+Zohh1KZDQaiNMm51jiVt9RJbdwdGmaavewASkIkFkr7xxi/PoyoOu5dh2TA5CctGmby8r3bJorUZCDolJ6Clv/zaos7Ollv9vmaAt9k7U/IAURH/mhURgMSgllYMAllT1DaJoaW0R7yqZjY74FuO/2aLOuVojRLFgQZRrsEDDXJjKfmLAk8ykeb1AJN7oEVvnVdAryNPJd1HLEfVOcKct+QVkZdr4CV4iwqrI8Gk51rPiyZIKLe76Dv+ecYdQAEhwhqn6k5IWysmu1JOD9UIpZRNHOOBFmsgGxjjAMQCKK+/speIdhBbhS3Cs0ngsVGVpf0fx5in8qrR6lIbB9elQ9zlINGwa1SgqAj9cVkz0scjxO2dam+ylT0NEQ+qzkVXyfEkgLkaLlteOFd4X31tOjsJunb78npPT+xd+70t2+2M/nGNcHuRrx8r8rXh1ECze96kPtyuPfCV+8pM34u//2mK//bmwP/FJ23nbs501Ozk5rdjHXTgKfQVktiGG8M+bV38DCJ3DfHCcYLCsToLHRNxQ0SaqOMJNNTQ0+xoSV+6sqhE4SJXuYpQ+0oI7cAJHQ6YDkzE8eXXiPYc7kMLkVIZ2pSZjEwx7bzBvKdpo0E1ksp3QoORlHtqJ4jyxREjV7uYrhynpNFFW2TXq+FEht5ZoAY8V73QsUyoUhAR6GQJFATxsR8OGLH2RWvYcLMqDY/I5Yv2ZA2Vk6cxyJWV7ovz0mGewFuJK4zqEx1Gxb7+75hRM1Cowky/XGR4FqMpyfYi5zkNPTXsXIAEoJCtu11TQwrrJ03TOLlWTfSxnrcmByo3hJHDEQGbVRILe/NfyX11Gt/WMUlMJUHnoVQbMATPhQa1PSdkoEbw8wkEJbMlKakxTTOtTNiJdHqVkBuqUy+ZlTqvOx95hz52Bnjxz9tNZzTdIy4CWwcMlmCWXbjzouZsdNXKOhCPQqETpRIbdhiAeuHOoJVxsRzzoIHW+TPP9jGa/Q9vihEeLKJJlC5xuFjdKoUTaIm8za658TOxNM5lNwYOSTz5RJvq2KtEE7QyRTBXm8JaJoEYf6or6jlju+TbQ8U14wuRckPFpFevWZf4oQCDLEP4liDXjGTfcZfSLU4Sb90+6jqBZlzgr6F6gqbVdwEobeawxSIN7a9kzjU5lIbZBzo9KN1r113ISiEvQYOJ+qyRZcRVYRcohJxjOMn4E7Tid68OMSwbt+BT9NRS/yk9cuqFGXB8CfUfak8BciqwxJdiJwkliVvwqKYjmSybYGGDhuorsgZgbwTYNaBqt753tdgd2fPfux27cOH77t1+w2xsy8sAJrHunBw/u3d/wYrZ29NyNuH7c4tf+odt/8p8d2p/+q59uH/vJ+8vt6/dsd/WSl9uxTbAxK3I6ksH2zjLJAAgwHIXoCYWA2YHaS74POQzZRmrxbJt6gV0Wi9Ht3NrCtDpvTGeiRJNGnr3RxrppYaLpm8UXZwSLAE+sNJv822m6MKAFLcR7sgqRT2HMxPjKo6LswVGP2XsZadSKQO5geCFdBh9TpLWB5HSMiuAkC5VKyJhWwNUJJhumTGbilRUrsr4Fp4ir7OGeoFlyunGI74mIPZmAwv6Tx2qSK7oRvoSeArO5HF7VAc1e6WZrjMkW7XvZ8KaIdD423OhrZ5rk3FQ6pNSyavU1zQ40gbACd4eZSYOcW/AxRQJZSckzAH+/MaY7HORcmlr2rwC9mlZrVNWGhy4bEZx9BoEyD4s5rYMtHTo99EKq6Utbm5zqCjnKbGtmZKzw0cXoBeysYnoDUCbqnbTEhUluflwbJCsjnzsRkd47gRhmNOJlIQz3Xkh+ulii2ocjDg6nTrVZgMUwTWDN3CG5ScJOc1RYmmSI+6lBPEBk16ykWYgWmo3yvkMf3tTkXJzT77Mc9d6QdWxVp2NzJ6kivMvVP9Cs2UYB9FTG+syS7mnlvw3UdlYoqLlI2YJ5+PaWGzkEjEU0ezC2aqy2zvdFOwoLqmO+p5E22TN+kQEWMDOrzyeJJ1vCyYToVFQ1WgUQvcvnb66Eg/QiRnqN2DLQjbJy8TlSjvgc1M4E9DqRsQziXfruAFQCDDUedvIFg/TVQEyM6otkqceeL8BKDJtKs5bM+dICylQ6OEy9SRkQnzebS1u2hDXfQm5YHdNmkoGziErnYJBshK4Ocg1R78qbM89j27IiLuJrirA7VUmhdnVm740uLYXLblhJW07Onz+398IzNz92bu/mwz//r9nXnnzS/Mtfsdj8wdSzfJNfu0cvv3Vqmu1WrKen9qEPvNNeffVh+4VffM3Mj+zTn3nHY3H40uHNV47FaazFCXoV5xuo/ObhDPdstl9cnYRkTeXR0FghTUT9TX+W7WhMmWwoLMi5ZBFmIBm1qfij8yrDFCeB8ZORbpDliCXKUac1Iw+9eRTlCz1sUgUfu9HhJyxJ1jPPcZOVRdAfyjMPYj8TyLVciBbnnH5VsoM5QVcgNkAMuOa21FMLoeyBPaDNK78HIVbPm+wiBjrdbHGqo2WkfDBtixdI9lfMyk8Mep1slkx3zcl0KRycJRXJW6ajIv+ri/5g6YfbnJaKwsbPfPEmNLmeoPicwwaeBTUHZ9X9asFxGWwJwQU0R6/kLMOm+9fx8EID1CXL0TiU5HGoWU+yQQcgM25qz1kIMYzayAQaZRkPlZbMpAyDZ1om+ega45enSUad1bzJ7RSOtI1s8aGSda5JNqzE1NT7TxxswQmjv4rv7Op1ddWcY7YfkMEBi6Q1jmVyk65UMN+d/FsDT4B1s3dlZ0yc5c+iN8g70oIuvklI7jg1E4BcqJvJKUJMdMcZ1rXXpSPlRgE3bID1SCThUpNuqgGmfYPdGbaROvktYSvvqUEZ+WDHKOlMf9Gj9U0lkeu38646fMHAijUkcWkKlAkGiaLUQAXgCrdyFj5jH5mNyLPxwZFm8wRv0w8QxvbiUiemJAuygN8TmrZjYI0SFU+X5swL81eWpNKS+gKkseVYfT4frm2OgkmrKUCXjZAOwgUQT3LZu1JwlrN58jvsGoJlFBpJIil31+HOUazk8tCIoecO4krKewK1A6ZEcf1yh8LIRHOsFwCBwcdpBK95CID2R8ike8AKI7emwGl2BzI5Cg7TEDcs1t2y7C27k3P7B/t7/+nfPLZ//efXeNdTqap5UK/d/eMXHty7v+G1rt2Ojo7sgx95t9+/+x7/wivf6Hdfe85e+NKrH736fXFt79z57DGEeOwZSOzM4sl6v4FAEgziDQdgJ8MV8ZrSd8ymYZwL+il1VM2LyRaQjU8uuQT3WeBnQeWuBmRm+w0mHF1LhX09ZJxOnH/btB2DUhx2hjF8YYvwMeCGRsQluemtPD0JGjuNgNk/jAJaA3NEHKX7dDywH066nqHZtP1lCr9Gic8hTmKaO/U72VFq8MMcj8LFrm8BqLgm8yH6bL+QARzETdhy+KQXUBzA/mEMxN9PjM9YMhrqvwsKzzNnnC2YKaBfQ+9PJDlKOBa5po5Dd/QfxhNc+PlYeYkn4YiV/T+BMZvZq2TNRfYa1lIZB3WIKzv0DbTmTuKeV6t+hKLEagHhk3Ra+ZfD1zdb2h2UfZ8yyBqL09G0Qvt+5AeQF/eY1m9PnCDzVcL2COEtijEheSlXIn3FkAV6ZhhlMMcmj1H5K6SBEdPkxpHntrXpuzDZoxEL2wu8EZZHYgsvrL2NtmamB+juZP2AHdc41nnQVHpxH1zLN/S2+QzfMA17wzVb6064kNKFTBAQH8ahFNDs5GQRFLGwNKQ5Io5JrS8UOl3m7rw/KZCyqVdNArj8fZvRtJxlmeWwQhHDRYjvpesCEx2MujroEYUjF1QAKVywVjsvFT1U0yoZf5XfzGxi3KbtRqmZQAoFMFwKoW6q/KwOba4Pnwb6iYFfMMXo4kDumB2uwJ7AToWjyNS4QOFIa0uGmSaA0Fd4tlB20DyT1GmqONjcrH1YWPUi+eNmLUiJulZ05OBRPf1uTDvgYRmosQCLplkiB0eVGI6Hp1pIwk4C1oUgGKW0bctWd2vs7PCC27/zSz+1/1/89d+3X/grz9in//i+PchZdrv79+89uHf/Dq+tivu1/+GfxKX3vtd++C9/xL7wX922m6+88qlr7fLbt/HFOcgzp8+kGeHoZuZ6TF9mOoeyEw+eG06gRNa4TQN+hA31ECyoJFMNFjEYLNY1DzI9P1AvGOeIdACnYJFx6he74uR6lzwNjRtOSxV6PxG7x01KuYrNLZNcRMhj4Bxt0tUETxv2MSnygukV6nTmZdgCmYcH5KFNfEnQEhLIoZCONPaG3nHQHA5nWtacrST8Z9ATDTCDAj6tYzn+OP/uNBRoUe1hqARG13LUJRpjuCrLIy6pj70LP9/G1220EYzlxXQXdKiU2xrt4JwQryLlwr8PPX+X8l9j93VYozWY9S/o0hLRqIZKlsygyy55pvbOOzRwi7p7QfJeUR2rQ9yD3cVsnunhS3aLqivXzYKTuWiEoRkxydwE7M6kmfXwJP/WzVZNTLPz/HQx/6Q0MDrrBqVpBjhvHII9gM4NPg1HfmQuEMHZ+DbtTwZyDACbBAjyhiHSSc3M5E0F6uv4eZ6yov95dko60KyuXItAo1itrmMznzRpKKPo754UKTIeZmYhWbOICh0EMoCEW9cAWwopPpnAwhRx99AvVjqnZQ2788Q72F/MQePj4KVcDglDQkCZUlPnNt1BB9oC745WA0RzRbSEbMD2dHK9hFBmP4/dS9hFx6j4RwuwSXKTgHDlhKOFQW63TvfJTlc87TQYRr7idMGjxUNPblT2W5j+msmuOGkbYj0FO3toLMKJEvu18e5h0CAmn7kSN7JOAh4n0SE8Iwwc3EnQTNBUAltGuzOHGoayerLqMoorA4vyOMCuK80UR8MKpuutBj0UA55FeZn6GC2aYrShNx+SUdQstuzt2dvf+9i1j37im/Z//AO3//kfHZrvHlxusPPj+CP82Jv3Wha3Wy8dx+sPvWwPfdHs7ou3/djvftzblZ2vi/XT07C+dm+NkwXyNffhNFGIqAD7FUAlNfA5699k5GNE2Nhknc8E2XQCl5muTKGE7YXGKJPld06f9conaHAo6rVsuaS2ywShYpqGkiGB78JQWFQTwObEN6k/cw8s6bjmOKtLmh5kbbjNoKOFFqLRiQh0CEpImSk12Y/lLINJDk05YjQ9D4kDcTLKe5BtS4IR/FqbhcaAk/KGouArmLxs4MgEAIGri1rQ5U6EKsSEM6UclxoqKDpDF0OrZuYprHgCth7pZbGGUVIBCbH4b+zRcE0U2GJlTQb/p27c9CSaJdUwOI4Ads6uUWmc5Rf4VmbyXAKQI4+OVntitLZq2ap8NROvJ3CPtjVTKg+sabL0aHbNtYAiK4mv1bjf7o8TGsL+6wZ9cXfKsnMRUc0V7BsELVrUbinQGMcUWhBEuuCNC2CbCUj5yGCpZoU89iafDFdM0mB5cFHRIAc0jvIQP80o0Re7C8A5NVyB/MCI3kev318AfnHwrzG7amj3dVRP7GvSJwbxrNvEU0KDITsSmohZrebAMCyFHTOCCkJA2SjzzKl7kv5bUU3AKqF1ft01tJLMyHbP1sJoHptG81RrFIxVg31RYIKSrGaM5qMBYQin0XJyzZRbTiCIngGxMnnX8icxpYppqShI5ClqXHCij7E4wmCFoCyVA0oCd8UVhkq2tUasXuAnT/wPacUo3hyZT95JwkTGg2KiSRfdPghaBCaUA4knfQxhtvP8sLr+KVPjresMRap6IQmkD7YLX+dcYUJBW7xZ113z3d7ent24eftDN27e88MLEY89tqpJ9CBeu+WR8w86/zj76mGHb9/Z3vuv2OvfuGOvPXt3uXf/6Indbt8i9tY++APYQhylzFXIIieYHxTxnOqUgK1mg6PYvNBAoWajbuqOOwj7oeWSVWtLelFnYgqSFnmiZGRnRxtjpnksYqZG16eEInfjQqg9rBMtEZK01+YfdZNEs2N2fUPsMLxJXsxKDpKP/uvYVmUcH7BkHq1/jVULrkBLt/WO/IsVGjZPkPhETgvatpS4uM74UT0saFGvJE9ZRQ0W2glYoe9uCyNO2qKA4hW9HmCeaSGNgRiyiFo4g4LkcvlinzHWVGPPAuPTqfLvvW5m8iOMBA7GQCvGqOdvU+BBaW8yKkbXvrVWMzIY/Og6rVZNiRVGV4yWiIEZTkYHAiWfPLWMFTTjIAqr1IEE1w+/PF1Icj4GB4txyDKVHuJ+Zx4qzxDIukF+6Hh2KHVdKRsQEIzbmTiASjqHjttpv6bAmP30Ds/WDUBaMvbDdwHPPvkWxPrDJjusILiWdFIn6I7+PdDOqiWZKOCUq0wrZOHewDgOSiTJZdyIHDvmJEiFOk+cESXaWAEuvCMnrG3Pb62TlEepbEy1/9noNx2x4KLHmvA7GnIyFZ//ue3YZWAlu8F/rP0djD9g0VYVw1iT8aspMyCbxoOGhmpcgCYTta6CDQCM23dZBjKkIxUN8vPEvmWhMKIvs0Sv+GdeccSNijAoroJ0NOqtEvBI6AUGDZM0j/tRFDZAb8pqWgkFCDglyzTQdmkmi9PAAZHEPHJalO0r00jyVvJRt2fZFtw/2fUZauOejKU+KGbFLp2SYrDwB6Nh4r5RYDNYRpNTcb5aiXe9WqqgNjN3nwwP9uxg/7ytp0cfOzm597ZHrx2+dPHcYnfungxA4UG8duc/9eQDeeM/9MVotyz2wZ94p12683wctPunsTZbWrR1pBqL/AFlQuggMnZMb5xTZuXHzFTE/Cf1r5NoZOi85EwSsKH5DPB/NZsW5VLHvCZZhkwswxYo5LoA3agmeNXN1YJkvWU1jjQ6huVmObX9xBLVaAzqgwKGTwgG4GXnN1wJcXiq2MGPyUjSMXIHlZPkCqYTgW7CBId5+1qIqOJ1n2uhk5dIySOZ6zEdEBRZSu9jBJozB+npMsjvy6pkzDJnV8aUwrHngKMkTyQiWWDlahjLjKeZ69+mPZlup1TxGFOVCiIoyIlh8CGHbi4k2G1G0EwmsIbWbIjtaVCDMQhlK3ESXU7WNKn2xbTYRr2EqTp28IuafES69Ajjp1T4dBocEENMsCLdOzsULpOpSui4ZlvfWZk1svmZCjRsKs5vaRPXZZpTI0NvglYBVCElJePsWguLC8CD0StjUBI+JprhLTuhOnBAHLpuM6HagxmEXDCZqSaOIp6WScDDvGQsLAOBJxiOnIk/01hn+5YqQHMtHU3Va6EEwlshmYgCUTOyOBoQu5XkLhYeDVCJyMPIyBqmJp9xmQkod+kKk6Aak2B0WAD10kzajAaJOPMDuF2jHZgvJpQLnSq1G0KBrKYILLD2COoJ1akIy3wWk/pUpGQWKxzLNPlN+5NoLz4jOC8YHMGYNpDRl9qne6hGOpX9bKd1IjIVv6GBS7ZHg/o22JtjyjLZZwPvcP0+PozTEdFVpwVc1nu0v7LpoIH1fg6nbgRr4INpDIycGEhiKs8XwkpJPtz2V2H2woNymZTp75bo73zpm2v5XrT7t46f2Fk89MGnr7104+6J3bm32vKA3Ml2R9+68UDe+Lu+wuz2vcUOvv0t+5v/wYl/xc4tX3st7NGHt7u8NravU/QUYDkaa5ucNglBeYMVcU+miBiLARJIKTODGQbXaRBfBqEw1SgiIKXQ2zlPja0hBZGkODZ0i+CFKayOhzybez0mvjyvNHva6eRktAEFHLTGOIobCafQz473X2F57SyaAh3OMgrc6BPgTuAkpx9wbhhI0oKjJzsM0Hio5JWzBcruriEadgxeaEwIlLypKZAwfZ5+5XRoVOZT5trACOQu5hTKIIth2z5LuiCHNLDSXYzJ9tk85iPNztEoGluZN9IBoCSbLRTdykMPpCI1fHg8I5HBKDoAJJlBzrRZHBIEUWGEMSpso1cG43ymIAukiwCgMr9YU1jVOw0y2efDxWToz6bGoBrn90VolYoPSZdcczwPLkfqBGkxtQ8cvINrpWmPNgoXdrYyvaa4o3jttTFyaXUWs+TNqsDAT3WQaqktM7WqfEY4AhQn+rvzA4ZtTzNK1VIcmV6CaoVzbpFOp1Q2MZpkvtHh3eZkENEGo3NECUzVAi4QdL6qelMmZon1oyPHO6EzAyRHytThQ8vTu3GGQ95s0GrcZbCOetsZfLJCjrq1QN06Gx7kvECMj/aXEwE0K85ZJ+S29W86e0z00IPPp0ILCiuewKMxQU1MXmaFjOjwW8UhjCyFDHKXlcpQoYJpme4FiDeLCaHCNx53r7swEY12FnPIFFDlN8uPcdpN0fgEGqtQndDQC0oosEPFM80byq3Ysdsqu6v4YIi16ccO8TPyYIz21QZxju9PVx+QyBNBGslPp5IHBGUD1S8yWeQz5PkCSXQvcXGr8Z4bNUTtnyjaLwpKk0HEuttv7aifPHnn7vFD33j92B5++3m7fPngwUl7X/z15x7MO/9zXnduH9v9w317/t/4M4enD9063Nldc7uQGQgkW8ZB1YNigHEZnVJMkii9Ng1/OjdncddqsXY5tqeiRYiVq5s8rtvxALX02JAWQc1oAlBFPkTzQZQtD8G+Brs6aLEkFkMGLLU/kf6iGPo2lCfsfLQuagyyCBDwhucbKzZDjTnuD+ifAd4pl728vmG/Ry8EwtcyS+coHBumDt2wV7oqFEIlrBhDBxOaGbnKKWQDr6sjz2wYpwHapqp5od6yDmnDMDz5+sAghpUMURQVHcCHNE5WrGeSYKMIYDARKAwT+FjQfTmZqK0R5q1sJLi5ISMdqEXaHA4p5qjYSYhwdY9gKIWh7Yg7TlY9ETyOpSB1HiR6JHhZQ41pVS2zz+qvTAxmnovSARIt8uSmbX+4ZFuJA9mDEyuAQfTGChTbYtwYTAwK5eBcf6rx1a1umtcf1BoFmzXQ4WBt985ZC5gqzSynzaBKdj0NJMcg3SMal1zLxZVpwnhYS3BE0VgxHcBNAAPLupzgSJF+mLRw3EqUv/Po8aakoyW1EEOHjLW+KoaGXeZpbYL/jjzlYSyTiUin8Y6gRj2yDczpGFa7eNdPkCRZxHHo6+s4bqb8KvCMtEHB8W/sDYSVXi4kVBJ+ydS5MlSwhxPZx+ZsLMYA1miYU3UZwsozzUhflgmNGhKEOHCDu6SsJoJQAiHZxSQanpGo00JjcoXuTs1x6r2dmSiB3awmqJdEqzn3IeZZi4yOwwmSepoHUAHGxlO4QnJq7HP5dvqYBftgeTfTdn6eMQafE3S1vTG1BXwD0cQ4ODi8LiglmKKw8+sZqx+41+DQ7KVWbizvNvLyqa27PbNzuz27td5++Nbt2+duPn/PlnPLUMQ+qNdufZD02O/2aqudHhzaP/32tbcdtqNzh+dyJ2wUmQUN4hSRCDDH8QZpHjmYeqRAMdhfLfKxo8LjTFk3DecqG3n900kSz8XVvTjq8D5yrldSqVQTlY9GBOAZWfY4gwjO2kn03ReKhFwjRIQhA8R3m5qcizoI5NrzIHcQv7ksPaV7rWgFVOmFiRWfIVPj6VNVx9JnfBpi9+RUHJBBg7IAyT1KK5/6nFRYI8gGeeLGozQW5I44RHPaSUbrsBIqJBA7qosxn4d4PQzqmguFStUsyTzFPEIK4mTfCI/P2ynSPB0/MdUKhICCX7XAMhlueM6oS/LTJx/Mln2glmdm1PBnw7wC1vsWQmhL+8OBSq4hAtOqoDOSi+4hcLqpFVUwDVpdQ9JJ4YBl/w7pS0qKfqY+AAAgAElEQVTh660U6PH2ja0PS+vyosLgqoFtsUHaopY9eUW1wcwk3EZaNt5haZ12/XTNDTh55lW2MNrFdJuAMjbwJBRgakytUJ5/zUlWwLghIEShJhp/ryGh3oZTLZCvQH89vM6w+R3lJs31CMyaMnZCsrU/iQQxDZDTeJB+49Tlt013Y51v6WRAo7Jp00ntdRcIJaNdmPXEJHWdwErYKyELbuaVQor7jW4CqFRb3gceNFADjnyVFrrxCasdEM7BlkauEKnyzF+cWRUkNzmwGGVUB84B9zF9d26XsfcXfJtEUTKhYIolsgWH1YxfXKwWoDPxHTlScdThaKP8LwcfO7aKEcnI3VbKKfZDSYXNjb9kkU1c27XbzTlyUUCPbIA13geeTqRCwScxH1Nm0D4JaNBcyk6bs4tP7hOFkfgOizg4Q+tlu8VO49758+d976V7Yc984yZKvAfz2t07igf25t/pNR7GLvuO7qe22kvvNz+52Nq5TMzQUmu+KcEbRZ8ISg3/G0BhTdW2DCkQnigfUMuQxqDs9o+CaG1oVIwf6th1i6EJT7wRbE2A4TjZOMqqc2SVLHaz2smN3VvPeEKbGXf5BNeCgy+qz7ulU/LhwxNRRROTZXwpWHF0Yd9qGODwDLQmQ02uZZxDLngvgMbnAUMwyrhwQ9YQMBVSRETDlO3YLLTUrs5rb3hrmjjGmNE22u1hHFQ1MEqPJfQFSUXoUCLCTCxWUMYIbWZyw56OUd6ULLt0tHUERdZi+S8rRELOoo/oxzKeaSN+QZg3QBqINMLaEGIstMYokbFzAUC8wtsmQ9p4QG3FcdSIHzvP0O2sY6qTCxfjnXHgaC2mBVqf1r2c9NNuml2QmA+aCvJGhSeJx+j3yOKlZZ7KJBUz4TmZSSaPePPNndQpHme/LzHnJHAMKonV2c6mY4RYMqT35CHc8Cip4xXBqCExBmnR5r1tunfSUI1slYAHZvAwjfSpahQn1SdZLichisKTZ1eH/+B4YJzfz5Yc02/yiueTfniyG9qdjfjOOCs7V3NeT6/1TYBspCGR3mFaMJ2KeMIo9DYS8TR0/3LL6pZ52i4DBgIhGtjUuKRyJpVzAPlR1MMy+6RHX9fgx2QPYYgGEYPMm5GissmW3Y2VzsLIenaIXyvwOdwUohGj6dZNcBzSpgwWcELJrhYS9XUaLsFAwqXSg8ZuJKQPxxti3aAiBeiATZPOyOfPGU4kaE86NlZho18GhTjkk0t2bDVWpDLtM2k0oXPPbH27HUFpJWurRoGvAGUKK4HmEbis1eEtG4F2ipXayLhRBTMcEaLHsjnvn5yE7e2a/aV/+zP7v/bffMn+399/zi5eOvdmpgNnXruLFx7w9Js3vLZE5NYtt6PjsPPW7fTk5Pt2u92VOMlNmukHl4rHwvmQMC4Qf9+TbUQKQd79BtDZ2IDpoDQ0nv0GjkJX7xE5AocMNAVvNhkS26DXIwuUxI2Hlc5AYpXcZusFWzu5KFj3kJqrz2I5wb+z08Lkt1wL1IGdgXCR0Tsu3Hv2hOhrxsCybfGls+hJK2NBmojxomQOHLvDMaMNjpoBLzW4IJYRnXFQKPaHCkTOD5WdqguQya8epHpVfQabE1NfGmEMe97MWPGlo3r+louDNTM2kmDEhB9kPKZyRnMG+heVZY1XHlBYsZnMaxm3elQ8U44LYkoyg0LXn19xBf25oAMKE84ku6j04LLRIErN6+shRu2aSRd8EIZjZc/eYy/Yxov/j3MOdxoYCLwWqHJMKCN/AnlHq2qWOZza8HnjO59OooTJg0ihZjBMtsjn1XUO6ujEOH9p2Q2zqLH7oxJLfieptvPZcXB1I4qopaNvphKOqwRCl7x/DZjaRLgmxwIIiOn5GE2IQ57KGz7eROPMtqo0Q920MKDuQ2OeQxTJIi6zXmRaZzuIbLZwfl7ldOyxlvWLmqUEFkIWXuK0YsxdpWKN99c0rbYGv4ItbkT+gZdN7HHVSNhjnZw5I726AzdrVULhpo7wvCTnj+nU0vHoW8MMCHeJgqE6RjYth3euSjkYdCuz3enExjWybUSNUPWsU7VLuJMrMDdesp5GTtFQRioMidgz2rxBvSVgv/yIrvghTJG/LpDIcJ6RMd9q9nFDMRBNoz2EsbtUEKj6UGbwweU1Nu3ejjZeQwM/MIwhF0yaAy8jTXY7bdZ2O3vqE++9+PD/+rLZ7z5ru90urTIewGv31/7qW2t6duHQ7MbrZv/Rf7yz12+uu6N7tz/RdlfPeT8Y/gAd4yAzQss/VXsnaDEC6SNPFBrS8egZ0wf1xEylVBstRGKioJJgvWoideb4BqMxRmaO6jKnYVYABqRLqxA7L6qHc3BemAxHoVhtw1W1b/YqdSRimBh3SMEUlQHnxJZh6+NLEpyU3oQuEHtIzRfjhhJuaIo2QUhUXfQVBTr9PNQVpzwgiMg21YXC2PLzoTEw+Xw4rhseEwgh4sMw3mNr92Bx0HHTUGPorQxmc2z0G2kSrCisgnhZ9WNWex8nqorhfHg9OLclIQNIk6iO4WktiEDLy8+cDa1BYLP5ptK+Cv2IESydM70A3Nd5GBT8jJImYzBFOvCGIqEVw1oKNy0On6EjnyxXfEHePqv43dRjJkjFKikw4ySPduRZzWTjWhGRobXh+jnMy636SFo6YHqyX5OpPgaLglVCSH0i/Gv6MZ0xsARwjKpTWlCGx5mMD9+40fa6VXWv5A1rY2SE7CW4ljTfOGmzu8qAq0kkmoR0scL/NMqCKHgeIuuoRsgGLkoEI0lvyJ+L21bmE6HPCiRPLSGtnLzXCLywIgCCQ5lTymrk1xM6+MB5KE3xQBhcK4iDlpT9C6IJSWmd3mZ5JxbE6bzHXOcJm6X4QKnBGDPQQMYPWLFOxedK0Comya9UOGhM8UxHTxmYDZ8Rkyw+20ZULQso+YCEsnYyWjgCVdGMM4M716mSeKuKD4cAhGqY5msYkDe+5gI6r0YVgFyu3LhRmgSpvsyAoYHM84PiMspqWHEyGXf1C1xdzFEOq4KMxiK8RT9tbX9/Odyzl6+//sSNl+/Y3rVDO/ehq9aPHwyAsXvve97aNs12A37kR8z+4f94Yp/99b3d0Xr/qVFntIXBGZIZbgUcUIZdGmCJb8zGPIotVuLTU8ZMMRuUV2jIe3LpAZk3ZQ48Cpw4AHuAjHEhPVqEWMg5Eaqp/nSk5mOqQqtuHj1NOhov6qpgNYB0wT1Fvwx6LG7GeMFDkRw5jjFRJaVScsWERi5TaHZUD9CJeOrNim2VTaYCNgn84ZhXNoPgpEyn1AQcfT+a8xNoibs4HIFw0seYPcH7Z2qbju2X+R3sobS7U0hNcIkMjDmb4RVreAMNU5zv3zHwBG8JgnqM0Rg2c/wSU1USmERodhgqy2tBqxTgJUTREePw/ajy59wYemHWUEgkQsEp6ATIq7PQQSLsJCtW/U9ux3CUU3dzO87yjMJNUIo/kXdNPEYWmjg3k2TpVKe01VS4S7xZWBUWTPbzU7aSDJ2GzmEkNNPpkBxw++FkBEOHDYlE741Ebq6NvG9oqXafzP7yRyCIS5+FtKzAcZ1O/6XJV+FAgLSTxZyi3QLNC70Zu2/0ydAew8gDPYu8j50BjEhc1ajN1+yZGM+4esi1y/L32aokSkG/C/pShzCsAcBF1DZ2PpqopJHdBwRYCtoEjwQyOI69xddCyV2EVIePCnEzp9aRCXUD/Yz4cHiJbIbdGtpvOk+rgwoScWDyuiguUdIY70Sw6bBd/hmeJL8IzgxqapYKNAObyOnVhr3ruPJUP+dP5Sbb3DfHtjsVmgLJfuQYOnY7KGJrSEHHYKHBPW74MM9UvSudaySesU5insNDzLX5XTuAG40DfqNsJpjRMbNX6PYqFp1ZsxtH5cAS0fjlgEH6RsDZLQcWd++9J+L4YP99l4/2H79g/d5J4ZZv4mv3pS89uB7QG1/bPTg+DnvsMfdPfqLHZ399m+Ee5xtpAhvufFoHnMlYPfuHOdakVY+j04CAaWOThN+FIVeGbrrlylVJQ+WTlB4NKDnHZI/fXWCYmAmAlMIZFujxQSYYSnNWkVxciGOqstaBn8DwEOsKIy3aTJE3hcdWthXO3KKx+hiUh/pAHRMxcSPJ4vKpii5vC96wKi4mBEVkRZN6CSZbiVo1lyMrmkWR+AOkEQ0PySgOga2yCYqUB9KQu27TZxzmEST9c9hO83l6v8uKRUkHB0zV32/vv4LcsgRtwSFQMfToSIulAEdJVvH7UgfjNAgYeVcRmWn/pYms82HtLKqqA5b3yzR7bKSnmFzsUM2i6mvqngeGqeS5JAuWrdCGcGTksKibLV26sW6r0ALGTov/APF3IQ7JmhnHISp+YCAwFWRbEzPKg1WmrG2J6litWeWy2B8NjDzxjuqQZqpTM58AyND8x2vqJEiPRqJKkTyL0EsEEfFgDeg7WnB9cs2IWMhWByYCx7LQmZP09zxP4H/eUj9NTHCAIVw947EiMgFbwQRiWUskdzA1oSsFHdiaNK7DrUTzFIuG2Je+4+QVO/ASso87ZzLgZO5W8FVZvplxuEbnQ9Hy5arqLmOh4RFjXCBwUEzLAXG20LtkB9ao5uZeS6Kd/IbyG8pvBLvGFaBj3L2UlaF/nycF6WzqwTEiCuEYti9I0lV3ca9m3GNrtE/DI9HngvbPIJ7FnDMj0k7+R+lrDDFxWCGSbipRLm+wE9pwsuE6jIPJKZwRVtKtjVc8Zv7C/8QI9CcbjrJ9gIGNeV6yvhbTcQFgfNuNW8RYrZ+YHd27f+Xc2/Yv/shPPX30zG+8ZC9/7Z7tn9+bqoA357X7u3/nQ2/yW3731/Hxal/76vv9mWe+ErZ80U9Ojvfa0mxdljTG6NndaCxzMlMNGmnkilgm7ZiiIxFZUZ4JcNA6IykmGr04n9ghdSitMrQtyecfD4g7JONcy+NmCDr7cAhO7sOw4OCpviEVI8lOg3H2g6vDbMRzVxMCJNSw0zWA3pkMuiZBCPbrVsB2EWJVzlqhNUFYD7fNg2MBjU3hUKXPUxNqmeH7SGQYSEH0BmMvBxrESowMDXaE4HCi+og1JDKWBrloqOmDclkHE1wzIjlzyWXPifsOp+ZA5IKHEwt0THZNEJlNt5BX8xa6OgXU9E7i1GPHhFmA2gzHHmWnwI5Adqp5KhPhF8WdcD0MZziKpwA4ck6mA4n4EWOWWgJCOvKVGFLiISyAUwCUf+7wjRz5GAi+DXaeQChgaYO2DGXIEkkhmW0crIZJ10nsHjBPy7UihUmzNiHJoEk3o0TUtD5xiRu4mUJqdhw5CgkfxFqb8gXOoKMWHdVmVQeGDhjN93GBSG0WZOgrt3/mbclkcXludx3S+K4BXRlI5synkCJ2Khg0K6+d1ZKYMD2mrU7COK8vz8A2cdBnRolqW+ySkY92dm+5nIxyEfiYdO5/o8kF4MeuxnMkClXJXwI/mG7DT6TetBPG0IrFsw42sLERM0zH4iL+qZU8waHwleGoryqjsjKBnUi0muknoJEkl/GsGn1YceCzYYvQOGY+W5uRQFJjhy1uw67VrDqCdXCta7RIYP0XuZE7LhXzymk2QfTF5bUXAVwcbWikX0hLjI2AFFkxAcX80d6hPyZXjorOSBeHPk6cFQJ+8EeQ2qsjP7WvAip6azR+3tK87mz4ReTA0M1t9d5y+u6TOydX3v61k1fb6Q17/OpLtnew96bnBrv9cw9wJvB3eB0cmj337Ff7l770svlu29JQzWRHcHAsgR5NbufBmQk9+eFQP/SiasH2lEZfrbKFYKZo0uMaSjV3nXNs1KGfzPlCIKdgQK6VfhvKWDlfLrpS6L3LyEksFKsiBAseCnNdgPFrC05RiyKrm9B6hFKLyUVjKVDUONTmGTXJs2dTZfv9Ndv1IMXSOiw4yDRTEI5sN58SQIIlUwM/skGhDUCjEXIMkIVN714yGeMtpQzerB5kQDw1Hsjm89ByEn/mj1123wZtkEsyxa5pVaEZQZeJhw5aGVMLoOJdjZ6tdjaiHtR01FcIdpRxBhJCpe8mpj5nL6YPhjb8oMhr3U6wJoCddSJs2NFvaIR7upwgDZA4becMrZVOk9DgwJWRCrepJ40Ris4jToYoRiJ4g+cxlyBndQCANzI+EvdSawxT6eazgulBIywUSCPAskMiORzOkaCgOUKyohjokJFnzuWsqk3YFDbopngRfoCqt6WZU3diI8wgHHeG0xNrf0r96cHjG0mHbj/p2jwVDZM9IZdxziMAQkiXOZKCuOMb+o5s23TRJo254gQlcaUAWCADOkCewvrrCRfFAqlM+saseKJNVXalby74Ahgyvm5jgitQgj+eSSfWPugdeXkL+PLAPzLsdvnGwOdJB/7ca5sG0/YJ9iGCgcm9pTUaGVoP1k09qHSuZKfXzWXWWAo0Y6FnvL+hoZpGKRjd+tPurbob6TNQCRRxKSo3K+KwFRW1fEZoVMqhLRSdJn4TokE+YSkp4YfbICakqbfib1GA0F0I1uCuLAsnYMD8iCg8mQpjL9jebm+5Y/fe99rLt68987999g/+rX/vnl17pNutW1M99Ca9dp/4ibfO9Gy7Q+vq9sd/4o79t//dBTv80J/bf/IDd3b3Xj+xc+eMKwGtOhTrPMwZ+rl0qk6q+WlG4JHYSLDIETpcfL4J6mLgCvK2zciti8za2R2W0yTO2YoVfAc8UQMBXBUbcIjA9NfcwZM8II9eoC1mXB+1sjohYdBHAPX1MbeWcRtjQYKFCCBZeAJINzQRKXTgMLXQNjLhS/RWafM9Q+0SkE3IaymY8wA/SQUPRLHD9cwJmeZhD/S+sSKaaIqsD8nSbMllaBiwDjfxUICaGpnk2JWSUM0mjs8fNcdKLYsMbIjnGyF+7vByrmT3OG16kRGGDjG1DXQ145huGhHCvi4PFdkYuHHod0erW8BgBt8UPBVmFJShAkFvgOqVDwXPsQZyKepSnxoR8tZwsrjVy4BNZhM/U7iigO8Aj0/4g56A8mivAW9Gd2rDzNhiABNCy04iehF9pcAlU3eRiIEa9Oq8TJFWpO0OMIHO7jy+rYA/r/3biCrkZZfYZJpbeGYJMBOVl6fXpzNP4QkfkNaJMKrRBA4zDLSJiN9w5j/jG+cC1wHWQLBQdmj6MpwVk4egOBI17ybq+Rq7kq7vDjIoWWlvaBYD51nJyJue4OhKISHNfgkFM1EThroozE4MAVavbEmZq68ccmwJmTzlgwdJXaC4+lR81KPX+/8R9y4xu23ZedYYc317n3uVy1W2Y8eODUnFoRHFJlgKSoAWHSIQimjQQIAUCTq0aLmJUBAIAhI0gCBA6SEiJESEIE4UgbgosoLlNBIICY4TfCvX3VXH57LPv+ZAa473eefaReFywj6nPiRcOfv/v//71pprzjHe8V6sPXGdHPtMgW0x9l7I0shCvDjgMGaaA3vnKfffbgsZVzwNBDVlGfYL3x8RDtBMjVE+mu4lJ+aHrFPXkCFZDlVHKs1iqjRfv3Qqa2gAqJQR/8Z82CrkBOk3b2JOPaIez5/F177yzd/xfd///jv/6r/wm/H9PxDx61+iOP4OB/7f5evxl//Kp1/tO/4Wr8u9bZ4Rn/sHfn8e3/PN+oP/yGfffPN7z8dHv1na6zdlz9MMB2gOCJRR9JCN8C/dyewJfY/s2ImOkv58u+y5kfFDJ9se1dCDhzB6LcvkA5I2z0RofOdB6kRm6p2HWjfMcJ01NrAZuybZArI7oevGDg3vetX0PQtOe8hrK6O8HSI6vojTTYGI1nYwsTAHI5p8NXlQnIOhEbn9mELTWNTKBpEs01cVc+jzFYP3IcvPztThpByis7k/Kpt/SqxBYq6KrlI+bn/xISbJygJucGiHPVAaBDQfSVS0AwUUsoi9qfqIbvRl2Jhq9rDZPbL6C6ECODUDHMFj0bcTOIG3VEc3Z5/L4rHQWpkujPsLU8SFH/bMC2bf2FQjDvZ+cGYMhYIMiDhzXX9M/BiY6ICBtnQiiKf1yWNpvlCf6KAMAfMHID5SQTfYTEK3lfFs7k9OTUQHz0tDKu3LTt5NeYcE6ZhCQjzDB5XqVaiOYrOJ/f8Xwt9Pj39nH95KMnLfwwCCEgK28Rzb8zn6/pVqlqnZfz9Tgy/fj7maCQW0qBjAZG1DVCQTD3iczR4TeJnh5MLaxWTLce5Z2fLPv77NMXHWYQOJPaJgoYYZevsTq4mW2lpTxsWjd2URpA6rZoAiA1bjCUhSWzeztL/IInJeEAro0Ob8fCvjbeULmpW+uqvyhGxr3dZXOnpqyXPY+5pL7p2FXFvjtkc5qrfhGbGRo0O6HBQWf17jXjOboaFuhkoHDBKylJwz4dEnlbTwZTUSc45JeJeiJFIeamuyWgV3rryLIUOolgO70MH2mbGox9YuonYJxwlVwI3VB8dVPT579og33zhf+9Vfm6//n38z4n/+hc/Gz/4fn4533np6xdVBxON3/+gnJ+29MK6np4of+9TfrJ//6Hl848vvfvaNz83neTzTublmt2N6lxe+y9ZJk7spqVM7bBhyH/zIDhkP7MW07OcBhBVOPUxC8CEkHSi6LMVi2CpAQnhoVxiymlSrvhuVOFR8bIcdA5uCOyYcFeXFDeb1WIUqtIISaW1ajAemVq6BiBQbVbx7pboTYU9+SB/ulkFMa4FNaL3NbTTcEj8Dm0FNqDVxENuLnnXwiFjcFoBGu7QPuSXQ2dBmEFYhx5YCbtw+hkaWDIprjjSxcQY7cK8sO5qlhuCT3wg6lHM4ce3uk3RQW/mn3/lb6KfmorOh1fBy7CHDsZT822ButU3Uv2X+u7p5zTPCWFXGqYUo2BBF0Akahm8k1/NW3V5b2apOWFQJwEjn6yoPEGYfWOVbhxZFLsj3seFN3N3ogNzubDAL/VJrTCSogqa+2sMtVW4SyZqbTUYwLHFnEkB/pndsoUcqzEZHFekedsrRhSWCoAxrQJlNEQVX2WSOA35TU1v67ow0exqQNNmOtESsvqZKzf3vmbuRh1qamtZAQMDLwBnMQ7M49hQvEA8lmlQtyvPUsmR8uuEcU6LVLsXmZbgot7vBRd/ZWsClhZoakXlrEAG/3IoBR7dHS1JCAnQ5KrTRmqn1dNn5twnODQxfJOflY3boRmOL2vYZ8mJw4O6uP6DMSpZoWw1rwdhFevREWjaXbWIKeYv19gCFGUqPtb2BBIqyMdifO+5g3zmlPspUPjExwNywp3LjVk+s3/fUSVX09Lcpqmwq4atzOZvPoo5gxiZhJkfV3sam5FHSPcZ4eowYb7xZ8Rtfei//tT/1mfjUT/yu+PCDEc9fl0LzFb4ef/UTVNM8PbUT4Y/+4Z+M35y/HOPFe793xOPNeVnSX1WhCJ/KnxqI1Z9gWroGvSONffBZn80RpI0+0GhMb2VBpGs1OhbhrU7KG0z5yuoR+mcT1oT02sxAnoOMYPt/4oG1Y+DU9Uu8NhUQEz6IQFPdBYg4tmfxOGj5/AT8TneFuSXvzV4kwiGBAamLdxSNrpNq5imiXrUrG6ajR7uktckWn8YeTTcCyfTxNW8ZVvfWS/OqZbC2R5xAQUUQcl+1W9T+6vqWS2ojDW3qieEjPqBDvzLTwt/pVUIP3IYMo6cvku/zJBfy02t5ndrhdHg7W/EG5dTq+k0/68tiy+ZMgiA2cL/c5UZ2HP+aj6+dWd45atdMcOOcT9GZ1HwP8Y0EFQlPtId6Yr41FqnNdWBKaoGBtFEphsl19+1jcpWMD4IVrgHS+jZTxjjqBcKF8XV3z75wx02Asgbwjs3oo4T1W0oAa8J5M8OVvNhP2DSo0kcSRFRO/a1ZVxfuoUyXooe4tiU7epIszSQNKucNmN8CkzkYQHxy35tdM7nxjWJ4sGdifZih201mU5QLHlebkKudYHs8VtzKcwk6PU8RdmrvJa8oCg3OUczvTCZ2m7e/qA3Xaw3YxI0EnvDk18MZ71LIo4xjUQcDGlL5eH7pH/ZH6TGwxwqCevf6CzrW2Z5ybuDgkWkakT0olmeJPKauZTuQ4ZSOBc0h55ZczyGuS3g6GRZiIrHxCAnGWIt3aU5Vt/ZqIwONoOUQ8587pLTEeVuKTHaAJoWeWWStnxsoHIXoW3VMkxSmsAqUBCbpPKjh2eqUgP3KKhkj3not64P3H/GP/nM/Hr/yl/5OfO0Xvx6Pt15tlMzjb//ya6/0DX+r13w613f/2b/2g/GNb345Y7z3+8bxqXfGOVCQERsSTA560xYOnnRR1PkuGkXPsQxFN9Eq2vW/JsW5uCl1g9YaCxOCsuH7rbTaI+ouGiR2F+4osuKq9W2wJ7OqPiVq+jBYlppqSUvkU5EObNKweaxboRFskQEnhZ0mYzcDK4fUzU2vyMv8Y7pNj9tvttlZMxO7dZz7L43t+pRj11giyr/UPHu8BKLQkAJtlwy4IpjE+qDimaKSkXU8YxZtnY6wyrxtmBvqtBSUTp6fYmcLK/2juPI1jl3chuAuZJeErHSnMjdk0CqvNdzb23Zv0D1L0nM/YLDBY80w49Xbv3JXVUJh3nAROul8NLGqStCPC17JpgGVZHo3H0ullg7l2fd/J7VV4FNR0FI8MBML5s5t+0mEY0NqrZYSyyebSHqRIo2rJ5e6S7FGohoamOJdZUNcy63D5e/YMCEuN32yrPHQvsKd4RvbThtyJSxCHN5AuW6WwcPnbUbbhPdw3VVKJCtOkWQbWr1XZB4g8NwZ9tMzOcljzxu4wP9w98CHFKpvbpLPhl2QAhGW/6nogkZC7cRkY6Nhp2wI1rS6EYg5wTy3Up5vFAha9F3uNPh778wz4EDsb1PCtFli2fk1L6eO2Q5EJMlO5QT1ab6B685NVwzR7S1vd3OFhiBtAxQLjXMMrzJquM0uGeksYzXh3ERd7C9QFMllt0FuHsvKhRBnBzFfdv4IbQFeLuHdyE8JCLJ9nBkBpqcr+nlssihnSs3TAf0xN/kAACAASURBVK0ASZSelIQfGPu5JLdtL7OigKYGR3KHEuzCZz788KN47fXX45/6l/+xN//H/+yvxo/8wpfia3/nN/LX//qX63j7+f+veuBbX4/v++xHr/QNf6vXdd0uf7Kv/uzPxPvvvRjztc9+Zjx7PLtiaGacS9wx5zxGvixXWFuNSJLB1JcyFP7A2jNEYw/LPIVDJcmHsxcy82KCX7xNyR5n2mvC3OJeLNNhXbultG/VgSk1HhwJT+qGs5rDDeVOAxOVPS30puTROGl0E99IuAbTdCCV6o8hVndm7xYx6AhauQTT7KtNG9ybbOIy6/nx2MVQHtcBst7gVFsXGI7lfgMNk2WgPZnzS7ZBIcAdmB2wqUpDrWu2rMxkAaT+3i/KbZK+hitKeAZslDfegF0QJZ/U9dPP1TjkSZ7NzOND3gjGax0+CakZajsMMrGjS1YLoI4IsrwbzdxbWXONINh3MkBZTLGbPE8OVkWX8ghgqYVWzmKkjG3Px8GURRxxeKbG/YXqPXwpa18zvjssRVp49NVTSknO1CIeMLuDEHeQSfcSuV/v+Uiv3QBJuVQYNS49HWby+tJNpkMjAXY+2yzU5wjrEAdY2bDod3pbGNAJe9O9/mBhNl4Dt7kdKBDiePSLMRPF/84NKDSho+QWHPeHjCZd1t2c3PBODWaKcqVx0NyMEtdj5ttT8AU8X/Fuivwzl903MExyjf3Isjb5M8N5gs4v6H/EjvzW328UKLVvVhI8a4elLRnqg3miI3LB+HKzBdsogJb2WKsYZyhcMGXeIoFDz8mGGrGjsejlUCS0cV57UVDUldollZ5WSOyiz+d1qpjvb479seu066k7YI5RFvjBa1XgwvyHKDEUJgpZYmEwh79BisH+c4SmqwH5WM9w2DWNylydBhIA1Vhn+Bn1YoArpN75siihJ20UswVaH374FC8+POPv/4d+1/i5v/ir8d/8Bz8bx/XgZMb733y1tcPjp/+VL7zSN/xOr0tN88OfO+Pf+0+eP/u1L9aP/tixFGhR8zwm62PXu41ZEUAgb+xemE0bHRvEvNMEYuvg6jbaW7779NMF/77X4AWZb9Muba4IDkwLtB33CERf/efMVdgAiIReojCmQibcWDHBWb8yK70ppTq9DiUBUt3EIs78RiV9OinXI7RoVeAs+cqw1qL3q3k76THOlpwjh/nrCkzbsdlkalTdrpqaDp3GmZDwG2Q5oFMSBDhzd6nrM5+6CahPLV5dLZKoVbkZ+yqubop5/XR6OG/GZCnGLbEc4Xvd89MmFNDY22I32VjneySwLcazZOVq+v9QHrAJygKamnY2vcPdKlRoGjYZpdejba0iAoHe1PZFyAoWCD0Yd+hO6wPoUqF72d3fS0yRtsw69iSpse2B8f5SGuCxE6EiIFX53k5KlxY8u24+Ayb3QkQWxzA3dXCLpSkTp48iz7URpup456nblnLTCbhy82M5bbGnfq0HHeo8R2lpeQqvR1RkwxR/S4zpfmxmOOV3m5HIhG3SYLQn43rmId/rGQKvHwxQcg9QrhPbGX8aU9k7R98a5W5UPtpgpk5vP1OA8eFxTaE95EqBzNRtp2BAjWsQG5VOt52LL48KjQrg2Xdthng6kqGGjmsNOm6T4FutwRi5t3+PzHiqwo9YbNUzKz9yq2WFJ+dY804P0mxOtqoCVfUpKC3si4QPIF0uj8/iyvDcJIqmPLaWDxsgboFaCVtVyYaH0EtKCO+/DYnuf+kKJkSeVaN98w1gOw72BQAX3BYEpHpn3w2nJkQu4D1obSUkyJFu+bUdPJ7Fh+++F/l9Z/7kT/+R+DP/1oxn35jx2tvP3Ki9qtfjR35ovtp3/A6vt9+K+MIXIv7vXzqe/c7x/u9M61QvWvgsomKn9rW++KpyWT4JiouH3goIZY/SOeJTsycKs9ittRBWhNfciphAunHLhAhX0r2zLkY91Y0sqL4lL4K1fLXYh5Vmu9omo5FhjmuQbisGYn65EDGYGvbiyalZq7YODbZ1anWtPxwOoWmJd+NAvQBmHzTqd9fyQ/PclukVtJud+bUOwMVfazxm4+FgSAJFlVyYAx2LTFj5SDe6fyj6rzIf1/PIUZUuLvrHbraQHg6nnQmhHd62K5pL9DRxA8xXh7wDPMUzk5cFSLriL9qZDexD2I66xvaph30y0v7zan9dJLATTNEIyS3i4nPgToxEN2XWe/J6Rkia82Z6m4B1xz5VQmZTDRfXZm2gE5RWZcDKQxJFaHf/qsM7PHGI9D2piwB4DjgO47YnYkyHaFoowIhtJTNh35U63OvdzmbyNJW/U9aA37g+zBkUolp5q4l0yJakeUtNh6iy5NYpZlmo8NIUUIfoUKkhybGO3cU36ELB5MVeqmeJTqvVpV9aCQZd4g4A1bJjxi4+bvWvBlXc42b6gN25Ea9gaLxqoLHeObHd44FI11RHKUBhT1Oo0ET+aEtYSG9J5NvmRsB62XB/eetKochGuBbFrHchJkZp1nMk227t/bmJmr0UgupoxY8yt1CIuRbBEuvOm6We9stEALwq5xH1dO2/5AroinQROuUc1de7W5gBuSQxo1cjOzuiDDthl7eFAkBo55BaD7DGQ1htM3WbKjZ/zf2HdFI9DA61h013E3qbt9pwaoA491LwKWKSkYwvcxcegOk1JQM8GeO019UloZcR+FgYydOs+Zj12uvP47U3H/HBV957/X/7L/5G/OO/9wvxR/7QjG+8Sxfy6l6PP/HvfHKckev1xhsRf+Ovz/jiV2K8886Hb/djfpxnk/AeTQTn+dtijLZjgDNUiggXU9nSz958xwrtPrUc9IAdqWTq7KP6ArRHDQMhm7yWzdGsOza8uYptey17hxUav96qlLO6/DAvM9mUO0J1VG0NbwL9dkrR81DcTwuHy1kXdNYn8vqYID3XFGt9laWcnSNfkoG20Lk2cRJcNtH/ZcMV7q/jxq1biqJcERJU2qMQvaoDbyPlRb6tNMsq5Ss9NO4pE9ZW+zoKDv+6yOfO4++/ez+Q5Yg5sodTwUBotnhvLYyOr50rFbtasBpz4oV/9CEyKEJ5mFVzXXYufQ5212gM26jM5Bhcg78LUOuOUF9uXo/uODRhaojIhJq2MmvH4FtKnFdyj6XlKc0hY1p+15Rn6yEKajtcm1QXNXtYps5r/w1qp+bcDnVxk0PNpjdtEVGjjjvdRZgxsS6AwpCYprNAl2wBN08mkMFgf3FPl2xpOhgvRnh9lD5UvuSdbJ6P6FuT44q5UFy+ACJ4zyWrbWPDTphWqWDsjseI795UlWQh9hhEg3WrJDwenbrScqMdlqIPiUCEmgqAAxrF16XnQmNM8ag3Y0k3iCfsVhXrybjnLPCYIp2OcT26GcdUurTXjodHckhYgXPKFO8rMzRQ6zhuItiwJ4bXGMeqAy9Dz/59b0n6nn0rpyiWmOXNmxYfJb6qadskQKxYNMk6dfDaVmek84EEjeQtJgfPkh6tjzxlVzQK4uuxAIU1atKPjk3ZoUa/ZVZ0obQVl120tIJzeSlu2XYIg1XIXa/vk0BImfcdq+aUH9N6Poan5tGEFnH496rEMmpiJ6KwjkeD0jbe8/0XCTnVtRBN4mrdQy61q2UpvV9H7081piwch9WJRnfWvHhxGtZOcBxH/MbXnj79hb/41+Kn/42vxT/4kxFf/tLLNKFX8Xr8pf/1eLXv+J1eHVIcn/nBM5+qnuexnEKOm7fcmZ1+hIVlYeRlIDWYXMzYs+FNT2uaNCesWIE6NTUZrhIrkOQi9ruknWyn5f7DM10WSUdV2MdrJ1ACfliOOSQ4mUTMhCfxg2EkEAcHMnSx5mEv3EGMrm/pTjC7bD/NMkeiAeI8iH8S6xHsYMvHZd1Wp7rwkU7aAUQYoXnqjI1Clr1TlpJ+Co5mV5UuofH2NqFOGYGe7Lq5P48xIdtl9vayOALZ3P2rNenxQdf6ifQCV1JsUW7Km9SuNjuI24M84jhkg72myHUmGm8Nx8VLgrFxnRozLloTsxTVc2px2jYldbp39Tbt667cCTgqo5V9sz/fdU2O6QmXT2XtsG1+1d4kKgeHwPGz0xV1gNc0WYfDfqFJ9ne8ix1a9TpX+543lgEonfAcJN4LVJzGoOIxxPFOvA9Yja14U0S5UGqzJdo71iMctRpSUdgZJJmrowaS4/VUkiqNhF6wuShGJQqdAJxdgGkdZgv0OodOTCbOQ8iaxZQPRHJ2z1pAQoNwYrmE3pxqcanBTB+QLZg7ljf78so/Rb8YyktIrJwX4Xcq0Yb07j7lxcSP2HIZDxc9NdbrBIoRpmLljL5/GZWZQPVzabzWNr2eb20aO1+Fnim3KVinEOLtV/qUssroX5sM3TT/Vh5Zw8zWEDJVgYUneFZ5P3FTnlQ76RcZF+w1JR/nSsIRjWXRrEKFY36lybyu/5BZ2FqL0tH2tNUD2vY5VmTpqtzGS6EDm9zDZ4JiB1jEyL+WS8xV901Na2JDzOpEA2qknyVBtTHjKaihJQDPVtJ0Mzpv65ABdDfECjKSNnLOw8DZgAZ3ud/XmU9PL1bP/+bb4/u/Md+M//5/+lr8wOcjfvXXXn1p8PjM973iwc9v4/Xi/YgXHzzFPIko0yjw6phrDU+MNDbJdN2wKQLC6GZ03LCMIixWSOkYcDqcRzHJZ+2hIbbW8qZOoltYXYs16vm8hihtC7+a6vUf1+0KC7fX1i7z9QrUJ2LUniujrVrPmTyAcgyz0UWJvjD4B3ecvWdO1cUd0ZHNVB36gBOVj4P149a41hSIO8rgoePdgJGnzBoozQqZXOzDTz3r0vt33yhLcP1+MqtSJdJbl2qC2+ze8fbQiZV6YR2H6KgbYrxyfoRtpGy0p6cXi/Jzitcox3WlsZj6L2X8ArR2SZaneuVjAnGaeY4cOmnLmjdw9Pl0BMMEjYGnMlfVijzICe+i+ijtDwP3gC65Jw1oZw622ErD7t5laAur4ez20tgORaXjq+vP7EfmNnzr8dpszCZb33A1THCmkk2rO7ap/jzg9SDSabtqezzKSIQbXnuyNEwvplpQUhBTJ2k2PYkSeWFKPj+2BFhnSEHQCa2mhPmiuQQFeAw4Qs11XQzGHpWPKwh4/S7Xp9vXZq134Gt/5ItA1iwVPHbCSUdtBMQ18/fMSXG0QwbHrb4zgSP7MLh+4viWCDz8jtfwKrEJ1o46rdqVl8r+67v1WLuPZDHqMTrraOr56lpsFJ6jBSB3XJFfy01nnAl9wLxIMb2VMZU7BLSHlOvRKmhAcwwDnvp+bcOs3v7McVP2afjWZUFHRY9BNQMPT0/5mX3vcplFReOPWTBonacwthUx9Vmqda0+UvbMMPqGtYn9nM7pUC5Vd3R62Brx0NlR2vhBH5ctRdN+Bkk3Ey5at1jqnlNUmDbrXPEWEwP+/lbm1tpVWdVxb8rC2Y8dstVXsoVuuQyFYt9dN8KnSvmj66WDmW+/xbFcDK7LBgV4Xmn6z58/v3wHvu+NN8/4T/90xJ/9c494evWeZ/H46INXP/v5Tq+P3s94/s7jugfPqk1ZPipGLldZiv3HrOVD0fNqZGyGN3v0N+TbMVVHVpFH62e/icfyXZjQ0mBx5nZTZv8by+KqhiCw0HnWd3ciiJJ4MgnvsuC+unnRlGUgCt8ZlAMctR0j0ryHxlZmRxf1aCD1+EGQbbvoaunkzlHYJiInlAAqeQa8i5mK+jl0FOC+ZWAG2tZ0YsNgPNvB/iUX/ESPkUws10M723KCPljA9u1GqKg5PYMwTN69yLgeldbfNSEDjNHx9nVLkcLUAwAKCX+LUmQ22udESB9L/VpH27yMpl+sXqNp0UdaX4zkRKT67EwftUyzCzt+yo3/9c8ntJ5kGJ0IpGfzAZetEwSBEBwmeuBsZGPYj04Nqdb3uLncq326lnGH/lmxkTLmGRA1cInrk1p+mYdRqhBJx7TtHYXU4xG8PlNzympKalAx7fqlz/Up3bEHCdtNMhuYWvQcmIPtt7Rgi3a7YsI4/HHp8zecs/k0mD11ypgUBFPntueB8A5nwAQ0L1QGN02YnzWPUz7ae5in2nHIbXGMNtkXw60fMbQqRPVowNgXr88kbP2llavJKASHxJ4naI8L6QVxPK4hZ4sz8OsMQIue3KpscQCaAb1dYEzNEWAmGDRY63/tAC1a6fV9S5HuRpwUJI0WwWmkxrhFatkKBP7ILCE+ymYhAhfyYOpENrWDLB0krz1Dnb0/C4wd6SwgIKle/ddQaEYrANuJQfsnHni6PlnCZNMaQEidOvCZhoq44vuD7HL3jk05vFb4DjKCHMn5NPtP9uyrJXX2f0FeuUs1nLIxzazU9yfzyBqFVU8cqz26U+30sPf+I8Z+dzRa4WKQVIezXh/wvMRhj3yMZ4/H470XH/7Qa8+f3oyI9774hY+nZni8+cYnZ3oWMj579uZr8cf++B9+9mOfz/Huu+/Hs/FWKuupbhTD7U5YLxF/a6puNSip+mRkHaVXP0Oj1TanzMVGbdlJQAjaf87DAhNTsT+OYVG+rFHXj07khLsPCNqz3k6wtfGDcj2AJ+NbpUv10aBqaqy1FJ4JF1CdFqRGifQTYDLXpzr6Kk04qpvfyBovuKu3vfw+mymkA46kSbLzC6fK2bsHHn5RRpaEg0/djEa8jJAWB0qX8seOtNrj05DUJT2n7WPKoplBSIa0VVD7pEpuFExnsPyYHO/XVVW0y0DBVeeOEcvBwmhZwjBrlye1sbn2rduzMwi8m4QySrlaHGgLsll0nNWxJpgbGMm2AVhMfY30oNlYpD0YfFXs+dJtwkcmVgZ18c22J8yl75NS6iP+K99/NJ91nDitSHUDyAP8nDdWv4r11OS9bqg8YmzD4aUIpfQsBq+u3qwHETra/zG5ZoVMHOqwgAdH7cdCGYsWSKUhchm2LrLXVqn53NRYoQOQlTaQPOPrJq1WVPwRZYvjX1GEjmF1x7mqs3w3LFA+VV3Mcr/UbIlK1RtNPdactiRX1XO369S9fWEFthxhdFgF/rPGKdaeMZLy4xg0BNi8eT1PuxVKutXEj8wJ+CTBjPaLxCcmy+6inhEpuaqzUpgacVLyJOwlmgR+bAFdqTMYa3pE/KP5rRD0dCQoU1JDQTFUVX80SmPfmtq1Kll5RY5F8FyhWb/uBk/Uwb4Je4bhpPgfo0vecaZyBKWN0wDL6re2UO4h8cJF9v7U+hbBs/B7au+bRj7WlTsW2TA1uKGpAMlTL6y6cNeLhVLAEsLZmeyjUz7GiKd68X2/9EvnG3/wJ+K9f/Kffoov/PrHwBn5nu/5ZIuRFy+e4hHP4h/+qR+JD773S+dX3p3x/LU8Zg//CeR0Za1gggYLEMB5WzrV4/Z/OaknBCNuNkMAopsgOuX+3nVvEXFNJOj2rtA2XHZLu3GokaxcYEYnm7XHhW5S6ss0u5XkfTrFuidQTlGcJH1ljq6MVcBi1i9lQ/fQ0h8lYBI7lGXjDc+aHxVbMbdHQ2DNF6cRwLB1BE0QEf3EwiAqjFNz0NjjzURhpH0mBKbkNK1H299gDjwmVXyiuL4KS6UVoR1WAXVz8yk2SVMKCpSLbPU2Gai8PbvFoPpQYzDbB5sZgfgAw4FzPVIfiKakvtlIT3utel2k2sqr6Fwro78I41j7kBbHkO6vElIG53fRJ658wZTxKF1OsPGqgLz0nevuHGsOzU7fRfNssue0CmUnMqHblalabWHCzYtu6pMY+6j7YbIM6Xt7j8uvbQ1fbykmrW/NRaNUIb8YQfbSS/h711c85Dwc+nJVEKKLp0uUYVgpK9Ojocp29+pTa9qrRZbA6d5Agz1YF2orwlluq/47oehic6rDsRlBq6315UjgNiwx++81GLDcpa39wwPD7rXyl15rDhHb6eFlD9cQIc8dQT5MKG7le04Z1R9TBR/NdUryVszDwzMWjdmm+n0ZzzlkEmXWVF3fLiLTt0bE+OsJyuuJxRq+n/3pbmf2Q7Beh6rk4oFv9h/btdIgpIBUoS7C32zumTb9HoEsao2s6M18sxoa1o8nKX1Heoif9qecyefrzVU7S5PVEjau0XnDf/RVa+s4996ovUpDD22Ns0yc0kcUk66EOPf1HPau4xTshdQKI41FSzzuZSI9eaq7lSk6pwD6WktDfhGYC7kYgSksM5MJZHXMMZ+uaukpRnzxi/X8859/Ov7tfzPi7c9U/PKvRDxerQFrPF7UJ2d6dr0+mmc8RcUvv/+F+cbTB/MR7wT665fpA6IpdC2iBPwReI6osJ9abnrQYCBgb9viul1dUKQPhUu6a8PBd/2vU3vE4amg1ZLIW3AHsiFxglukSglt32qiBhW6xIFuxMFTaZQNJ0ylIfVYYgHwW+5u65UISBp7MmMXaMhm5Sa0/Q7G9RCUIrDbbA/Jhtbp8PC1J+kDGBmtagc+NkkfFawhfW127raHfb0EiIo8cEyhF+Gvlp2mIbFUxs2Yl+Oa8Q98hEUF1Q8PGvvyZGNnaSAthd2Y4+m6ycTeQv1neo+6tjEEdT/C9E/4b01Q0CHAPtXHH716b+k7tkRl0WQiHXidWxQjyEsT32ufOwapFTi/LyBxhro3MJpmT59TDALK9tSko5NWUBtvZpv6Lq5UCLfXsTM6BqcArI0AssYVZ6GnMU1vSQ5pra89UPBh6Jk2pAx5CGFLWRgQZhf6L5mA7UV2QTga5cM7Jh3aBhoc3Wq+EVRQ8iWOrIIYiqaa5nOyDJOpG7SLeRMzeFNBtVqxYS07vqjA7jMub0/vuodrijunnxZbJiqNRbr3YEalAUc/KrPEgKZV1+9r6sAm49Fr07yYVGX5y+x6cFAYrGt0uNgwn8K+AH77+7g3sVLeGBQfpnTSVtyGgcnzU8LEysIztnbyfkNDb5VKls/vqCU/HxpYbza/MaUFPzVlcIx52/0KwCc9BA6l/fC0L1XWiUmDF3EPfBvSnAQOyAZAK8AjncbRAVlr3owqJXcp4SfIHyaY8Xqd+n39jSYJsP+g9R+9ftvcTAxIb8mERxoW1XsQdHW9+YsXET/4g0c8e/56/NzPZ3z1KzMej1cLjTzOF6/0/b7j6+mjPqDjwzefxXxaXVQfZYvErQ7x2JNoLUIMqM7g5DWrSaNL3aw1CRtCVMg96L2vMDptiZxdewRfCQMOKAJGRNPoloHMXf+K6i4kEj9YzRvb4YmIlBvlTS6lRcxUmpHuE0n4nO05oQLojzd0PyEelDXKg9rqerQaT5pQvHmMNCdSICFYsrPnNeVJWQbs0wvMdEkh+hAZZaa4z8VmXugU3NuaR2sSDQxhtbtMLDnyD89sQukh5X05toMqobWW6AQslSRMLpiqVlGPakGppIFB6ctersuYQqRHE0C/h3dc8B9+v7elo2G6a+L0CBDk/g3OZk7Iy3W49vX1gUnhm3vy5WmI6R+L+BIiYAYng224yxhYf3QNii2Z6TIwQNM8JjJp15GzeEHsiEYV2rqU8j3QPbjK+O7oN57V7hE99VrmDRr1mUNX4b5/+P6bSWU+QKg2aBvg1tYzSGKS0/rUpcBF++z5ktZcs4WkHGFoFgUk2h3xuojTc1IDZe3T0LdE6UvBREPxJ3fNT5el8GuzfcaX3E5U4/QE1X9rhRqyR6Egu67sqEau4BcJOgBkKKVXk/l3C464oRWufzoQNFISYNYA9p7LPrRdNghug4JGVSnm6AUP7Jqs3+UInO5rq/Vwy101xJwK9NtnoZKlSsjcKLjKvTYW0GmBw23upnCwwdWgn+DPNfGaqA9n49If0NsuPXdZszVxMy72qENblQyWx0A9/3L42WALkblfyGvH28vu/yzcN0FBZvhNvo59EqK1WEO25hMPJGjaIHITJBM3GTbfXq69oa9Cg/dG23F9i3msRXQ0nrSgkscx4p3vee+NX/21148/81/+ofji19+Pr33tN+PxuEmGX8HrUa/07b7zq7iuj3wjI59FA9NTzW333ixMurbiv8L8PXTT+inxHmUJp+RmmF5IdjYMRU9AWY6k3bhfHTvSj5wmlZsGQLNZDCHaPylRYnFjx5DDUmrOaCagD83aj1PHyYdEE5LMttcShBE2kdrYMYiDSantuVAI4Awp7Eraoy75RqgT1UYoqiMT8tCcBhcTLemBxNcRX0wrVM3B5hz6R+scWnZj8SPZNxNiiBXWcqckcqjwkJdV/tAXRnSyiXhTCYs7IERwqu7x9EVpDjA2GL1njgWlYFFE/KvNqpoB7YoQUoOnT4rqH3Q5bt8izDNyQbw+4hiLSR8OKldLF0ZNYj8RyHlHYdBKbhNn9JamdJMjpAraKv/vdGEmHwPwg+vHTkk0E70Az9XNPk6Fae7q9EZf6HBifP1cj3APilkWYprYF8sz+ig3aXkrwuJGUSmP5WLbgu0huUqZiv0LyfU1Hb3lDTCflwEGCz+JTNLjlZSI8Afq/nxpvNB/+rBTPAxChkLtwDZoOg6VhrzV+hLnDV5h1bIfgoBRWdFegesOYQvFFqc+L1wEwC/I2JHHQThs25ciWdVvj7JeT0ELOcGT924y/K5Ge+0dqEbPAHD/6Il2gP5sfcahecr+udtsF0r8kFuwNAQ6YBFQ2SEY7jzvY/SPvynFAZBc7ZJjfxxNZvC/m4EEN+N2Bxb/you9hnJpzGwrOO+F3UDSHAcCUQGfaQdfo/zKL7hOplRRtm7RaMD9Zafheb/PWPBYD8XzsU8GtR1Nh+oNJanFpEk/jvjwo2fPYnxw/IE/8PPxpd/I+OpXz1ePjMSrLW6+44tK9Hw236pHHPG0ZhdHTtF/sQL3EwnbrokjtyQi0Sc33mbKCByDFVUwJLWY/iU0AZpNqylKEuySN4touPRmHWkuXkAMnYZRZxHCadOl8lbWbzepr2zlOMV3ovliCmFPy3kznA4DCMqRFYN7qoMOfROpCtC3K/eveqDV3wJLqe2eClKgk4e8W/u15Cap9R/WibwLb+4FWSPrRVDQJQAAIABJREFU8F+Ctrap9jmuHxNwod/3CEMI5d4zRPKcRVwAHAulupV5Mt0ZMODwYV58u0JjtdkzYhOCiutMmKKjJ6TKdMXV6+dUN6wzYW+etTNOGpFgWZb8UlShgNaf4YtfN3QCHZ+JGz4f4PoUbJYtsbx1UJ4NFCnvSr0b8DD6Y8C2NClwFXra2OPWrWmN2q+dU/A+BqMqEgd1zeTl7BouVGEi6jmbNG2373cDAd0oaAQ0VLurUxeW3WeMb6GpyOWD0UVuiGxTTfUuNC+TIMLlhLmGQhtNG3sTZ/85gjCj4FES4fFWLvR/t8OWpOT6EZMK99Cjg/PDI06PHVyUlFVwfdQk4Xf2+gCkgb0IQcl30b4lzW72uqZH3wUQtUBB5gi68xK7YRNUdRBqA/eab0sdGDJTSDTl6OwpsBxyEd4zzbpNdVDO7RZ/S9pz15ra6GpvJbJEyvvRroeiy6mZ95Kxb+HEtuQUOZaGtxuBccptefCI6/fGXn3r+x1FOnY3rdpHZMOg2RX/PHp0uJdCoM/UNTUTf3kqXlpUXGu7rrqGx8xCUZ3tQwXx3Lc0t5oGaegkg/CS9nElh1Rdpmdvv/ns9b/9Cy+Ov/xzX49/5p+N+OIX/97O/9/q9bCa5BN7VZ9QT/ONI58dc/HvT4u9Iu/DigxiCnq01WItqDrh4hYHoo5UHrmbh/PGlWdTj9ig7zqsB3I0qVNzLzRylBIb6d0jmr+vCLiBHyXFjYjLmzWpmW2B+2jdbbxEG83YM+Rbre7+ylkIxWaSZKK0Xm0/dU7F3k9iIyKANPL1vJyTPTyfQJvMfbmC7VOgKLaUfb6ffN0HSRHDUrcCR9HlTgcQIdMzlAjCwMBWx2tS7RudSf8MXxPn+Ahj0DeeliupMQoPQ6em7AY4BB9b5hZBvmcAfvT95WyduiOappVil1Ud7JN7zD2ldUR8IA1S7JCqwwo3cZwYAfAbsCV9y+nOtJnqYDzVUWWA1HR/Njjb5GCh1boXDM9HtSw22n800LfUnlyxdry+9/jLN9FaK69wIHYuKNdAIiA9BP5ILtC49zdQho+7l7zYvsbtFm9SnwSScGyKOQ/X5n/3pi2L9LxxXfXjqizvWFu5ItB6kfS9pzneXsfdqz83IqjCypIhl/FuZHj8eisasgyZ5hvt2SeP+b13UYXYkKl6rv1s24rC8v6byRp3/aVWqLlETYQ+lzNt2dNtm0qjV4OXhIPqyzA0ezuXBJr5mPfUIUA67eK3zdywqGnEJOF6XVE0RfkrAxHtcJ5J5MdwiIFtlfQIQhtOfXV2xtqkpGJLplFox+/wdS2NXZn2pW9vu565Zu+5GRii9D3Uji2xitvvp9HqEKpZe8LaZJhMmtSAtnQ7I8ItQtcg7UKjRTfjeDbi2XG+8eIbHx1/629FfPpTEd/4xm7YX9XrccYrfsfv8Fr84Zrx4nz63HEcz891qwQqrOahW7kpgzgXwxq9MmqjUCHwqzPbE/rOuvcY3VbcwPjlLogkRtAY0HkWjNlA562M69i+yTyThMO+FLJCTL5QvyVO6VbFOlbWQAotK7YibwkVMDzMnlPl0yt70rIuR/tlah/eG6f3r9lyafy6sBqPjX1OXYEbxjrZoNhnX8KKVUtWy+pGOYYwYO1k3PRChQuJUKU8ZNVVxDB3CAMJZxXeRCa+VITccP5UO6s2zXE0c2vMNfcHS4Hfs7dGfcCXUOSq7V1DRosuW8BTGiwG5BIQUntTnQrWcGYdYxApfji8xVsQ5CWItaHRxpi72Hj5SUyhIjrK07VM39zJ+vRenTDoZoGRDKsTWe66vxRhplW7hubIx1EVYnLsJH1R/vpB8ruP3Tm7MDii7eX6qte0wUuJSNDLeziLzhscpaRqzJc7ZWrJhgytWHwJaG+dCP5RLKVk08YE9vbtBDS9BIzq75pez5mn/yD9vHQZIYuTSrYloCOXjHquWwR8eIJVCDsFyW27aXufJlBj33QZYuA/sHcgf9bYcQfBxtQap7lr4sCpR2Sv9TNnuMPwsz/x2uGQxml6es6EOxeUG5ir8HWN+lOgptQbRUVZCcN8j+agzOCs7G1UxS+c89hfpQSdbeewov/sHWGj271DDUM5biDvO8DcMILOL8mDiQvouGNttDMZsmjr8HMpTY0u7VBxPwlaSnome14J4x5eAEJ31ViIOuJZPZxaCNkC+6htfXGmuZDsKiwA8E34200lutbRN785X/vRH3/++Bf/+Y/izbciPvu9t47gFb0er7y8+U6v0vitzh+ozNdUKi/JQGjWOSJc8qlwdbddUgzguJtueML4cx8VclFfTcyOmSOAr5eOmrG50yDw9A7d5WIlGopkiMDuAo22rCZIdhmht0Wh0xNHKu6VZV90EC7DcfYT9AJCqjTQXtKDve0GDN8wAA6wjh+RzKe/fRd5I11DZMd0UK1LsdaO2dr9bP9Wu7iuMq0yd+4URMu8rX1InyWS7UsduNjheTeVF6MNehc962QTdH+0u7/tFzLLXZJHaaoX8qTM60Cw8ubOsQTEe1hD3iFAnIRYher7j6FrVA2xqsQJ3VX3OA6my9jZwa3WzFEcX4EjrIMMW0Fy4+SoNKLS6R5JPcxZXO3NFNUTUSB6WtTcwWL3nRQzey8A9PC6YhkGH32Enc9r3+v+q+oj5aSek+1Yz+e65j6YwpXvhh72JI0OrrYQPsmNH7dJGVBWLf6w/Hf0DlNt9FKRpRZRy511Sm6ogmoSNM+1rfmtRVT1JtgOynhjNbVN5TuGKbD70UOu1Mb1rxJcuO5XtewCFOUJdfWCIBo+ujyrhajzVbiWvu8NpWbbpJebhQLpG/DXeah020fPO/skn7UXgPEoaDgrbfJmU9IiGvNazEmzqZMji5v7rDRZ8owb3VJsH+nH8S2dqc/RPR1ToTOTWA65uBbpo2EzIfoT9l91ckm8yEwesNiUMS4vc3CqAMjY6R9w+dOqmdprxfRxddvoiddCPUG5SozhpKrWM9nPTAYyxJ7QzRueG25tCypc3Dk4RvIRZgXKVG/LjPnmEh+fcYlcPvvZZ48//i/91PHf/nf/e/xXf/a9eDx79TEy34ViRJvO00dvnmc+rtv/7BhPfe2WZHxMoYo+kWZaeU0sg1ZW/0+pM2+z1/Tcg8c4RdAxcVRnXYfILAPfclFQt0aMIhQpjf4wpkcip6j9cOvE4mvfoFGPZY85e9q3s5lUnCwvT8yStVJlin5cD+PlVBCy7mHkIRFcX5qJBF2T7+5DhupocPr9rPQeNcTznIUFyNqpZ6FJSfooH6fbsjGXIavM9utQ5I4HaLvaAaOhZoK44Pbk+vhClVIoZxePi+owLsOH5qmt3128IcfSrXc5NR45xiYWJ0FgmmGPzUTWgTaArOGZ8dmqB8kK8ll2JFMu29h83igk92CLW1uvvXLIb3Gu4FvUFEvEMGK55QZAYKa2dDtli3NWK4fUJJ7eg0bmbYTZeQjWcAa9b8C+Y7BYJhiHaY+hQNuSJYFatFuntJjH8ic3gmikEVaNn3HZqvD7N8yrOT4T6mJuilRXUCpAaB6mx1fXg3Az//dUQssAnW46q0gBleGJVLvF3pCT9JkWN7KDcAh/+urkyRCbezmRWuHQdf9YaUdjYKjpmiA8uLrA7tFjzX2V+h0rlTTeV1Pe38CnarpqXyk3X6uKmAp2TNZ3EI/dHDw9MrfGwYev3UGJEHTwTpSvbcBEz13je+gwOYnHqcgCvESC9BSur+SrsCiDe9t/qBlLpH1P/Fi6O8hWHSm3j4K/nwBlgKzM0zZOGKrVp4YVTUHdaUXb3l8rQY2P1PgCv+1RIGIwKVuc4gmi3n50FzMxh+h3vDkVnXxpL5c6EYyAsNMGu8b3dUVoqzfebZZZ+vmmNMGBxGxvgY0uT6yO5jzb/zfv0LuWDlYZR2+m86JRPHt91Gd/9+ePv/Knvxa/+Itfjnc+/er9yR61NWifyAuY6qP54u2qZ8fRMQXHCT1oTOVSKcFl5oAmPrG+LdmVo5vXAdxbNvewcb2xGBKjCdbt+L3jmrRxr7yYBZrqV8EH1rsPd60uFoJ9ahHGxypkVCaYRbfRNrlZBwbvXYo2G7plrLZJ43CsIMUkk1xv06FDqSqUMmuBz0ZBthPVZTfRJg/D0tY1GpmpY6wtyQuKDcUcgGe/LEA2ZVXhZL3RKutDHTgLnkiVIV5338qCWWFLrpI0YXRx4UaDelPgdSh9Tyo/sHyju+vZOemqIaDPskSODh1cIxUhhNyCnWfsAFf1mTV6fHPL5O3Sr5Qirv6pHfs7RlleG2GinswnLzcMkdQE3TG8lhXk9OXTILGLqys6ckgd4MUF8oPrQeGI2Q4w2loIrrey+FuLnDr6URmG86ldNI4SY7h16jcS755qa5WCiOTcULd7V26KJKDK0esP1D6TKpulIpJxJWdFf4YuMztZLDr3ObCIGYEtjy1KPB43vJIgGLs/X5TRsk8G5IfqCMmx4FoE7ILIb+wTR9MikpTHUNKtSJ26LszpgDYQFzhkRCSFwteSIX8gcurn95S0tZEHEHvF+ZqZZYo2tUR2cI7lfpuNBuWnLVspzNnfOsJbHu+Bm1LJ/Y/NqY/RobxvHaMgEhK36vpNF3sSItwJvGxdhmBiPx+jGwcQVHOL07N8qxyH1h++mcQvseCM7N29SM0D2dtwyUgfZmcjGcw5wPDW748Walvbnh71F5avYyxX7ZIPDK3CRqFabHDnCvXSkB1gDsyTPGbRM8r+CGF6jII07enZJcIpVB073LS69l0GZxAd+Pvg0SuvdY6nxet8vD/i+z8d8dHvmPHW26++bnh80sAIt/Fpzs/1DT96xz+fUozI4M53nT1Viroc5UnlPFJJbRAyHXMTAelDdxtA+FBlOAGZU0eLlsJAtxHco30Y0YvezAtGKf6kboQJU9pgcmW4pybdujz/uZRu5S43ExQb4h5EPqhWffpM7FYQ6ChRWg4WC/BYafWjJevY23ByTfbH29kwdi/b9q46S2huvb8LxbCPB9ezScTL8EBJT2I1ZMdw4TXFfNjEYuORjRZZS+/chSnUR00m/fj6fMd1V89VEc2uPgg1382ze5YhqkeVAwCn6zDFWVyf4bytsuqk3M6LCaw2m++ryOYKHx/bKIMvNwF8u/y9dojl3MwbNYGl3Yt6zqCZU41jdsRfjwgyDHLvSW+DSzDVhOOGZ9/6+8sqPHTzLpeHpag/1mJXWMvs8mCN7npmWkJ3WPc8B0KPEMrMTcgbD6N71EVd0d3WU3Q27CqjGdPVgBKhf9dazpTchbs5xKEgzVdP7QxzK8RJhFPqHD0tAD1Jk/E70a3wzbTkO/mShmQhWe12oSJ23jTlJRV831A5va8ziFnjPnAYeChJ3jY0Zl0xJNF/K8W8CfQdFFmN0hkAUUM0rxHaRfyQJe9qiCwgGeVsGNQ3Qa/OKGa4HBBIqt/nmBwxzwxR2VcCEUVK2GFGTnUOBwRBHMv5pxhSC3FyERt0b6nc7fayHB5RZ867y7Wsaafgsb0+R5dglzfLgibhgjiHj/3VUv/p52monHyq9ik6lC/UI+3rzDLyNiDJcIaPJn5P7NqmbW/TfCKdBJPxOzAYtckIhnieTGkPaWXpIHxeTBPGUMJB0wCq+soZO2sslDJsrpw2Euze1F+tlvFc/oPH8hOZx7v1dLxQU/pxcE0f8TG86W/94u/Nd9IbU/qoDRm31AogpJrf9aKjn+RRHiCJG83UyHwGByM3gu6L7nIthZFo1tX1t1/3NEfA00gtmnZIPNtUDcHGrRcL5IcQxfR9Ka8bwLxWtVOpRbvoKgGilYmemYxf4za3j83j4xoce2JMyb/+ZXVUR8aNdpEasJSBY97rPsrBxVJ53yLEKqFC+mCuVRCyEsrlmX44Q2z668DsUmhBluFzx1SG/ghjEIs9w974sHA2iUQjP6VfSSy3rkM6TMzfbE9QRBXN2vVl2T06047gcw+dshu/tZUdu/kR5dI3jwndYS0USELfNPPaUyTgQBlZt63oKnouZ/dGCPlzkIx9y4dEeYU5Ma6VAhK6D+2mnVY+bavr61DD6WGtcxxdkFKn91p6Cb7v8eG0lIcBTPAJBQP213eZpo8jqt6MnbcsCJAHPK5gzFXI0pHX7ln5JFPZJ7HfkGfCGLn/aEwZ+4o2Oa5Z+OT00nAyCw8s0J88TBUKBk9tR1r7840tqceQeT+7rkYDN/ohBM7j5msC1sVn3KKq1v6XYSm1RhNgZ8M4TTrAdoNPt2hCk95x91pfQVKwOZko6xdVmB+KW/OQok9sudp2nso5xIFDNZqbjXF5zp3TVGmwP9hW7QfqdBYmCTfTkrY27elKF7bhOgjjM0ZwCAvhv/ip05ca1EFpUtL6fHeExgXgVJ0bjNuA1Dw0WTiHOkehJ+DFLizwFcwB50rr6br1hwCSc+o0sbq6APKIVLyp+sOEIPaXg83tJdWjE31SFrbakQWBNZ91yMSoJB6gwAQ9vmqteV6UglnX7GRZPB5V771Zz59ei6hHxvnMKNIre33ypme6rnOebxxton79b2WXr61V5/4k3KKRChUMo9OkbE+QVLQdv6pNefaM+Koy5pRPB0PlahDWtsO3ytaCjIY6TwwPFt9jUQ1J6BWcvLqBKzHbXbAOcWasmkYk+EogMtxscW/zfXcPY+2jwNdvPhYdENOsLOUvBpIFH9f1kprWZO2iY68bpZYhqTGi/kv+CXsFuGa3+ImCYBtHyYVt7mjuzT/szmiMVghsyjkj8i5cuo6b2JwtdJsmJowp4Tw53XxTU42U6WynG2v/OwKb1Z51c9G1xXGgwMzvJA2qZBIvZAC2cqS1mVGs1qbUvRTiOBmtC4imji4f7Nc/nvsMEYw8sbUD7NdhoertSZ8vkc0MpyPDqDZ4sZmAKjgCIYV2r7O247VMSIRQTXViWIkYntdGylhwcu3EqLM7bHDzUZIMmCRT4wt//+gUunwsEGM9eJJbNVYyCRZat2rKQd+RNv1kiDDCbMq7TaFtZzJQ0xL59bQcuxqCnLhkwb13UMeqjI6u7sag4yQGopY/VGkKeBEhPA7TOCJZvwbj4KjvMSIuN5qEAPys/yVmPOvWYw1S6AgooVgPjwW8w3XULwxHU1gqb/+hekXNOGPUQV9yUyCRFSpZWKkgNH92yplp4ghJhlzPdLWZIN7HzwHmEMyB/nsnaGNC9W6ULfXcgA7L1Vl+dKfkZtbconbSF6RmPc36FEqQoL0lDomFccvZ/dD6m129tsEat6cODYfOAqGD43IjegQI6NxUkFv8Bt0ZhXB53jhAXdm/cu5njDMwmESmR5I0ecERUBNMucPN1hcfQn+pfVMAvS7dGPE4nvLxqHj2fMSz5x9LMfLJliMlI7Gn83zr8gu99qSndaiu56MnwasY7+RMGMRi/IT+XWvHw4VQ7FiqQx7a8pYWRCQi69OMslbytqIlNLCNGvNoPhzEAEmdJpnkeunMYgJ5C0xbLyse2T3uowtVYCvwb/QksMMhnHfaK2+Auc3mi4Sy9YecWPv6FE+ezyKmWu71rmRo9cfExUyqoS5zyKnRftj4yalHpu2gKOQQ5ObGRpsJS1UGqZ8zwOc/CEe0/kXqy3F25VWjewocaefuEK0ZCOACa9dkJuAAQrWU68afCJdW6Wi1XQC1TW70qoLOVP9bp+fI7QW0ytwcigu0wIClk4rUGkrGczul8zh0DrNmZo+pxrb5LV+BnSq+GCqjG8VqV17kS6GLsqrNKbQjg3iBAvsSVJf0urfn8a4KWchsDQw/3DU1B2gNgh7XITthMswop6JKL1U1xsuIIICHBwpn1PBMxyqxo9SvjcIilae+iX7VDkUzE7aYN+Lmn5YC4Rid6JGb63ou2GJQhyfMaoqvy5AohwLpnDChozHnUJM7tb9bLnS7mwqoutaP3Oa5Aj6MpWHKjh5PG3p45jbN6r15LGFPVE6S6aU9pjyRVhEg86USbdXcxbGt7RRMJCd9Hnut4fRQ+YpfGw156mTWMFIVzdkkFOdUGQokt7C4f8fW9U1Y5WsTscn2Kd+B0eHE106YsKdHCUHSHLjbjLyJLWUSNrbI4bzlEniP1Uak7TGNobrJgyeXK/mzFOG5ziDHR3fOp9xpzd56yjUGyqPGHgTe6opp4UuHEV0J8p2shzOR9sdhBdt263afWhoUpvKRNYNBm5ci1d0i9nr/OhrhTcK1h4bfOP0tbnC3M+1zsj7CeQoPVek9MD85n+c3vvJB/PIvfCne/vSbf881wP/X67uiprn+v7PO13JhVusrrxtUc1UnedtnN+R65BBLuiHaCIctaaw8fBikByq9sdNh2JkqbFvupdMiWA7oqyeI47ICk32f1IlpE7H1Gpr1r8/TkQr4IsBrUwbAzj/i/ygnYFg5lPPAVbJ/v1GG0buaHMGbfHWj/SuYzz4YtVECm2RrpJRlA4Du2eZ+YqV0JcIctGR1Rm3drMdsHuu5v87UgQdI7i6ZQB94tEEgNwzvGQqMAvokqUVmSafQCaJXO+400OLO2ofcUZpNoOMpI+y6O5opyP1HXrZA0yLey78FesK5eNBihDH7D3U22/6199tdlLYOJjeKoxDuXQeIizvti9CbXTADSyW0a62iIhGqnofUH9f1O/o6X50aLL21+uZdiOGCAp8DDeZ8TjFCUxDJfdiSkoCnnq+1fbVB/0ST0Tcy5eor9w0PgUqE0dVwNIrSTxnlZLSk1fdngYwq1nV9jpKxvCujzi1itGOAPNXWC8LBK3llXFV/8hNNTQheXPf34AxSbX6MJE1FzQghUxrjj/Kcs9YlhxB85a2bM0QhLqTs6LFM31t7h66YV1mLSxUCC2ZdhvOGdWHo8XIPxP0FWd3OYP07A7/3Qfe1ZTtrd1QHvfKNbMsDm6avD32YGKcBVwHf227qSld1jXest073JcXNbsyIB1gh+X5ch0Ar7R2H3NWcppspg9D+ge19uUZVgx881WoNjTMBbaK2Cd12MtEISaaXbu5qm+52e1ZDAYoBYjfmWHHGmxLST79VOaeQWHtECk9ieXZf1JXERqk0uW6EcTAGAkk6FZ0DvTRErxYjeO5qqBok1mUt9QLVFWlnS+1gQsFirs6sO2QxVB3PnsezFx+8iPff/TDm08dAYH3l7/jbfGXMZyU7srW6cQ3aERiTtEeNU7qP5lQUx7vm5vkAKTFj67WceugmK/B+wXm6MJ3Qh+9bSVMmS9hEaqHyt9cL4WtD0w9NfYwsI3wf3ZjM7cGFeZLzMziJtCb2rKWoYCbYZjfWcmRuiHgmxsSaUTXTfcpXp1GWDQvm1ORoxAE4Yp6MWBNdQEgmUyJthb8ive2YWC2UH6Tb8Lvh+Qj5nKiSbC5B2w5NMXj7yLYT/IThU4kDObIYnumWXU+YocWznMDqJKzSqjMuaYxCA+9Jsaek9GDMOlba5fZunn7zvK8leEwMkkMUk0Od+PSBqW18eBFp5rSZQOm1aVCgl4dWhOBuQale7G4qdC9q7c9i6k+q+l6LDvsXJxz8CvCcx6iYLTShuA2zgFjGTaeMpfgeVumhyM1Bij5gmU6GuvR1ESeOgHyO7mTX3Wghhh0OQ/DP2CpKf36VAY0Ruebc4zWHJM2dXhoyzBlaiiwz2XMmcn9dPlOiu46VN1xfZPRtMIP2TX3CI0kjtWu9oPPmiVZDME9RA/qcyyDQFnnMty7Aex4Se1f/kpToVz8+9iZStoBXHZ6adzRfonLnMi5yxSTnqeLmbS6jNY2RT2I2etOUB01/oLOrA2f9UJ3wfOrcS7m4dSJ6nwQrTTyPvbbLEG7AoaiEv6WvX4oY9lUIqibGM1s0pTeVeCv2zF6pgGpSBpiEqlPuhsbv4S/KUpxS6adWCRXQsAnwfZ+S/UD586sZmSLXpFFEDooYe31V+vPrMCmTu6+Z4dwNxnqipkdGtS9nMrDUPEpfaPYiw4cqjnkcyqN5PP8YfEbsd/8JvYSVx1kfvb6QteNoVHN+dOD8JilD37ErtWapjy6alsKjgSB7yNVI5azjxBYYusNC1g5xOCTPa2DFao5u3LLm2dBxo+habqtPWZZEF43gCNtl4GPQSJfw/aEKCJtA4ezd0hBJjqPZHVCuRooHCOTInYlyAfSO0qMsVwvTh3GPpnsGr+3O+5a+9k2M2p9ixGauge2R2Lfz8Hv7b6p6LRx9FtLJbAmrtHSdByscuo/uc3ZPuZK3rifrHAxRGvORDZTIZdKUALCKHF6cJc01m9qxZJw8U2S4idB1GxNNSpMxpDOuYwZACqdJtFlKf+0DyV/KxKzvGpe1xPgfPqsK1XETUmXHtjVWLQ5rhk2bfitboPbBOvO6NxfsN9fPz1air1po5SJd12/tFC2RWHz+OayxWqlO6wNAAXa8evZbjXOehWGdBkYLjVHPOaasVccaUsmBZQjo6JH/NXeaYw7VTQzhu06AdtQLn8OuyU1X8akQIzWyTeYRzXOVzVMsIJ5v0XVKanAlNKlqXcDUBJfu9d0fR3O2qXTL9WBMNQ2S55hPZW0jrL7rdg9ItbiPnSXxRq9qfT6RCdIWdQKCSgtpfeq6+Xp2NO2sYz1B0cVXW873TVRe21gn+Rym8MxOqDpFrx6xl6EI/KstZn85mAPFVg+meuloCeHkuFrXrge2R/u41jjEBarcp6okaWLwsrQ0cpShoXRpvX41nMwWb/V4NFt4skh3WIhQmjcRZO3QtsZw2b42ySGThWX60ESUUxmWDEymKvxRvj97NC2u+PX5htIsTnxxpyzORs1l+TyFV2BVsp4f9Vc1evtLGtHuosbRiSPzwi5VJG0F8toftfUf3eFVvYTQIxq9bj8V92wcWAIMOrxsxF41U+5DTiPpUfFElwenSlXJevQOhURMI5hdpmONM26rSsZzVz10zGfjcZxnzo8e8xlTATcYr7QY+S74jFyz+Kfzo9eC839Z9In+JtOitUMoAAAgAElEQVQ/TcAvLp99uxdFaaiv1S1Wl3dv1NTFy1lZx0TCcrzxrNQe96bWeHdnRvcYdChjLKYra8fMibLM7nVpv+bSs3R3eYooOTboC54TUJ6rQydbdLajR3C4mRLPj3LoXqtQWrc8QAdp4SLwGRJwqa1pD6TNGJVXgpTIsztQbtAQNb928x/uPxEfaNugGR+zb8MowQ16XLt2iP350Z0VM+SY1pyVvnvvZAM1qVYNAwcMVVN9q+ZS3S40nGE+yvXmAwQGiucObHOzyu+ArSmeE4WW8ehSEEeXrFP0jN2TXotmkcHqdCUnqgLpcIGnCCBAyAlM+oJUsvkNTC6GSZfGl0NmW7dAReEzLOkkVrlr7/P9C9QHkDJK/FEokNhq705Sxe8pIGWkvDJFtTANVp920P3WoFpDJiBfoPYycO8Xt/W76q0QwW6jBlQPxuH2OMKXMXcRu2mfRg7ICuku9lj14bW/TDz61VUOGZfYnJaNX8RhkXJYO0CE02BQalNfJ44QcE3xVZ81DWf0/tY5fTwaWh/DSEx/xznxMFNN2sUgwIMMdG/AwM3UhYmIfP/s86YfhljZRUEwK73NPsRk1SDbI85VwiyUtzBUCXVfHQRJ4BupXRE3dLK9kIsxe8rza6b295KANkVVMgstQj4z6pF0dN1ytXc/MG7jSmF7rZ1JgysAiwuWGctCTX4KNvdodfGEpbUKhsD5UMxqWOEh8kq2p3TiRgxxuoLKVl1kP45isa49YMj4UV4BXbo17msJnXLnR5lcX8wDpKfsZ+7su7loI715tTDTsRdFhD2VpcahS4uKjpJxVuPI8+nx9a/3//Pd3/htHfd/V6/HvmOf4KsWIf8xmlt9mTwVXFFpW9u9pSG3HhQD7ar7KuxysfzXc+XYtcHFlE1xV/AhJ2uPdSlSqhPErIBb6/t4yOJ82z1NP+7NJHF2OqU4cq/ukpL2yKTmMFUl81xeFv0nj17eskqoXDYU13uf41RuX0IWTZ6IlCu5cAQKkUSpUPL0JIy2pyZj2Eu4iHPVnl2+/joTx6xR9jNWqzHEs14GOsypwUFNskiv8igPbvWx7TCyPvxWPSOdJ0ouZWIN9qENiVm1kpcTD5rADCnTHwBwvD9eo+AHM0GdmxE8eCcbyMATRAhdYi/ZlWAHeVH3SHJ5KkkFO3S2397soZLo9vE1C/Xg2mKKCdE2yBw04FpSvTUj1Z7z9ielL0kbWe9gdBtVUSA0OW8s0Z5rH0YN1AIzIUJcksJWvqTlpk20yhrhC4VAsQ0x8bucgN86MPVBal8hPciFIX4S2CabcdjYuf8EFZDWh2hGffKYQ+isRdczZV0YcrSeZs4wIUzrV/fNZNljYRdiZ00RxLaklecjmS6rlxn8SZw2elTAeFIMYig3siYoKcCuhTYhl4ou3HXuEHe7odjBzpiMIRrrPIIOz/hGb7PhOVHCt+rZrp1JBAGFiVMOqiRtMRuY2pWSpD16+sQ5j/A+4P1pk/IZRTfFve1AMALpca+qtWsjOiiWw3Z0Kh1C5sKr0B7tgydgSmv7ZrDr4mbJXGVh0myknl0OVVjVJgRzawdZG2KwN9zh3S8Y2nkaJAQUSsmNOq2fyd5f9WDohsDfyNLJFKB6zSWVwZxIUnc9qd5rdGOUYX1gygqaS2FGgZisd1RXdEeKxcXTPNd/Gj/+ez6Kz7wW8c73zFdON/3Epb1BF4dJxcXuetJloJyd2qRpr7p1xxkj1yiE82Q6XWQLKPaWJQyBfm+RxlISsvL1b5NFiDpkx/fu8hA3jkxInT+17Yfo4ViW6RmrnqPmduoeD/E+sJtsA5rQti32WO+eU659Q+1ldwDnYjPuR3iLOgRTatCs68H0IzGI7bJI6GDWLTmEYX7beOkjO8JksN+oXptrG5jbyljY4dxs1hGbip8CQAvF+xa+86t36rHOQi7qJjULuDSpjiGAhJ57GRTDkGQcek//UK2RS5nZmInsJCm8kKdygqsxkXP2jVjQb2w3SbYf0UG1m6x52rV4jmmCsk7XTFdXlK1DIWaYRzgJ7CbTq9bCrhGATqvDtR8Sj0Dhld7vtPGbRipjXice819b1XXDwqhqks+iBMAyqeFGlejaaoHUmFXENu4tsJjgh0nc7fQ7lY6tqWrTKpcH5DMHERrluw6LANbxrg+MXMggoM+kVQ/0LMDxEzAz/TgW7zBFMFb9UrcjbdecZmMXdJAqiKSKVwgjX0cqCCr2UcBH9ES4l/xL6raz2YfrbJ6SRozcG8htfZltsPaH3uM6Ims60wBql/4YyFl77wVk7u1DX6dULod3826g2nzSdSLGWMOMU9ZPqwpUIvWHF8BtKpMHa1Qr2xEk5J4QtobZ7UQwoXHlGtCFi9JVtWJK7SJqE6Jviorarq3r5wantpNR8ZZmSO6roYq12m3YyWD4WDZvI5x2HPD+xEsLWFcrrY1apfZlqYadS7xbDBE6e3TR75bs4ZQLRD9GKv3nqYkpqJh6O6/6shP2ijfQNvXuuxV/3+95dvzJf/et+Av/9Yjf/PCS976KamC/vkumZ+uWHBJFa3SxhudsesP5cBKLT6L8u9bTIBkgTD4kY5JwqL8BW0dDHFl8lQt71R50FtqQy4dMn7mTxvQWOXYrerz9rjJGighY9Sf/TmNQGrp248qTfAMW1ngnYe2PW//XB9SQPK2wjN4oXRvGGTTcSpCwo2cb6rjfZxZhh5XBIOma92prK7+pxHwiBDMbYlCSewTPnuEQ9VQXj3gGKEYqsmax0PVx/urh0Lg7yqJmvTfcBUbqnZ3qCFvEGfYezHsRAswt0dImDC+WR43bpfOW3XmXU+PGQfPNmpo+dPUvVKHNW8A0KnHihOV+Q6GDTnXfQ8CYPpyvvelMKzX64omEdyUw3dauDlOJn4/k2UMx0Z9wDZZ7a50OK/fYTkAV43qPS/QkJoKNC+Pejrgu5wKFkTLSDFiohd3l1QmJk7/bn3pyUE9CGlsHPotr6ccv8QitSI8g+oBjumobZ8Os24PygPaIuqpHM50JJcsLm6Jx3qdi2NoA14aNfCiPc1CiVI8DkgdWt0TEKBf+jrf30x/u1FU8Bj+RoCRhXlDuo8XlvFCybAMl8l32WZiMp+oeS+yui4kXCBeKKkUpTQOrg8bKYgBrEGi7KfPtEar7PShn551IKXJfYfrOY6J3Hzdy53ZTTT+LDTv3ME2TFVdnutiIaHpJDaEtoBHDXBZxXG6owq0W00W3hIj9xYZPGCOGv4OlxUjuagbZk7bOlwKQ7U5fJLdbbDVp6Gr0TiVgjKXUDXub6fnsGzpeHs91laJ1576aUWet2fRaMh/Va88fx4jfH3/hz38lfukLIz71zqslsX6X1DSGJvkP1IOLpkc3vAqB7sTtvKHBpUYfqiRBjVcbgpetm+LcwSSi5WG2STaD3kJKp7x/ThnUq/cPj4K7bShrJcHXVovQ2OjyW0sv1DBWLtrH3oxSbNc1M23vWTEgadRobycZXv1xppd/1yVbKLfId7OMaDsppCWW2j24YkgU1b7gaB97ZTKmUmsAaFvFbCBQnBxt5LyKnzXvbXkPEH1hCXELIVbw5jppBzMRK5FsURI6jIz3ShQigdKyJzG7mWNj1LZOr8G8xoBMZ6Cd/HxbzxuvHDD3EoAdQl9itw4kNIC5YVxISdfUinXZBlQHhYeE+FGtu5I8IVTCxaZT8N9grKpjbe6ffEvSc6c27D0juGb2bg2rgkxl7MW9EfQ9MyEPW749vX8NExrFigZSXo/kEULVOxoISbCsfJxEIDB8P2I97maFSuo75RkHlqP9wSYbhmzsWdEoyfDGjb9fqNcpEY1CrJM+fPSDk3OB4a8QJhltEVBWSu3zlHNdxnNQzvcjcmzSJ4yIHS68wRw5PUbSTlDBKC2q4CNHdZL0FNT22J7cdvink3HZbUSnl/9AabFEAUrup+0a+7hLD25ZzDflSTalzqgCzoyCDRh032rl4s8OGPzU3uwoNzKJMOUxKF7A0kKnnogXgRILztgN8zQNP8BdPdMN5RBGmxUYQBwCLTqOtDax5F7xpSJNjRfX3tVvLlSrL76yYM6Nx3Li9dz4cjgteWDtnWo9J2d3U3Fo4Za5jNgb9kaIRRQTIGPTtl3NScCAIO0aMGpu4zM+2Ex2PFRP5qKvJ2dd/Wf50YunePOz/1f80T/6jfjmB8/i+Ss2PvuuFCO6hU+7gNQKubT6cNdSOkT9P40Xc5m8YaTPFuFgEktqxhPnjpzaPCJy4cZV+FENS9VZmIrGVt/7kVFXoBAW7KFcqsNm3N7kQNAaK/eqx0AWSa4fFoXVrlCLru65NkWIhRQv/fSpbTVGblLXHYpU0kMjQHPo84sRlT60vB/NS6G0fmsNikY43rAkCOypTSkfP7Y2NW9sNtzY9qEwhqqiSZSwt6aJQrBxzgYXV1Jr0cKvxP170+04UU8RFFjHlKbt1FwctE/ejXS4+A5mRPem0N4LU2K+ka7DdpnTY2qkMV4eiX0zE0JokGNPZ03+5WCKjrZin1H/7DyYVi4poGz7eHR9U0GA36CySYm6Jp4CnROpqzxAycXP0vXjdk02qo5TbNkVKzvl07O5B3MRDyaMQEmKpcrdbS8UO7qPFb8wvaxxR75HP8xwrluS/lK367uMM1fFO1QGNtcSA82wWELlmFaJ5+DNbb+YWX54bzRJPSokvY6UN4/5j8V0FPl67klCpa1S2h1kiD9KmVoNmMLGXYB6m1k1ep5hM3Kwx/XHbzTziQdAA5kprVFjQM6SDSCiHAZZmDd3hNOp0kwoRy/VtWSwUO6DfAwQzyW9myIrjBoO6IM6Oi0bBrLYc76bk9fcNWV6kyOaqdr0+TZPE/IqOt7cGWatgLOT+SafrWHFKTr1UcCDHdg3x2zW1xxpFC1ZHDzWcidl+lPuawVRlYK2+oFkWsnKC7aU4YBRfvgyHHcJ5fK6iwzJIqZnALwrNk7uVbBi8JrHlin7/iwe9XA5ueewYawsDGj7+QijKXL/lD/hp94a8fWvPsWf+FNfjK//6kfx9qd3oOmren0XihFw2DrGpSaDaCQyIlAprB3GZxqb7WG4Np9iBrEbpi07X0ypY3fR2hVN2KLnSo3x7CcSt+M9yRF3H8FIRP4e6z8OHy/ySdGwmF1Ujkj++5q556ml4GpVlBJ14Ynww6hn18b0AYAD9IE+4vr3l64w6FJclM0F7PQpLO4TUOnyZUm3aPrurhpA6W33EbiF7ZukL9SSpLqhMwoDUe5C8867LGuDB6jkJfLpfl9hNw4j3Lt/AI6iKmZ2orVW9mfa8xDpDhObhP0bjlrsKTxuNjJsGHN/7wWyiCvBJRq+/trJhzi8bXFhQcGckxCllL5O7WtRcPd0pMl1U4zcbG/8luGOAQQDwjHkzKHYfZl00PH73kRs2IhDkuso6TKVwBhMUW9xgMLq2demCpyh52uWuCLSFXqjX0cIOQhjONdM44LcWYVa8JvGIOCpj8kdBpuOM6miLGAuoe83tgR4XT69+/ESCUZkAf0e/9dZ4cOZNb7WG2dMX4xqLgUnbATP7zB2qvlFk09qWmzTYAljgT3M0jps+uFcw2s53q/Yi7R196nzf1KJ+/HvqnuKEYGEY/3NOfIYpmXJkwxr+rVfLI7tsrCGJwZQ0387R2fYpB676eufLUxatUqbVeyqRDiDs2X2UFAMGoXotbDPyRILGzu1jJe6YeVlijwNf5tav7+o5HcDDmvO/QtJhqBu2axbUj823JknM332B6hJPCBnMc6muGju2BD5dm5L4DL/GPIqtNg1YjHKT2Ui69OyH35/94tS2+ujr294J6QWA/GDtRqIK6aHzauSkw3VLog4o/BK1NR8Rrz2/IqBj/Hnfub1+OqvXD/yigkj351ipJgrHOc8YYQvTwULYGSLvpKTa/OZCkq89JRMNWn3Av+z3nlUyYzb0+1jYsOYSavL5sSsIm4ZG10dYtxFEd73zBkGDrvEukuozeamYc3MXyXuGzO0jA0mqOL3jMUsuSnW6eSb6OGGtN2rFCfXropnQktS3TJ6PDHcW3uS0STf0URZ+TBzYOm49C9onJziWtaNQKzqpgfR8Ap4sEPvr+tTqCOHBHNBMxz+jvzdoKcAhX1Z4Yph01jJIMmBzQZIq5eK0GFIWhikylW+EbpGA2rzHVT+1ZYyeboTmvPKYED2ZgbO0lj8VAgqpYdKbEWsibkStste3XJHpBJvpCJtLmDA3I1URd89f3Oqjo2G8ymDpKYtbfBgufwxCxeH/fBB5MTPVffyHsngeyJEnPghh9vdEXoiDa5fOeXyzfhKZl3C4LFG2PyCpcQ8GarstUGXC49H+nVfTAWs5bkgNul0BiCIrgf3utrKM0nB6pOvCOAsk76tBvMkTYJ2HTu1jU68B47y83sYSGruh7+JfUjU1d6GGxPzlbAUokCldJSUdFt8GyhWOvcT5/ChUSOddvMm04X5iBuOqvUBiijqacKwF+gM8SXm0LbVmwNeanuYVNssMqB+9CdR5lGVCOP+qx4bT98pf7ENYTcbqbFtORkMc+zwNfTOR9Wnz1fwziarY+4FxEB+KrY9EXZyM3YX3W+wK0yzlCI2xtFRTGoWPQhoXTNCCO89wZnRCMu833yfcrcDTgOqUpfNqFZtUr3MFWB34xxuN93rHj8yXlTF88jH938uVjFyISOv+jVe+Tv+tl5dJZSI5U3jm3LPCpxxCg8YAyLlGqKEtRbR9XMLpPrYuw+lr3c4To9ta9M91+9c4q2Bz5x+6SYr0AmCjZbmE4kQcw8fBd7o2WUtVHuJpMLF9slsul2t5Tg7XRLGmcDusPnatHb39L55Rwt2KJIN5S1cbGIaRpy7EWQXYpjUa5cOtdMg4Ouw21EQbnOtZmYKE18Km+r0b6VrqV8WUzhwWb2FTc7OMC5VfGSRO9XV43Tz4TIRoE5aGUVXtZMNxoNlHAdkrd9r3kw7F7f25m1Gh2CqEZckXXCBZHYIvZ9ptpK4LQZ9/lHwLwKXb8EmCSrhxWeyiShPC0CygQxrhoPR3j292pq/UIMuB1/dUiKfBxlL2GoLZCX7ipagkwFdwo5964+lQs14uq8s10FTDU/r5lTSykzihqWyLRXzuaWCzVbvbzvEGZ+d0s21dPnpZ578DIBTMStBBNukL1SwuKB2CFTlk7f68lbeD/MyO7paYBGoXbTV2OSj3JMNufTgC36DBA2wd+t8LmMJaYRYnyJT19jOfVzQsqJEN1a7S8miTwVh3H4KMN9X10ORsRG71fqd/mf+cMndM/QUd4SYC0IrSiudGCYjBc8kEAkQlRg3psqt19jDwo0bpJ2j+87LjolbuHT44l0s/vosaiYKS+7zeZUOo5UIHcEoLH4iA1y+mu1hzQUHNNJrMvW3eQ+A/k3woJ54ts9M1C6V58xpNG19HL3d2vmuY38AtaWMT7qDxSwTxHMHmXLEaK653OBunzGU1mb/+zvLZboman7JmlzFXiA6u9Sr5UNsiPOlS/LKX9+lYkTQe9YWdd0wM0wvjSjeuNnhp1qzZjEi9iWkhpVuUnTIAJ2feqBXFjZF/CW4HZ7Yu8GUn91w2dwngby3aED3KK7M2UCkoUSzhciZR873SjaYOsyQjaRWGpp1tOuZ1GA3HI0pZm4PDvFTh+1TZNuKOjrny1cIdTEluj7T4o+PITpDyszI/pOSaMDxblpbH4Q2OpMQWxV3E8C1yUrKUXhXrfcb05twVxJyWAcVZdFs8KruKAz+2Vo/C1gRqtbP4VKCuDPR1U9dZf0PwfA6/Y7kejbVZOyUNA1Y0xAYG0ll+0VqIntLt/A4el0ipLuyE9jJiyYd3gbVwYdtTYHmbiGmtkPpxl6Ahfhgu70zZOMYCw/B0mhV/6MHwe6yeCoDm5UkfV916gircakStylMn4kD/1MIo0kDzLPf0/VdcO7/07P30pl/9RXywtlsZX0KupPE/CQlyyfwcVdMBckF3AwSZ5XDLJuEMjA7XAoeGQaDOgC0auKrEExNYYe8K0bPFVQRFIkBLQoimGTD5C0fKQ2iF3rpcBPRyPrCQbJJgY2BrZ6GaTONAw7b1pxC+hgpa+rpDgUlYFnOZhv3bZB5RAfLZzvNlAzKOLwgrMWNAHqL60h2fHsPJiezihGaKI8gjAz57ixzgib96/OLvDEb8ky2wOVRq6c7vFo2R2iw1nmqWuzafI+iN+hnjCWNgofKAKC7F8htnA8VDWerLurk0t+pkCsXVMSQSSYNAKc8AhHP3709/HQHZffomkWI4GYc6BPnrZN0pQXDGlSGSrdv+uhcwHOlNsUj42n366/+9fjGNz/4+N7927zOFxd19TI9q8v2TItwV+0Evm2uF/MOSoLyYtYNt726q4fN5ZFZ5QwS4TfYa4yAkIH+sIofpf0BoZfpsnQAevZr8Rxqh9QNWfBgM6pDuBS0Lfgv4CJaT7bhVsD2FpXMtNWGDpCwZ5qenHkbuhZPmiRJC+K/H+a7zJELfaL8CkwbHJShnufsi9Bo40iTAWfdnkVQqaErcYoRnjczyhlb7K57cKgZnC0gqG0W5h6HvdsF4ODRGi4+y99ss2kMHs0bhpkMDWqPDvjd/fyGt5fRPU0LjjAhCMPf0qUY5h7dQW0JeDIOLFgYAOYmbKrLyo6hiE2yNC/Xvhcq3xvjGuQeGp3LrSKcG9y47V6CY6wtdPdT+9jYVb2L5f0J8rbMYo+oOmbUxVC6nphu9p2xtE83EzUUIUXZtuu3vrrTj4jDijU9VbnNWvF3TFu9QUTp/27LtDXx0p9wKjRPbUa4PNSZ7fpaF6YHDU08P1Xs963RIObUuOJI0VxE+mlLmNBRn/VQUn/tJSrviOuoX6FaJ+NACIe+8LIrOMsJQ3GH+VVopg+w43bmbpTxLPCU2wzNdWTt1seC82lFlqR0nh3ePoiXUNxWsElbzJ8GIGOnBA+NsUvOXH3/JMieDERnmMc8SgvkuuZd7zZC7mfWxfVlqs/1sRm0jo9S0lEmJOfORfBZEOKH61twjmCD7GXPKK3l5368p8wl4NhZ86/1u7Ox8B7oanYGnpWS0EP6B4HEu4cAEzEAnHiHHLOnbcQe6+yiAOTZHHscK9mPAK2nxWc5p5TtLzcpr/L1+LHf9UMf25t/u9dVZb333vsxjuMsNCdMejfx0Pp9Jq0HXkF9U/acHS4jayK0W8CFWP95ILHoJkOyTGmyN2AYYJP0ZMY9/ACZjjIoQvzIrf1hFFR8yPUeGPoE67ee1ZM7TYHSnza19/WuM8pNgUUrDQUGvSR7TOmqMapZcMwKL7mmTHOSm63B2D6xbkWesYNZu3DwhNg/bMiQPix3+XDBCp7HurQ8Oy0E983CvFmtUqOQklm0BmaNZa0GoPLUBb9vlPy+G4ESFLtpvR3mB/gTIrwPu7UZI16/Ljlx2gUEYiDvJrQ2mx+5i6WwzLaUV6Djj727SYdVkk/wibOz0+PmrbHwe/j3O+1E90OH98YLyeDaxv57zHQz7uKz6+Ko4RL0tqU+twdCm/aB1hipbpbMR5zCwigu45ZPRlVOKgHsAKzTgkESXXLtY0zLvXyR7ltxSXDAgTP3cwj3AK+fGObxLGb8kFRi4m1OFYtlfXAdpI6/Pbp7rShJwjVZWHN2876Q+N6sR2lIM58W2VoG5d4b0gPeDnR1QdTDo7rd39L4WfDufj7MzL/pXBS+o2dl0aflnhGgEEbz+5vOAZSvL2NWM+XidHNHIU65NLu/3J5CAVltF43TuNoUl0r1VTKwRE8lXpR5nEOD1+kxm6mwljUdsVekVT21/ceSlLONqJfwr7nKK/qBvv4DZrbu/JAHPc8X/a0zSWzls+FjV1+QYLclsjCZIswCW/rUaHL9Lm69tD+9//J3dx+gG6mfUfk3NR7spTJZar1ziJdjvWmWRqcRgVK+rWnGNvr7OF6PP/mv/4cf37t/m1fW83j+RsT/8t5/nF/+8pfjc2//8AVDrpAmAcqUoDvY4UbO1Li7V+d9gqWDJadHjTnI7w8Bn6ZCpguexT8yq8G0hr6hc3NIOwm3txRRWZpeoY3ME3dImQRhpUwmIPOVA7bWZ5U7K5Cpdz0kIJHmW21qXezN71a+d+fFxjyYTlUbP+cu/oOquz8rw+Xd7vjYpluFhDtdQb/UizIYon8Q5w3GAU82ZEIf0VMEWMtitSss+bEKgrxpasUDKBcGG2rmu6UmzLsuksh+KqMebGJ97bMdglRwMre3mdyeZSzb/pDJQgNShV45+Kg4C5WqApehN+pibx5oSfiQEtCAGG3UTrvdUEEDL2jsn4fEz+nHiW90I27PD26fYV4Ecug+S2SzQAz/jNuKoVLVvdhELir6BSuTLuwisTM+LG9MXx+601QOlXtOyWyEW2HOcGNEqAqw8iXthKerUHwDS5+gaPdB4TEdheLA8UoXZ6/uwYOX+S3PHiZhBhQgKgTPqYxEbNRcfCeV9YfQHWAgyn8OXhCgA2cIIhV0P0fVlvu6VEvePzVO06KYVtOEY2cQcx/GGIuCcO51pXtmyGNi3CNDLqrR3dWluwB+sW5Le3vczqaaMTET7w0H/jtAF+YBic9D+rT7SUnzAm6NR9IkduQNZdSocONM5PcE1kvrSpzSUR2WMwKp0BYVz1fu4h+eKOqy9JkQnGq96uxuyMCNZyQ31WjoF3Ev81MdRn2S8KJxz0bRTkBzCIGpx9fmzvX50kQo/cn+Hh27uKjivZmOzN2ffiyvx3/0n//7H+f7/79e86kbhR/9J94fn//hH96BKogT3DGa9ZT3ApJctVvTezs1b+sFICNC0SbMJm7HKN28yw9XA4XCVI4wV0vbFaSCgC0o8DizG5E2bJTdfFsHMCFSfCT7K0M6BAuJjIBGiyyC7TdPtX59j7MNAzK91rcEzXOi22bHR9Tx42YhObdTQXf80i2h3pZCQiW75AfJG7e5mdyge4osbbdRkTAAACAASURBVFh/oAMC7F3WogfbzWH5QWFIwcXysTg1rQiDP/rXGzbsvYwon1p/n/UzIdXITLHx4XKOi6Okwpc3mSk1703JrNEn+S1Wzc27RjQlm7ow6oF2shGj8spVAVTtPIIflzK7WOaaANde2cXeuvNi+qOP4RR3SBrFXANzLGC1I/0w6FAm1JzjbsOzJ20oBVjw3EpsG9gA1U6q1tHD5w9zqdN5DP78fhSl4dqjIx+XiSB2wJGB+hf6Xnpno6Q0x1SHEkQhe9TjAFE7nH0b+C8Yk2lVSflL35QoyUl7F/tpL7f6Rrf60fu/kJkZ807fSyvP6BjUze8KDCLtdhnbh2GMl67kroc1DmowKWWXx41lTFCN2laLylzi5G3LkP6Arwj4nP4vHqTcqhOEUv5MeNVr6JS8NTXVbRPw09UBH0o6pssfh3aB6erAaGntjq5naVoHBLroUVqLDGkyQT6bAw8iXfc1Wv6KgpzmlIWCVPC5t4TcsJpRCWrycGHGPR5wiA295b732v+rXroHLNnihtuZZJc7ZTzEWF5Ze39DVzx+VX/Otb/ZTX4sr8fP/Pn/4WN782/7etFf+o/91OfrJ976ffHRu70O2kpYQNIsUF5W4G1FkiQVAY9/Gw748Fo3Y2p0J75Ds4tH3B4Jof2OSdG/yNK7V/HosFIZZQKfqCcealIhgmLaByKoUkcBpzraUA29ZK6pJ29xNIZI/TZt8nrbz6jPJY7McMhmUzrS16u86FT5Hm4IdosaTWxbjI/k+91OPhcpydPaVVZekWHTO7R1CvOm5E+T6ft5HDtdTCFF/f0hT0q4qBGA0k+lqrK+wLaRjVYgT4UUVIpX2TEyAA7sD50+PgU0WLjIRcJNtEP0d45E05vXnxakMOQWIk+EVevhj3CMhB6Rtw0HMGxx2EWY2QfhslRQmDIb69Z9YGngJyOViuoNS3UQz1AX1mMbEQeYt7ZlXD6lbxcNq5ZEHHOVuR8YdkMdzMAyRjLbipYoRPP/TRXcx/auGXPuzd6GwRhF7Bbv5sdxrz5VNmwfms59DSJKm2fAFbH3HsCl2/d+iFaEixbLlOFlrxUcjn002pm5g4fW6BXUhBqxTVBm3k+xsFoq2RdcwtKhzL2t9aUxWdmnOv4auZUWQusYKe5fST1aGWAezeEy7kNBWipfuB88lH1/19h4TKmRnZ9TFTvrNc2TurHcOMSuZi71JG2deHmk3qZmeJ2oEJqdnKpZ/XAwkI9HUMNG4aRckfF7e9vx/QWs9KGfXI3+yOwM4IDZVf3tKkF1mjerNLcXwwqUEoCJk1ndUW9DclV7EW3fvOYYdTps7sNtA5+xt8GbaaVbqHLHricFRNfErOG+KgFRdtW4Zr4KBii4zqJS7yyOj+P1eP7W6x/fu3+b1/l8xvn+U9R41rGV45i1bYKHawf1UWAI1ABZeFHQ5WT4iWGKT2vnrSMRKPqCk91ZYhnd65vgWRFcptCU9E4IaCH+iSG0reW+hMpyA6XJukHRJZ0VK79PYpvP9mEu51Pi2Nuk9zr5e9xQEqEO/bkNEamkV3pBJ9r3NGPIjbLjt2tiuAGaGB4otQKn2t3IfcI+GRyUukxzxVhwRSc2TO9YWRhbebkjeojlXyQC0AbjN0ad+ze2R8qe0dfd0ja3bEq1RF+UCyHYDxdn0/Uhz+4iGxYR2Yzxg63CY5Q/H3dvJjL0fsHdGLVDovmnlAyyVAiDAJyzvdUbWmnIndpYIFi93I5ku+vjO6XiJhW6PCcjKCuNdfE0wf9/aHu32M2y7apvzvX9q6svp/tc7HMxPsbHGCzbCo4NsrkaHCdOICACQki5KiLhKc95jPJAHnnjgdwekiiQBBIJ5HARIiASYWREADvEV8AGfD+3bp/Tfaqr6r/XjPaa4zfWLsc+7m6qP4RPddX//33723utueYcc8wxtLAK+txl4LkRuKFkMa3VNCvHdivJcIdg0rHui5xyBIAk1RSNVlwjetpHaXTOuzWNlaJKN2J6MqyvXPFUHaP+yJlWiOT069yoTNAJ6OFco5KOuiZVQlcdFSbHGks592JvudP+f/ZuSWhdxcyJNqoZbCjieg5XYMCcaiitgAE9Xq29X/rmii/tKssAvtefd4+/TRuTjA0xn/uzXSpLp3mEwTIRPFAr6tOrqwkSHVYKLeWdAkTs+DhtgKB7POXe3G5YQ4FceLBuW7LsgtwCYEhjeL/EJgFSzwoqk2kePU0bInVurSWPKY7cE+hdjkYtgwEnBXZtJLyJE6tttZ91yzonu2AkCC8B0OyWP8uu2B+jFTYtzOvcAAwC8eUNIqrCc/xZm2BSpJI3anr3JOsWwGAzByfi1GDK2j6kIpPeck+yaz32GSDHt1sdDG6/T6+7r/nq9+/Nf7nXSWB9880Zt5uODpXwDa8iOhyaDKUtP5EDsg/G6LVakwR7KGTCWFLGURFofnGQLdetIIcpElIkpwOVktp8/xShUKQ2nzbg5Cvb73VZWKA0Crx1m3tzTmPaygAuSlfg8NZRJD/iIrVTj5CP22ZS66CAB0A8Zm+lTsoSraV/vWFMiXg5vmVAu04FPf464blpm7Wj3EqXRhp6GdLpFpl9elS7lvoyR/oKyIfxERoiOvJUdWgsuQ0VVGPA5tAfdOAN/ruMdnZlOOduY+Hwu6N4mRSYiDEJx/LB1pg0TISioax4vEQHWlRb2m0DHXXkDZc9GcOfzxb6hcNNQHwNByVBr1NfaRTF79Bf7aQx8ILMzUhsPgDeRjYMJeHZvshTyYdIMy0UJiTp2AiANoxcZbbP5AJwAjwqaM30nWOF61C3OAK9Aye5oYnERTAxYTCe6Sx1G+hy+7zDoYYVKhSwuK557Zx8jwnwEwwTtB1LtuzHSjRvUh3rIw93ffVAIGkVTYUE6FGS1qjWCuzdSMi085mUUCUxXXMGnGc1OLUW9QfKk33wkDQgGxpSJZdpygqdXvIOfnt3odJ2TRt6Z/Ua7XTZsu6FIH8HJjpk3kEO8lv8MFDZKlAc3828wnbr5opXM+QHLiK+0QMNykra58Ikk1pzWkpv5+DkuQahNo2mFRyEcZeyu8uvjtNXHSMO2ozcyxYyWWiZCQDiwdLJE+qyiyKL8ymqzWouv+vvyaeDaIlEVYs02sM9dJF6Ly61ePtFXAlZF+MPWqUw+6cS39wDQFLGbAFdt+6xDGVWB32r2V4T72O6cPeHvuf9e/Nf+jofxpNHM37H74j4yY9mfOazER9+8bxbA4uxS3PhovhNfAkTPd1r8+ivMr6JvIIYSz6ZKi4KqCHj/O7CTPaMLCeVpa/HduvwPFtaneYKEzx0TMANYL5s5HNs8CyZ5cKjZdi4g9XrLYW5uo4205scMQTSgcsGq5AKaQOKXX4u8MKHcarS4iP3cejsAEZ3MDufoBZu8GCNvjb62H1reXqgSpuuqTakqslUqhyR0dxrBnLUbUiqAzMlLuQETrjt/DIMxHBeroPm3HChtohGwQtBN9W2AiPwjtuQvD97t3FVw+i+TI395CYC9A/213JPRDoVGdtpVQSfaSIAT0ETQMrhNs5ryI8r5EDs0zTMopOLmnLrdL/MpMnZI6RWqd5nR6Rbj/76tU3Q8zpBZfpINad72Mbgegt1xVguhHcFmIB7apxrJKncvJr72tzsiUs1DKTQaMP6hO2iB5lq16wFIcxlR9rSbglsxpwkyecbHuH5FLr+RIENqS4E0mlL35tDspk40lofaVfc9sYt92Ms8Yv+wN7MFOH7ToLUr7+6TRjZ+iHIQdr3iOtMwqlz935s/PsGJ8OyOd4Jz7ZodLytOQwNFTJ4I60/cFc9ukImny/KjGTuytA5b78GRFvgy9x3w+uA/RUaHMwah1ticGZgX3hfBId5XMb9olWemodq7mLKho7UAL1l2GvQqT3eb0L5gBni5njNuOzFKMfXbu/QS7HPhG6oSj/7GV4yhFLClfMWuCjt4obglUDzUxt68MVX5TRadpLx93Vp43qrYv/vc3zd/d8/+Nrzf9df4XVyLh994Yhv/o6viZdf/VB96dGjiHjNK7ntGpdYHQiB4ghp3249DgUYZFXRCmvyUB+KB/I7Y7rc6LESpipqswZvgB2aNK2SVobebw6JlLcV57A6qFwypj98t1oHpZ0So2a2rkyzZTguv0dlRVJ/ZXqHY7H2GhDptA1v9yjPFn/z56dDbLqQy+v7y0SfCnev1SbdLhfVICgbXxZlpyvUmfaS0dmPitozzO+45ovhmHBhZ9VWis+4PHOq6G5SIIS8g+CFdANj1xUN2p4jcH+lje68LiCIb+kEXdOQmy8lVmcU4Lciuelm5eXU2CKr0SN8TOQahi55xJE+8egctPRzuVMI2TgOCaTLa0N+s03o2x2L8uMcZhYQr84YdXNR37MqqpnNYRoUrrvpoIO7vEwG8gr7ODBUYx7PBUPDC3shMFgITIVZJxWhFgk9fCU9k9W3cUkWoi1grbciCB39LuWFwzl85C5NPCkiZoFS8GS2hB2sZ7WtHnYcVsDQs704+hUqbtYWLzYGzTTychgrPjH6G81etk46Sw4nCnexV47u2jJGS3nFqxWq8i5FD+kz7tjxxUxblT8mynB3Lmad43KimRZhqknatGIkAsqFbFnGJYgoxo6LDHySTWACYRtu3TKjT8SLqdp/5CXBcUcORlI30lGnocMGz1lj6mvskTwy6O/kZQ2TbMNWUl13yRRRyvLglACFAfF0a0NBCZZGHGC3wcf0IaAuQVCj72Ev1uQkmgPWVE/EXbSde8Jm7rwOWioMMoeiuiy+fhTz6eiEcrCxjyMfv9G6ZE++8Pi9JQFf5nX3s7eP+l/H+6zHehwznrxwH3//tW+LT+Tn48V6jHNJP/2epZWcmEZizcFKGGdG/RR5jV32KdovcBTKL2ygEpFqGI2Tt2bm3YhH+B0i3cyFjjfHjim7JRmbtQ7acaiNBCygCDLTqLEuuAE4kPwpjwCHgNkoTo7urTRW0N0We0Kfo0ohxck+WrYT3ky5vuDk5KS3AZipL37TQerbS5NbuQDOrHW9P8sj0yQ64Z3r1w71qQbhvYabIyfsNFzk7Pu2NsilcApz4sIJHtmV04DS+qHzt5mO2uRNsL0pSjfbgqRvjR+Xnz90OD1uPMr6sFdiYokrhVElTETluIxdTq5f/95LZqZh2QpaQvxC6XvqAUza44wOM/RieoEJ+mvNBWbUl+koWp65O4AO5KloePB3GCA60aRrbbIz7S2zhqkS6MgUENMmQnLNlszI3bacQuIEBx2B/lOnkZtMXSEdPSNgpOYkLMVIpQ4UNTUbam5OF+A40sb91oKCEChtO12Plxf4YBiKTCB+oYrTGiPWWQWwgIqQ3TkpuR920twcZIioXciXyb90ESMuo+1QH2ZdxGm0J/AGvG1eMqy5tSbuwxNspAudsE/HHB/Nz1BwGluMXmKJ/kdc0skKt4vTLWP+kWs0T5YcDJa9foxMnwU44KJusQxaNVrHWLp56A3Kt/GuDXfvblmbIKy3voE/7TLJX8/05tLgmRdbWcJjXL/ZRgz3+R6AYpeqK1xGQ+CGKbP3MsvtUq0heTLS+3t0ikaWYojIcXrwJ/FYFYHHRpCDQNihthPp4UzySWXejfzYb/xYvH57HB947flzTe++8GOvrz/c30d88LWKF188k4bn/jnrdSq55ZeOePGH/mmMV0YeL32kD5ZhLKmxvkTs2VIHhns9AlhNWQiQicA1e0jsAvaomip5icR7j1/aGmEdPNOMi1GP7uOBX4AS7O6Mli1raHSwMUyqlTrddRqxu+Rq5zEb54JJn0bLIfeKp0Ff10N36hJGusoDK8Bve28Lww86y25ppF7njBGRNXBeTt4vDYfm3A63xSovIeRKB/YvWHd0H54IrDNp0XYpliBRfrP/1G+52flU+YuzTE6TGzYvx/LdW4mQWNlUxYx779AJMJ3wTLx34R+7r3DrNbeVT3fQ7U8fwOB0KQpxRBug7R+/VGG9uKflHfTQyrUxgm6xT4ERZl8GHgQmZFJRYdOzu0hQEoQJQoQZcE1dZoY7PymomWXQKLyPjQ7E5VL50vxQSX05zhF0UoNw9lYRrjE6/6JjI4aoWy0MSpS+vlo4WdcIflljCXbks7MuG12Gb1rGzAT5C7KCWWtmim104EJy0QYow+7t6qDvUuLlwHtfSgBiUW7tCybkLk1fZX3aKR2NjiuXpLzAaFhZv4WHaDaTwY4pAt4oyLTmDS1xRxTpSY93Z3aggbgyw0NVpGgIz4TJq4+lpQj2A3LHqXl5KPGRKFYjcTZq6KO181vJ4+MzGHkhtSg4Tun5GVUoP8xJzjU6EDO9Ey5wlifj+otbr9goaDH9VczEeCbBSMtTssFi81LGPncu60tT2lp0Iy5kFtAPdCqpjDczLrdHj/XrwPnRfQrDcOIHXbVhrjNvOjRy0aZmjwhkPH7raTz8da/M7/zPvyvye//BaZoX4+75ohd3/8Ef/kw8fBjx1lsZf+EvPozPvV7x4Pm7A/tV9xV//k/9rfjOF75h/tZ/85MxH639NKfmaDddV4322bzgqcfIMd67iWXFVt6qHAjF8AMFXuZxjEGlpjNZg8AB222NGybhaXbSPXdaIikcaxjBwCSFGJPBtRB8RrHfMeF22ZCcNwa0baPSpwPEMy2yedpn3xY2J9Zmn9RjG2kl+6B8GImpQrmDL6bzfEsvrEarcLyOpaZFYfJ7stqn1zL1hDgXsMJ3X8ShsicklhKmgKomUIrKSdXt0b3tqCpOQzp76VTU6HITKfvbrmcyprckB9gekpGSuhogzOh76ufCcNTJNZNjhmqxRbs5wfv3hzKZNONj5pULayKg2waxufJoh8UEUtb8QwII+1DsnTILhL4lrZG42uhrXsZ+ZtauEBmMLluhRsndgjvtvNvTItMQdApgrn362/58hPMNd6xhglwK7Qivnm702BVNoJISyWEX4JRoBGmRlP63Ql2DU3UZ+hDYso2XCx9qT+b4HNjaq+1McHrjJZQ1Vp/OkxEeMtniZPQDgoEsS7Tg67f7j12DsCG2FAucqQs0EbHzwJR8fVsx4YykMJMX6sTcAmllxT3aX0eX1es2WH7kOrXcUWTmTStFCab7IEELalMcTIwgmBiW3tMiiUtyXWAobrjoO1eci7Gt2Z1xgU8lkLa//2DTjhLoa62OsqTOtUGzu4IUpz06drWH1ypkby8IlTooNX4baoNqoK8v1yoEBhj3nOIO8cLEp0MxFTnd5POwusVUEWZydA7UDULOm+BETEluoKsEoW0ThIsGo6uYiZVKP0a4B63U4Kd5vh68dBdPXn97/t0/8wPxT37wJ+KVD7z4zEZ+Hq+7b/+t9+ttPv7xiB/8kY/E3/6+V+Ljn3hyQcif40udjZ//zKfj7Uez7kbGk0URgU16qadn7OjNBvDZDbmqEI/rmkoPv5jPV8Zq9nUEssPJxG34ENmKOxd4/1qeONlw2ZesZ0GwanV00dIiYtNkUhtpqBfeOhWIAg62pW+A5Ikv9jLJEhoNZq9RQ5mWWbZNXJOSQIZAk9V98S6HgJhANUg/h4h3YlpsQcPwVlI/ePZMbOZOvo05biapnXyirGGoYmcWrlgBMrIF8FrUACKYy1qyDxePxfttYJXS/Dzbbtewo6TtJHbJwL/JwUJIs8MLxavF9ZZs97O0Hs2nusk/d5LZyO1mApBfAEUjwz8khRE49kCHUCusMw2Xgr3YByeNEq51ScNUW7e1uuxREmdp8gFznxxPumB8J4ZbBtkHOPg2vZl2MlIf0AhVhnmXM2o/MFLRANLm19chpecwGYEr0JrONERoEe+Kno8GbIqJEwJCxHXI/dKEEmOjNj64gVblqumzPyVtU65SSzxn8IaEa8Z7X6TUkx7Yzu0V9J5h1kfbn4wLYgpR4XIACI+oTGnDX4V2NPwj8FX3Ze6jyb6QRgPJzZRczeYkxt68m//VbefRU3C7fWp0urs7xf3fsENTxmZoiG2UBu6Hv6XDOV2IIXjoEkIowpjxCaF4bH2Db8Pj6Tqg+eWk480kIIRqS1k5MaUFNtf0qq4t3STb6/faHivYQOR/1hyqkiDVGPg3Xg5SUEmAlb6mqbNhiGDIZFwEmK6s/FOTgb1yrvBfXNw6Ck+acXny1VqK6y+OirS8k+IbZyEsBNmRr81wWgM8eDGjHj+tf/zXfjw++/Ofj8/tT35ur7vPfa5bNB/5SMTXf+ouvu9vfmW8evfWbjs9x9fijDyZ8Uf/4/8wPv6tPxuv/+Lr8eqDjx0nT6YrPNNCmVHR7QE41pjS1vi68nt3oW5VJvG2Lgi47n9Xx6M40/stVTaF/KVOQxfW2aXi7EVTgODVv+lhR+aBOQRnCzrbSHf2YVK2g5KRwFjKroz6ESbCOElzoHVyDnkoKJHRvBttag5+eSCkSICpCw9Nk/ReQjB6wFjdmGCYPebBWlJ+izxq9lfrGSVranDhQBf9oqZgsoeXVrumpsPhf2fu03EKzppq9CrprwhgtQdHtx3Or3r02XritDHySKgv6t9cEHYiNMqHNHRkfrqyv81GgCoK0sIzcDi9MXg8NPYzx8ZE019OsjXdK+IGrUNKxYltvjzAJLf32AN746Iin7uflPTg5GKnxTu08E0NKSPOrq4D3Giq64mWP5oiaqFoV43VfrX38KSGBn1Tr3UYk5juQQhDKumKFRB19+UmEzHOrgGs8QG8Uik1NdPpuTE65xmbG41pYd+maf4UqCNLoYxIFll0XlcYh/Z2ljZv0m1B6ddNxDn0BsUcXAustWmfciQUvsOldkmlYkilQgBMNanGrtYmaphOCsaB6nRxlGcfTKRRS909jeP2BGF5gLkUAIxWoAEwkQSQ2Q1fn9s+GV7pXeLzs5750RbUXYCzqkG6irrRBcnLEx0D2jlNvJJAbKot7/XP5kkyUa2Jmc3MX7egy84TGD/sRAAdrPKcoSpZJiyIXof3VPXEQzMVAAwDq7BachZOZ0l+CNXacFvWJi4I8AZQdXpwGCewh51Oy8FVHDYIO2xT88bmdrnS0DB00akV1J7RU3YMc8S41f1CQ8dHvvoj8bnPfyle/fDLzz0bueMPX3gj4vf83l+Iv/e5j8YXn3wgXnvp6YVP+Hxec84Ybx5x9z23iI/HyEcR+SChW7XCSOE9IR3ntVSmTBQ2c1oXNM0ObGonswCKS3rfi6JtAAM3sLGABatnFIOepRSklsQv/+7EsTx/KTUmHT0hiiP6q4WmaEkMdB9YKsudXa2YUK4MqmtjFtMyUbr5kzrPKrTD1EbYIh64SnRi1d2cVecsO4pQ23i2wYrXeALuVKvH6S6uCzp0PGJd20VJWcilE6SEZ1ZToxNM5p9f/3YpVt3Rkc6O9sveRGUWC6bHi6aPBv/y2Wx19eSMH6V8LcCfg7HkOOQNvs6HiVC/vkDLy5+DJtUmp810TTeJl0dDS8b1aVszb+u4qjEnJ+Gttd4YGdHAdB9l3ZlvRcaap+XFTUblhKMhy+NSetLRug9WuZpNtZWzPR7h8U5FpGRQJziot/c7+PrQHa24Da0Pt+AQzcrN4eNwtbX0bT19bzQVCMPcyjQSzE4+hC6khnRxsEzgOSyUW/K1V6yyk0k9S6IRXT40WGacJg18bnaYov1EiEbdHNpkU+6sZ5U45dGS0KZhzAAECttYn7/koFRPyJK67QVW0laX+JF69nW5P1TP1jMG6glqHv0+kAOWTWZs6G8qUOvoW3Dqja2MXIXWebR2g3t29qjVpzyv4PCLi7428K10KJHOtkp9zzirRmT6BsochsfJdBVtDvJ8y+hg8wMR0KvrGcMq5yGWLdiILSlFizgidSrRp2F6s6YflDpQMGlessPLoeN6w0wKsUu948TqJ6BViRPQ8wJKAkUduUDBQAsoxODTOVtZP0W+QNoj8Jgv52djn09xpNLDsjmqxql6vmiqUCjpNUiu1bqcU+fDBb8L6NNWaIpuy2oyQ9h7Z7WT5t6YfUpUPL5/fHzFqy/M7/qu744X7//fePjKiPGcJ16cjLzxhYhv+cb7+E/+nR+N/+LP/oZ443bEC3fPNxs578fxoOJ7/6fvje/87g/mb/2Ob13HnFsb1caA/cO5UeXl4E8nHWqq8tqhtPsMJJPkYCskVW8DARAtRlSbzAEdXCPV5/IdE0aUZ+uQGphbxLfc1Q71UAutSjuc7F/rz5qLYBKIVW4W4FhqJ1JO7HGZFR0XQZTsSez77rucn3KT6lEtM7iVp5t5VW1xQnmxOOaCQRjhLyOhK5qNkl2jttjJYBK3YxcFJQK2wV6NMzepv6bQqn40CofGgIG2mAcGoJ14mqxvcCBvLse0QSia3HW9XUfq7PEfzSP3E3YrRbsw9ChnSUKwoYHBZEyfUbK0sjubcAatL/FSJnhxMViVFz7uEoGXo7PsRTWSs1pGK4uZ3eFCnUDBvzErwWKa7kq3IcbUtKVQrjNyAsOlc+8gOcZXCQlJ6rbwwYCTl1BjM0OXnSBk2vTBPCT72CLdu/prid0eYeyJHzpSxYRR0fkQEiJ+dQ+QaPzZpEU0wjr7SxeOAPUr/4ie156G9wRuQG1fCpdF+A3br8JuVD9n9sIZnQLDi6Cv2F0MJUuNJV5s7JJpJs9r3DSDsA/AfrQAQhEMvrjdbJiELq6cnk0SVwWtamRZhQfitWV8uM+8Mc2WipYBrtythAvoyBjThbYgr831rebaP2ubM5rYx+D6yGk+bbieAPFRbh8MRzJh7fGRGUipObcw13YhCMnTg0kKVrDWyJkFHr1kCvROG1dzQqv1hT4tEpGlKLKkN/rxt2NgkekxMEIaMxCfla3Q2BryRqG0S81IC0VIU+e6SSJyT4oPpimnWVtdxvC/8pJpXU70pBL5o1VEXdLz7Od1oRgq9QUZTA98WeB+dhmDtQ1M2dHuSOnQrAk21P2j4u7BbTx98qR+lR8u3QAAIABJREFU+Id/NP75T/9EvPzaC84dn9fLycjtFvG5NyK+/oNvx9e9+jR+7GdfiZdee/u5fuACud884pu+55vio596km+/9XY8fPhS1nFyAUd4eWl2dWmN696fs4qVh7DkZOyj51agYnuNVG9QMsGec22lrSV9VUCCw3xXu2+J79xA+E1tHRPSyjtgLezRqUsAka1QcgMbPi2c2sQhLnS3lS1M6Yr2VEcTSOiXA+SfhhfYhZ1fvqXX8gTNFDZbmK+dz1MnpcAjeU9mLWmJZEAm4UIMpgtUzMxmBOSyU+niid7NQfWl/Krzg1WeWJHvQrfJlQX14T5GWLhv9mirMvKl7Ly+/+1MciD5i6XMPGcacZJlw4KQhtPXG0BybalYbcOdiQntXI5HrX7W/EEd3zdlsI2m+2DuMB0CEhpJapGVQUYjrXh9+dn5q9KM1VJrx3rdoFnTaRr14x3A+X70pZb3+szbOoFEKhCE0xfTyfl5iwbnt7LcCyiSdEkkO4yOdZdVYqtCjN4oRKj9dT6+aZ5VEZv7J6YMBjPivkm0RtMSdCDuNJq1+pXsL+OHKzUxfGgOUZbP/A6YM9X+SeAPG/iRXeVFTdvjtf0BqTbYPOGuJo/InW/zR0MstWBUlHw2j5aCFnWGs0vxwSKWuWVPNZLf93FoEmT5M1I9D6qu0ZOyxaENpD4oCEp68u3OGGEDZy362txQWV7x+Z21KJs4N/nRW2LedK9ljX1uLukg9zze4BTcLEbtI3dPGeNYC+IgW1SCsdpO1TTTZxohiaKSqp5O1lbB0gDLnqtXLd/6YtLs6J5Z7olzc1GHJm/kfwEnvNJJ0UU6KkQVLVuJ98hkDT6/5YfERRzulpp3KgkfyKOTpyZLS/1CIy01lFDqOxBV0rvAm6/NE1b8GCPEEqddlDV3fA2H+S64W9Zexj0SNDmfwM0ntyulJLsAnz9X3U3TIWXDgtjLfw2Iz4oHZ6fmSY0f/8f/OD79uU/Hgy89fx2Qu+t/PL6P+PBHIn7br/l8/NBf/3DcPn7/XD/sOI7It0Z85yvfGQ8+8MPxaH4hHsZHNgXBnVsYcjrlPFDp+OokFQ4ehEyVUsOcdeGKCeg+XCeoFhyaq7042A3/4jyN65gUZqICGBLyv0Dj9vJP6IjNLxBkbBFjyUlvCkq/0PXuYTZp/a6Pute/KzETmaQNvEQdT3QT9ki+moONthXUmxXMGODzKa7dRFIeWozSOgBIzj0eA04s+em+9zeV9xSwCTKPyH+McXQCsg7gG547bsAzVBMGDM5q6wTR++Q0Z6DwC+oza7lo5aHFM4ib4VFJt/JH+JuHKerrrvehRfO3dWAsGav4m/tZdQq8HsjUVMvgrvTjHs1ULxElhsJQI0vL1yj2mFhMdaH6/k6H0+yCWGS95PgJWhdmTglBoVuvn3UrTMOkOp8hYVw4DCkebWzDAsu6BZ1kT40F05trIV6Xcrr5eKOhmkpqpRC8rIJaOWq7k+p3bTWS3uBbvDpAjHp9rP4YeZUpiQ1NrJ2oDhc3rCaj8UMiCpOjq6Yy7bxM3t02V3d0wk/Y2KoqRf7wDFEE4JsGLpJr21n5rFEG8z1ZWz2HFQ0JQpDl7ouIj44lRrco2qprdkLU1oaCmfvvcHBtQLUByTm8IJj3RWi2E0Vt7nWXpiegtf+uaQM7KVA8DcF2AoKc3CMI77mivWFG7GMwVm2qn7LbhoHLQjFl93q7n9sCkJOGkILbkDOTNl3z1KVe4xjOVFqzzZr0TUN8yipqYUXQ9xXG1Qve9De6IRdD3SMn8pc7sqZ7y5sgDJ7ZWM9U06bbnAQz1tDWwdCEBbTcErdodYNVQoawTYGPzWSTcUrrVs5iNczLQ4FPuA6xs7Nct9t8+eVX1vd44YWHzyUnuL6eSUbOW/TZz0d8+7d9Jj73c/9G3D/9aDx44a3n9mHnLXzrFx/Ht37oN8U/z5+ZXzw+02PsDRMqXV/suNGnVnn8vhtYasSUBtH6MYCEDqYSPdXUQWLKBAw3KjZANrpRR3r4CswUYSad0q1Hyo7xEIdmROc45btman5BdZ1rtaWvcVuFskIXZDvsM3CkaZWQIfwlaBicC+Smngzwc+stzwJwH8x6DQOYY4g6J0B707tSaIuO3gkvThOoPt1KBP+hnn4nBR1RDxVj2fFvxOS8Yjf6qQv0abeURbnMJpV2HhEILWAbJpJqJsouoxWYaXR64wIm3J7l9XfiaPcLPEUsSUqRpUSl+TFMMpnD2IpbKy705dcgCgq8ozd9rOff36p20L7tst098+bSCDkwQXY0CL0QjjHVBqFCjayb2KP0I0ucUFWjU3ZyQ9DDbmUdK5SeJMlbgAqXGzBKkHLexH1sNAZZLUgWTagIlNacxQ1JllmkOplzCQEUInP2TPmUEV5P9TjdMA9TTtPpgYZovkMDzqvKOzaTl5FWD9bq3F7UK0kKkXWefIpbHwirBBaIn/h3H52xnLfrLBNH3+MlVkgKMtScPAv+NdPAUy4hqtLh9VyIE4zzW9z6ohcVMppUv3bmiYgOCX/rFJq51s1sWo4yHrlAUXozi8F8sfyCG2TNKe/FJuG6yxQWNUrcVQJ23qADuL7nsLanVsNa3+3gyvrX0deL0PbMyj6UrZwh6yiU9pAgN1F7E3Lmkt4+ERqtuxvGMb2v55BSpfwX41JuKOMW9GlKOuT+DkAtstC1D65X6SQg6tZ00yH0TYt5D6gPVUF98HRF0xpFrTVCM39urZaOJVMdKCEpEz5f6Y5NEYhjocNrIw8eCBNXzLcJfKsaThXEYa30/tUOR9FxVkO3kuOL9oRnpmEIOpwpiSvYuypsmlByy2P9+1qqY4f19+F190vf8vHjiI9/VcXj4wfi+77/a+KTX/3mc5usmcdc4in/6Od+LO6/4q354PbC2mslSpzkbGkg416cgX176NmT2vapdFNveE/DZ22LmUFLmSYs474IUyiIT45DFtrYBM7zHNNRNtsVLjX8qWW1CrauP5RityrYgMElnokz4PPHDoVsYoEix5TaKDNtfescgjV5IjY7dwiLsTamK9GYTG6IK+dXQUkkRJN3B3M0MLTdlilnXmdC12SPoe5YMoSyIAo64JBwLZMBtrDGuDXBMYkvlqtEOhs5hUg4Yv1booJ1XXGrIP/x5KCwDb6oOyDppo1hNOSrdFdKE7ESs2hYaHqGZktZow9Zy9CyOi1TwVMMU4TSujMiHN1MagRrtFdwYyKxiatkEefTaac1YLUtnTLLfaf1pQ44B89oSjElcdk/Od26u/BBzhOPCZhnoIcQbXpKFZIVgIoD7exFq9iVQa/ZIyXhAXeHDr/4taaSltZ/05AC+KJbjoNhiEVTuplzl9G97ZVOTERj1i8OUaIGUGn/v4k9rOLoYqT3gdQEAqyiwvu7hyUqxS9aZxleEvTVa8s1BxyxeVF0S3ETgu5ed0M6UB2axtsWMHQMm53ZCxmAn6EUZw2AAX7+pnfGPk0U/6wHyIpcKRu5yQxE06usnqalMMVwiIB0rFE+hEXG0dtcmJKEbl3ydxd3Gn7SzQT5Dphr5XElbdOV+3dbSxlZu4wqtYoDIKKv3ko+QWylkTFF4vTksRSlkK7h+/XqG4vPdY6+LIUo2vaeMBaTD0x7k+vhuGu3thTVeZmTbEH4rJ7xZOJ2MkYzkymKkqJRNKZhzlkgakw3Wk+zJ+DVUhG9RIze2d9P6rvyKUc2Z63Wzv1nw7ja8+oXd3NVJbqSuJUo3dOceT+ykv9fMhJK87/+N/zD+B//3Gfji4/vT4fd5/Jh90+POB5H/PTTH8gP5+vjwe0hLc1A72vxv1OzJEKmULBlkk9UZ3zML2eyoT06puoZ9gBF7qGqRCZS6DjBThX22HsrARJbcLR83q1TZQzYK3QlPWXXh12bDqFQdWzCZNK0Vqm+fucIpFzXruxkoIGfbiEVjVO63qunN/BL6QbHlIkJxh3wKDgYBIfMvrloPYaFsN1uTqqKpI2yvALNHVxw9hAtQJRgMNuR3nVYKgNXiTi/RBt7AiSBOotnMAU43hpB7KaH7RisPqOBNiTnpnxyUxwX60eqVp8zt/aaFMslmFKQ9xn97C8sF424DAuSmEgiZEi0rWCorYOxDeNG206lUm6fkopSA+mxAUrTkkfyTV2cgm36lQyl00oPPb8uguyQQTkshlE7cqoU73s/dP+GDgbOBg3LI1+WkEt3ktLL5MYg0lgDRHBEPOuWbmdg8tGb8Sg2Sa4plr7zA6VsnYPiZ0bRdGuxK8TjOXN1sDU5fU4PR85+6soq+ttJMGMd9Of9HXy/wKuhj4sOwEf6McNc2OPFYX05I26JWOAe/uC+9vqROa/WoddPhmQapdA1phi6a0yhZMY70pkKXrqX5rM6J62VKvVRJdVtx7wW1wIhGes/ArUepmtoj1dTE9RAUts7mXwWFTJM4SK8KsNAeDQm43xNG1WrbMJTmDWg3620EysdyYi1xlnNNvFt+Shx3Zu7QbrsuUAedPSAVS0cbUr+6bYz/aTJ236Fa8BxDE/6i/G9SGlktIvWJnU9sGQOyb5/E+pS0dufnsHK2/DsLYBqdEM/JHiQbVuIc1E468ZqkNpZQ0cpeAPSGnlW15FWWIOFzGps1TcbqHjmtPQRon9P9m1IjkQ7eTQwPp5O+4W9D69fNhn59Kcjfs+/HvEDPzDjL/3lT8SnvvbtOOa/+Icf44inNePho6+KnG/n03yrK8GhQqaZX0Pw30W1RwLxIkCMAq8DrJMm0go6Bxss/Nvt7aU0IXeQ0U+pp9J1lZZC7p4Zx5sCm5jsUXfhdDg1/T4TubZsHXWNik4Rn0Ta10qNLeETpk6omB+S7CpYGnnpkQZoZTDgG/Ycs2xVumycez5MqXSjoRp1lZJYWpMVop1JNIHGvLZHWlpEvYrhu8b3jzXtY6tKQl8fDV1v3K37Q3NIz2Pqbt7yvL8lHGVNwkaL4CaBcjBd3Ry/Lte2hmLdcQYF53YNNeDlEaDoWLCEPWS17u8NCe4ojN1qP4PMO/FssOlfsrWN2UgojTixRPMRrhInYywBXzX3JxgQ/EyEHdJJdgeVm1KCVBLQcryo0qVK566F76Th0JB3m4LBimT9FXWQppIB3c8PvMNCSMWvW0XRmNsN3gNpxx5MuLRTAofHhWGOoSnfQewZNq7u9YPK2Nka9Uc6NjBC1fXwlkQc196g/lLAQyEHYaZYXiNDZ53wIrnfGyxnBIlBNTCShCe05znFJRHxtm4X4M3nhqhF58lwp6W+CvJeogNZzXYo6d0htrlwzIKwyiEualcmUh6irmkCqjSDpMSt1/qtu3+tujMxPSDp1MIdrE7fExjK/WDuSH6csA7S6XW1t24MebzrbFZ3+T8RCatnclV5mNbQ/lNHTaakwCEpjt+ERbWlqWEQedRpJwLQVhQSsluD+vJFzcp6qmcmYDgvJFYs+OVszYo/qLs1IWdJTy4gMpM/i/MyFmg2btO7V4GHZpbG8NGd7EaxUepKH0Mb/BVelVuJ3nmvsW3udafI/dsCU/r0sY5LmLEzSwNFd2dWNt5HbfZfIRm5PyLefjviD//Bz8WP/8gH4u6W8eKL/+LZyCl69vhLR3zi5Z+qp/ko3ri/i7o7umOx21smfDCh0nMZ4HrNdh2mWAn7HfKUMOLHCJ1+eLtH+Eg/U925M2aAF50CtzAuGxofLtA/46JG1Pb0JE4IIu27by2zVS0U1Y7WhVSnXst2KsWOaYB7cR370Nk9ekLPTBy/RLMVKSwKcD40yYVs99CdnoARHl0s/l2wuLjEQzSaKWG/Rk57uHMVQSDyfR62pAapnE4I6rjQBjV9TP+RFyIb1hpNwi/GXzuszRC2vALPOdg4tJurTARrxEm93dKJ6+kV1g1XmOEudYt7iWwEnmQu657eNzVUi4OYn6hlKhei0QTLKCyxfk57VzN6Rncsay2VniU+JO4sXj1MRScE3V2DWe/sM1VAGoOWahYSVWq64I9Ql5XTN36UtaRI9ad03yxl2fNbHZuxJdCKsmz7zpwRhESEbjEj1sGyteL9dK3TLg0aBniFzIgSwuRn+5TOcETVezXYBFYp6a2hgnpuRUCns5Um2/T64gn3k2UOemc0zG+VxAGGeZxilpGMzq13vLofngnVoN85KHhTloGJ2RDUrjDIXy48FpSK3EdIQbnXpus7f/AQpg8s3IVNO/dOkVlL9pXKx7CJjN1aIFmQsFHgF+OdEKwrIWwCIleQmJ0/Wu3JaZkEiRKFjN5oExFdRQuoF9pcIb5L7YgdSwFBwkMt1GNkJ1Zj56wTpuNDsvLLjRKliGsOsLUwG/UQqcvdbCzAwzBwQmaVPh06bGWBxuyBN0nE1MHvK1efvtuyudmtsm7Y7nGH0WTrtGv39MxVrL5Qq+VYFbDfphsxYUaJYCMYhk61qTq3KnPf32PJ/pxnzKz3Exj5Fdo0o9GRr//19/Hv/vv/PP7633gxPvHxp4Eny3t9zSPj0Zv38bXf+OfiZ1795vnZN74l4qVFZFcislHmxb8U+A7ZKBMyPVYYKehsNZdDoheghsCh5QOK/Tg2PX2nB23RNQUfLB0hBMNV2BeClLYtEA216XOYWDVRq1T3JDjgpOjuT23hV4upF8dUMcOYVnMCRkTreo/SFVW/WytuwCcZyYqFw4xeouliR2tlzsBzsJC93uMBduruwZNbzwnsg2MI8Jv0i02OV55jWRdGK6aOAIn/BcgAZ72Kp/UXtPMZ5OE3kbcXG2/32qRZAokZOLyf4uE0JRGGxHfO68HC/CEzl764LUMvNoOxFfg8smsh5VQ+2tHeDbnaT7DXScMgrYHQB5WQPgO05cesE7svaaTXo0hIBBHn2gkn59rG1CfQ2oKPSa6I00g1oXTQbaCHoq9sEjeb1hqXotvUjdTPtWkEPmZ+tz4uBMCJAmukj35Lp8GziZ8LjQZ7mftNDDg4a+n+FKK7U/EDBd6ABeqoEL7ZrMFiBI65qJDHAmo95W4QJqdzZ/goiJW7fBphwjORdsa1D4+lTOgCrcbC/hVmSy/NtxItzf6y6gUN4aW2kdqIPeDQgHkgZFmPu1xPTZasf384iCW07LaRIfI2R712vjhL7FLoUWpyktJYyliQhIR7kewr5dUazLogKokOc1G9pCMJPntTA3ZmS3noLRAvGIbYjKvO9CekE4lwzWlJiJBxGYdO7gZW16CpFrYY+woMqBdshoGth81O73zLHjR8vGumXP5mE8CWpxdqMqsFqPaM7pHtosAuV/3T9BD5ZtdlWYnWN1cfNERoer9ev2wyEtIdeftRxCc/+TR+9J++Fj/2zzJeepFq6r29nj6dcf/2Lb7j898aL3zk5fng9igqHt7KyWb20Hc35DZRRzszLkfJxHN7Sm23xKTkBCj0jmAAy8837FoQ8kib1yNiKBur6RrUQpHgGVRQ6XnHbi+MuOgqGfEUPYvdoARU45vtRUVwiPL3c7gkNwZtyMBTyoUBe4Rdoukvhb/e3qlSnC9SkKMuKvLoXelOQVaLVg3wiL+b9tLJiS0o2Ed8gwvTGVU5vPrjr+djV4zryYhKOdLD3oXWYtlby/pzikijnpG0ZHJHpU/22O7lJmnQzXsuIYGBQ18SMRVjAlCYX0lJLGrYmzZaOhDslrohU6WTgx8GeEUgOGFHSFoU8tAGefsoWFG/hUDVptmEBOHqYNYojnKYlbywurFRYGKtztS6uv1farvcVpwqCEfbKwAPpuEKMyg0E8atDoPT0rEP0pMidAOXTNSD3S7BtrfImIQ4QnPdmn5Yv23cEvekoboB+wi9yzPbN9WtMlxYpvxeGOMlg/YBxbJ7D/vw1JOGWw+prRFdhPqkgeRZWHskgTqIrD892dT9BWMcwuQ2uHkpjlxeM/0WW+tEBEum6yfVC9Kr4PDKQ6VH2gCPB4utOnZtIPqS+PvpdND5QfaISJJMF53YJrSxTEh5EL1Xxj7Nu7sAL5muSCA4zDb6E6Ga3jDqCzt91sriCncTo+KSV07B8kNe+0sqINFsc/LlkqW5V8xu684OuuncKDj2NdZs7ACbHRe/P03WuX7c74+M/1WGNlxQNPeqtTJJjJi7AHPpdFPNFmRLngG0FG87Y/IZOlRfz5H3GXG3QLoTT3tO7NFf/vUrJiPn6/U3Ir7u10b8e3/ktfg/v++3x8c/9qYrm/fyOuYRj774ND71oT8Wr4+/lq8f/ygiP0QuKwZ4P85Fq7+lazG2hTBl+mrKNvawV+gvAa+496LINuaCIvhtUlE/c2BazDeMK6YMhVYkFL9QvyANgRhw6vp8OMnmQyPwWrleBSq/Lkm8vp2lB9tHj0hfjb81oDbkPDHFu7ST49az9wGxF+8Ml7jdhW0rCCAnJfLOv59hvqeTm9Xx1FX1UheNJ11IoEwaFyR8bpDYbPdd0Da81KT5hD3liI9YCc/GvJAWPxgXp3SfYkSudFQWYDZE8rqUv/RRkBdCX16lNYHgOtEIMjCV/FoDvA3iUk2Rxd8zwEzCLMxlZyB9LlT5lBIVx7oYwREbdIHC8LxSrwy37sF2al4wv7ANcTmkSSYBPodTAlQY1Sz38FHyMPx09Ecjl2ZjlIcd/GeDbWn79yt8pRktnajbOijlSJjui+uOTGjQah21AfTwfV4Sr+wvpzzaqU7Et+699H2FBAnCcWvRZh7JeIoTVUug0/PbJ1HZaeCMfeXNpIi2aBor85xpf4k9f87UCim8c9I1MDTTz3vshtouonfuPXf9wFg5NI5en5bT3wBct70DkySHoV39JOihaAtlFSQ9IJVbGtEQhWOgVuApeM5QAc7W/3Uyf/GliLr+WTQXa+hv1tAu7ET7yUs3w9jCFL+2l+lkemI/8tihKHj6JE1FJrNT3FAhKHZvqx+FvosScLsYga2XA1b4CnVu7GIXv5Sbk+AeYVOwMny2I1TtiCVgz2NnBMO90TH98ReeMFCMgqvpEM5O35fXl01Gzss/iavf/m0/G3/hL/5kfO7zFa+8fFAJvevXcX8fTx7N+MnPfCbvXnty9yCbo7hVAcSQo2vlji9hZapU3l0WCzFtern78mzQXrY+iZdfgKYW45qRTqC+2osxtVdqByUO/6TdXjvAMXypnsnuACaZbu7jWGvGeI+bzPvEULT3f/4SPSjOGjJyRpS9iVbEQ/oyL7HCE7+0g1zwYd6S27mWE1QVKkmDG1gJeNoRQ1zDZU0zdut2I10QIQukA9HkdEtiy2kqHKOOqsnSmfjc0AYawBrT+WHfsqrNzlOw1oio9Q33eM2qNW6rC61kSLU2tLaGScK8NlovydAN/KWE3KyjHsyeru3OAIuE95IEbjSitsnW5bGmk4FWVtc0UJZ7I+ZCdQIbhvgYd6c6ZgmBrsEPOEGJUxh5H3CGcmIn+YkCsfmPVKVojAcbQZIc2gCDnk0Z9NLmkmACQp98UdV7C4DOjeC3Z8BwyhzKKnRfL9B67CvcR+Glc5lbTwstkUuubtLQFM9ClwFUOr0/eQDDwf2y7UWqmoupMIy06TCGupPoHHEQrPs8HZZJ/Dtu1Qhv4nhmJ/fnDjT3OFrFA5Zl5dTQ1j4jvUgDsdQOB/rkgdCOvs6t33ZOaXKA2+q2oSE2W+A1LM7hQx5ZfYseEiF2gadIIhtfDRkHdyKsn1fbjdeLtBgbi43MaYHD8hh+KmFnkZ10DfKZTjtZ42XwvDlf16otsBSu2JRQ1RD9P3vM1p+/5x2DER3ZHvWZM2eiH+vNwnsMjU8I43GlW/t02HlKOndTr4AYoIGK3rlNdzmzoECUa8eg5//6ssnI+X1OdOSTn3wc3/lbfjD+9J/+5Prze31BYH36mR+oFz71xhwPHjbpgPCKP8IKVbeA6itO+d5dyjA5792jg7gHeM5aVesh5NvWBrRQk2E0OOXfqcIaHkMzULpcYd+zJdYEGkc8s/Dg7EnuUuaaUnQeE24pJH9Ce0Ld9riOhGefxU+AWpJ7sOmpRYFtacWgEQOEIXKjxHL6g/FouSx/fdqglwuZXwBhAjnvs9ytyL5HPbd62bEbGy0BlckB7TJzaZDA3ecYMYDAtlPNfhVYAF+IsG0cbYr+XiAczBUE48zPlHP9CLr9HfRgA5UGEIoWfwryHRF4N51KCdbcNCVO+nZdhF2WklCafp7KJXuSQnJHuXxHAOJBR7ht5AlzEw+gXkntclwa3GR6cglRWS0BqjZJWMGn8NEIW7+R1hgLpPqkBO+7v+dXg65SGOTSUWe10kK4n3N+2l7WJNXw6CGcuyRBwBx6w0HV7q4mbD2rTCtREakgxjWCqLTvVFa6FivBkWaDkm4tC+WB4ppSK/oQDTDJXRQlNPRuTt0yIICSZ/fuHe1Qtlc6XUOLoev6Ky8LzgjTZIe249++oERyr5bE24bZ6EB4fTUjadIHzaapbyV00zYnKA6xS1kHAlCEUofWPuxxU0/0WJmJgo0fXnpD7hFHTzqOdn4YE2NGowxb37RNZsXb6GYzYTPav5LRrkhS80HvhUavBgIs8krn0PGtVcJCJHCJ2tKCmkTPjQF3YsucX7vcpUPDrs+EVaD8PhzHN+Os5a0pvoeNrSfh2xlUKsVi+9XlwHF8V+sYDmV3frrmWJHyoE9EuCX9fX9eXzYZ0ckSr78e8W//kbfigx/4hXj86C5e++CM+R7aNedTOJOR3/kt/0v80Pia+cb9tyyhZRFSR5uyFVFT/2fYXCOcIULGTN/q2ueLwTVPNjXfHihO8FixDqCXjnl0dX0bmwFLgMydRJCJC4BGkH47jAUGMDArjplLZjMH9M1kSOPCX9FlUxH3nyc4eeu4p6dTulcgOvyqw4YWtIygO19aN/NYs7EWkAg10eelse2sGbl70B9pZopEL7aZuMwt811CsAaEqa53p4I1oliK5GOTbCXBrjLoAn73w95ltMp3H4UiQeBiieAZGDtAqPbnKae5/eg1xS0llTBWAAAgAElEQVTTzmFY3SMQAlMo2BldcO/fFqNLMHG98WKftl7A6S99RqRbMgHWd3zLy3Lo9/M7T8YbuFReUuI6mtiaG7W/IOXFIeXysSw/x+AM9MMiM/HNkZzJWqmT44udlIrd0liaSfsdywbKTSpgeibD/b7t9wZ6pJR2WHXYogk2fhGyqXqiAZ6ZsqMWPARhZEI50SdM+bxhHBNQSt12MMQCn/zS50owvxySp+kn0A4PtO+duDDMoCozASuWdW7KpnW1RtVwwrTXyWBpUlSJ+SZJ0GbqoCRmhKZjK5xgXwhmes8y+tvmlHRmBc2svxwwNMA9g8EMb/zdl8lLsyQDVIYZQukXKttM5Cmkn6EIh2RgbiCWO6viQUi17qOkREFbQdUGjFtFHNgtE6qyMvgxniFtqQ4rTvDWA0kTMKLcBpXhYxZePFl7K1z696Ksl+V6+vsJi14RftF/+taXwf22ZUy45lI+VWbAB+6Hb1TX8+JtOzaYbyeNNPiy0/Tdw9mBIrc0cBogcfOovfNUJCqnkdSTBiZOccRxuzURYZ9Sz//1qyYj59U9ehTx8kciftfvfiP+xJ98GI+fRLz04nsBas4YO+Pv/NDT+Pp/6/HtN/8rDyIfW85dU3pSd1CzisYcSlSi+fmpkZ1wrI/aR6l4BjqxnONxOnBR5WlFJ0KqqGxkUNhmiBi4RvQk8DuuQlERuyngoo20x2n6LkxEFPKMadj+BgKp1msrRWrAVQ46Rhik8tZT+uTRPmH6k45doO7m0Z6qRU6y3DaiRpEUks83dcNK/vtqPzFnFNem2rUFhlv43jLxDL2v6B4oaCwjL0E9h657TLQ0FIRt6wxh4VqPixmYtuF2jpK0YhFjc82bwDJQ9db/P4Rv3ErovCpRxHZBDVoYug9SdEo7I4jdQQ9Iizp5x4TQQ6+LwtEStHv6RV+MiRN6JghPmSQtpIGnP8COVuwcxhdkVdZVbLsGTSrdRogEtPUBJ1uA1IgKoDXinwZn8gKtRB9eJamVfhLMOWivFmTYpRPEl/STRXOd47r2qcPy0x/nTqc5pMOTqntb7B5eL3lJhwK6Rot/aJDhEioUPLCfiH30aeZCy538YL3TWAXpsdvJuc9LAXtIXQReRVJ1hhxEs96kh11UKLKYT5P+eaZLYt+qNJawqS7hZY5JXgcdqrGIuqQ1+lk1QsylFd1dZ54dpWXTPNb+OpwPM1RQe16GtANYNHIPNUuJlAsfO+i7dbfzTWPYFxBxtiiq8MihyuYIgWEr3SU18K+l/KQmUqRql21dEyzIVXMYX8SyI90U2lUlB01uihhjMxTJ6Uc7icYzHR9YiqNA8KpD5aUHzvnmuWXd46EuZ+swGF5dWpupQlGaWaEh/G6hLbeP5Tr/yubQvZfz/8u/ftVkJDTq+8UvRnz0oxFf+OJ9/MO/W6pT38NLbMOP/a4X8qWXIx4/WTf/EL9+XElGjShdVHljNzBofPZk9PRKjHJHd0mmKr03ic2aXB2zAG436WKZAjlxp3s3l0UDMwX0DieUos3XH/D93ARiMmTu6QjzoER9VC9i6wja35oKdGO9RUq71C9Jq7V0RVDrekrO4m5ZDWVpcL1aoEH1goAJlEFUFg+i2xp14bhkmHUod5+ezbmg08JTGLqzTB08nZayVAnYI/PwWISPNosw4ZKydKz6tP5jlAQSBxmrYyPUk37Pds7OyzSDuivuurjibEv86GYL98fFmVJanuRQ+txqJhtgatCqU0ZEYLbnbUiZGhWrUvDbcRagb/Lv+HH2+liXcSy79T1dy3R1B6j0mOh5c2/q/myZFAlgUUYe5aSoUPVS98ZPZBdVwiDYnJz88AhKrOPLZITwfGJgteA8Z8iQyJNwt0b0pYzlOcrpfVw8P5QJET4rybGO3Xrdk8DkDoU2fJtNzgVDhdSKZEt9oIMYfFqqmTyljAMloqVvGYPjBCxnzI3vtBoLdYDQviEC5QyfTJysPmaNDCa+lfT3g7YXMcTErpS6eAqi6LQ0JUvhvcIwzXpEU5bTsT83EtVH3HnUEu326JRiqyWPSPrNbjcvDdngLc9E8cnQrKYLAsnp1BDMFfusU5oWOrStgwS6KhkwHY34sY5V5YhmtO9wKNXkzbyDqyLQYggkaxWJQcZaeg+k7lmg7JteC6t66vtP0NEtyMtEpNmqSuDCYwOjgW4Ngnt/k4QuIoAQF9BjT3glS3/7hqv0k4VeBNQ79JzVJV/x/9bDyDfLP1XcV3qa5r3yRr/c6x0lI+fr6X3ES7eIP/iHHsSP/vxH4+Mfe/KePvAMFF96/c144UHV/dP1RI9Ngr5ChFTpV4BMpfncj5vtqlgzCew9ZUE49rCa0TAzBgaaJdB2GioBFfTZyLBJAhIURUK5bdPpiBRX1am7bG6JhuFpnpvE4GpG70/7CKkgE6zp6mB3sxIlTh1C1bqfB1k4+pcqjt3ojAujnoM8q6xLkkl5C45ylHzTJTwECGUiV8/su2qPGf7JIdeEiP1toKgEbVQYal4CytfcmkqlCMo1G5SmWg/yKNeQ1+enFIq8VAxO96epWIdx4l05X0aU1KNp9QBWg8KMhVZ6ofNAw9GlNsaeJM2idkJQLClIDM17YYsWu2Kb8D2A2iWnFky0q1euv0DXqr1DNY7tft+GrrRExpapU1VUATLFvEbJxBIRA15FBanWc8FDCrLY2PplmEQO7hkN7AB4bjbnKHnEmw/Vldwli7nQifTULwLnsedwQEds6B9W+9IDcYiVQLtpp4HVApdP8a1AHonfiVG5/tvpah8CSwgMgde1BxSAFTuj6q81RtcmZuMKp4f7u3N7Lz6N5zjf1pQ9769OZ8u+zoEkdYeraeUzKCejE9KA7wGoOIehqgEy7SxMnAbR2C7Vg9YcTNxhmHHH0/Mc1JiyT968DJGXGOgQX6AyOADOtg5EV9mR3NuRXCxK7WsJAS/Akkmrogvfpw8Kd4HWnVGP3W2n1G72+qb4dlgs+TyYxtcNdZcoM/eZhkRj2/4HIiQboduQu7lyGvAD0epJguCUSXj7PUHXY1y71dD3fjpwdg6HQIR+NI58+uhL/dH87/N8veNk5Pwyb7we8eu/LuLr/tVPxsMXR7z04N1P1jx564iP/aavjI//2kfx6LNfigcPXzvLkhHy2CAt0Hl1C6f8QJaq14fQ0kJxhsY/kxETRBYMcpd95eTT6n5jsyz7QEo3JuZWhgiPEzTtYS6/aZ3uGz4Nto9O9w3NG5awhCZZ6mBBT41qSFvIoK/wl85fhzJZA0Tu+4v+3zPvCxpR4j0lJBKmh6f53pt+rm8Ic3bxxZbWw9g0Mx04On2NLhLAFMOdMajCEoK9ntIRPoOtEcLsAd0KASIzttc9VzpMWr4IQeY2xhV9YhYKZj7JVSmbjMLsA8acxtaCsEGEga27wrg8zhRDZ0NSl09rElTVRTDSrNukpdF8lo4kG9lVN6ZVn1YGJ4htc5CHrYZPlXzRR2x43DSQHNKzArFacC8XODkdckMa6ZSgK8Jibhqm7Ca+zUkVPjTB6r2mKO2Yq98/M2ZiZwWOSLFz+GC2NYGpesNAEG+bxqHCfHo8E2Hxa1+Hw2dKuCxFjshxfcIFpiU22ECuYjBWdXqWloJRuRkGrNmfNvVtby42IRosKnDvvi3QHBsCEYx+yQidrAxv/DPnOxSAPVcSlAFL1s5qFFqgRQI7Llm8+ZAhxRZRm0dtIy94mTuBkx6P5ohZSUSG1nPe9En65lBtW/+m85Yi4dbm6IsHRg5G/7k+OEKAYtthCnNwpnarLmPeJKVxqb/4O2ej127JdHoHlUlv0Dn9MmTncfuYntgVGESMsSlQ5IRSadDxdOnQlyOMkUQi7qb18ISZmkio2i6QLphSWGsmbf3VXX2a0BnG4IUvpsM4QPfpooVrpgJfzyA07eU4nXZifOVXZLz+MxGvfOjdnfvv5PWOk5Hz9cajiG/+1Nvxe7/2R+JP/emPxFd/7Mm7T0YeHfHkjS/EJ//Ah+ruq+5OZeI1GJZGKdEkKFmPe5ShVwqObBSk7EviX6frtStmYVrSPxcIKzdPMTCDyTZBwev3J/NpaV6+57IBWIbIADq9wYhpLmr1eaae/ZZubOdYBh8F8rIFZ9nRUz6OzmEWiXp2kz8aYBavsg2nRd6QrKIxcpT7psRLh+YCZDpkTQuJmXKxBBzeQs2Rnkg4v+mhun14cLRpcCUDiKMVUTAtf6ZdD12x+xWhqmIbWrv530n+ArtP5oaCPDVqYYLbEXcwXAcdsod7zXN16FZF6GSmA2jrOCx97k6GdvWj+2vk7jaIRr2xAa1TkyEn6WuK2C82XuyQt5bkVNdrhqNJr88WfpO+7M4GlogY34QZRsZnOjMdLLq6HF05KA61K9KLVsVnOq2zENs0D8bJsboDpS+wcM2uD7Z+I5Bdb8YhAUJdRVmz9rC6EpCYPTm4EhPIIDMovg7JbPP8dH9cT2zoAuCEKnqbWveNHhN7ptoESimtKkPd2Ri4h4gvJZDAeXjW5iu4d7a54Vrqqv0PzWejsqWiXcJlEPmteS5oac3hBqMsjVp1ODFZ1yiC7EzIxs0ly8B8g29XwKYAWx1f1RNpQ8zqjAB/153XMhvb93xaZJKZe5eSK/07dI9BLKAm+SZpIQyR5w5nD/0zC3Re8X1Kc8hafErrbilHcRgUnniKbVF9rsfB51/ERdI6drHhNLcX149I/FkVrSmd6x9vnfecNVx/qzRvWZuC4e+MdsqSdy+SFJsiqoR4BgLiG8KY3T5b1ckhzRXd9jmlkiBhcGE5YULTbO9TTZWrQ45RRCJ0537z0HZ5662Ij36s6o//8SO+8LMR8eC9T9X+Sq93lYycr8f3Eb/pa96IFz494403Kl58+M6pLPO+4unjGb/zd3wiv/JDD+PtpxWv3Nq2qSF9a86spdb2IGDh6OzmJjZFSaCCHbXhZ1nSgusNAMTOsrujrWKJjsIenUvS2lC79cILtKhlOYQPnSPzUjKd0vcrRKc8gMN5gaH9lNvNILWZBunbb0XJdrSDltswHSnVrxgCRhpVTMB7gMQthSwSmEhKR/Nx4ErmxrxJlOhFh9KKuTjdi0Vb9tgwUtUZdoOLEwQmt6uh3i8peSY700g8ikZ4/W7hygvtsz1E1MsVA+CcdLyphaqDodP5QRJblEiaSGg60USD+aapkh2XzwPi6FXZQ0zZ3dtDREwJO3dR1iPeXiNMEw/ONYMu3dkZxESfm9I7zDK6BmTdOdpNZwKUg/YompTwjOlsfMBMo34+aQWYe4nijJhSZVzrF8W3hSqN67WrKC1AJ1342NThnQA4KUANQtiQGyal/K4VckkmGPGVI7zw/GmQzj2oUSLChgZzniFhiuHRAONqj/h8SZD9YD3RUBuucXoDLbXCNlpq5hi1ushcOsndJEJdm8c+Ijevd8J9cP7tMfCMa2dfg3WDarrRVqq0QU6Rm0KxMyyb9JguxNMGbxQ7u5qAFCJDSi+8l1kXKI0sTwCF7qvKeztX1VHpoXwk71NzQ90NyEtbcQ2WK2EuQcxeJQr32ir6PiUYcQm4nMcqD2yqOa7ANgkQQ9o3x6YsUz8ayCYnNtXCILoz3mDfdV8HwhYhu+cSN4+qJ3qwTGt5/EbCSiP5rarZcP/W5+yuZjocgxBNp3JTqtU3KfS0LLxmD20Xon5hin5P6lBubXZOGHO49kWB2Q6G6/HVDZg+oT41n8TGZXtlPXyY8fjtmn/mz0b81I9HvPiBB5c+wPN5vatk5Lyqz3w24pt+Y8Tv/30Z//tfei2+5pOP4zje2WXd359y8DO+45s/UfO1o956fB8vvxw9eDsMxjHNIQzCCgqoVA+L7oliEshALykHPO8BeM1j81TZ3hLtddGQuLqQA1yYyLXAuk4hxGpUpJ5y7cSIU/1F59ByzxH+q55sIgBcPVA2lhOtJsAjsE/XMZsTAYoy3EuL6vyuI5hCu5DB0yFXrQwN4FaYX8/uCoix1QuvLhWOMYQheZ6pccsBPbNbEzU0KQNlE2soeXfIeUj29ClVE7WYVle6NG45cPsoMCHfjZYyExelhyXHFKR7M3xqBrkeLkXjoG8SicInlMDTEXGW/Pb6t8fs8QY8Z2BBdNNj2PdjQodwMaknMfEE6YN7IJJbtnZMbk5DCgggbnxjex9vZEqtL2aZVkPZtVrf+Ka7aeZJfi/tcdrfUPIOuABuUIJuuk91TTGkUtzCjbQzE8X+5oUMseK4yEvx5/LRGHPFM3MoE708Zz6BrbFHG9L5dfOSKJUn86LA/Zlh0Dnkn9ru0SomDWBmzxYjOTH8UMp51TQiISZ2s25E2Vb60639Tes+4hDBDZs99t9Kx+61iTuBk1tObOdqTVil2sadKuvbNSl1F+I0JQoNd74D7cy+/KkMaWWfM/AvzxV92ov+zEW7EyloVpQiaoesISRu/Q8LUwBNE0R7ohhmfH/+0Q9v0cFjTu0Xy2s0uhQgeeuNx+5WOVdIcuUZCBw9i9JI6RT2eZFBKgL1aFcqEGug//y1w+Av+mGlZ6EPl+iH3DWGiKyTTQIen5tUI3EDR8P+nnPU5U2D3awGa+ssUjhcGAFOfRcPdu3vobmCtRSO9i/NAcrFpL11pPT9TDnjaAMOnsmKYC7QqHwHijlxC3zhLuO4j/wbfyPjMz91vt/tnSUN7+L1rpGR88IevR3xB//AW/F3/vaH4oufeTE++Orxzkz0jhnz8RGPfuou7j41K19z+2HiY0+JsqtZzUZvXdx9blNwz625h5TInllpfdDaIb11jfq/RE8YgUp1l3ETCpM6y9GiSFOShH0qd4sVZiy9/ha12QwPOr3JPNfhQNJKCcgW8B2m0qxWXnEFBketL76S3h9DAKXJOHqIZst4dWmi0210TBs6hx6bUhERZnJa+SHlzTalM745ZVSQXE03M5QnAgvgbh99BNUqPgcJJeKsTv4FU7p2KQVNcSKBDloIol0xu05l6DmBPstHDBA7aki0jaSA2WwQcR5L4APoh/K6G9acopAi06r4NA/CUwfnvqfIjEpBD25x1en/lIdIvwNSgPoS4nj0mPBoKl5r8kw3vhGdnXuaW/IPcOYlNxNhQIBjVwGSA40xpnKI7PN6lB1K0gFg52Zg2LJd3RNtgXOccJGbTFwnaXEWxgF0zTcQXjQkkD5mhpkNldZgStL+pNcThmNEXzGKgqem1LM1FDwgP6PypZR+0MjnHNkKcpviSOWpxoV5H44Ryg4vmhF0QXdZ1HvJg0huULkL6aGOgOg7lXLfLo9mNyYvtqMZ1/0X4XnGoTENIy1htnjf6dPPoscrOAQTmFIhTgI5Xv+CLYDMEEGDrWfpxGGtwynY7bpM3ZMTmaeWRAfIUJTMViK8DS5itbGjTKjT1GyO5ltjKrHVYZO5v81QoTnmOwJJfCHULVsmUTz3//jG2kOprNUMOv4ZqFttNEBoSWEChUNeplVnun3Q7ZobtNipkVxOJ27aNXbtOqv2/bnE2qbNlOt3fWlRYSSIcn7WbcWCpx948Wl8JiJeuL0PbZr7+9PArkVtzuD4TsTMPv/5iG/4hvv4j/7YZ+NP/refiLibcfdORn0z4v6u4r//3n8Yv/OrviJ/83d/U9SXTv+ddbvvNj+SYdvcyKVJThKIa+VWkf06aq05pkmrgS4A2efIS+2mCCJDhWxBCgtAqW3ZHK5hUbPeRc2YYCqMDinrrIJTrEWgBqnEWH3XcRZqef4fVZgtkBxl+8kc1NBYHqkUHUk6PorNobZzV7xpLkrPSJvvEmiiNZt2WOzDPXWxWblRq8u0NJEN/pKlDyj9ohS6WZ+WkcsEBR0XyQeyruj+ZlHLNsmjVZRCTYfYArGaaNV2mRTn5rarqykVqWtjokg0GH2FldJQVVpRo/fmsA1fw1g3IyNKZ3RdU+gcaTRHLxAM91Q3ivmSy+dL0LVaYnh44jphqglep1NtaF8jhasJsadDpHzedLzcI9WsH8hVIy6QkP82YCJZsJpGV8RmTqTmiEjuOafpSap7D7hQ2iaiPTe40kn+gHJDJSGlVSs0sEVviRhbX+VQLjHhlnLFjSLtNhmjZWESeniTe/hi/6UhHFNVVvl8WhEWlQ0M0wJhH2qtKhubrZetYeQVXo7egi5BVPNszkKjZ2A461oAKmS0OlTCWLOKDM+acJBF6MiERAWbN452k4y1tKcm1gZrG3ANK1TitqXrGVRRRFDFuWKiFTqcixXdb5XdE167ZEtagXYO+tywcswlE4KtE5VKKnNbYTfMuvIZZhIgXkF6sgrTOfxgBg+UQOnGDYmUsYIVTtI+faybBkt0I8QxWzy/mX0r6Ra7YclzYf56SKtqw0DG3i5zFD0Aru5W89vs/Ux36rIQx1BiRU8TREWcXMtjw+iVRwcOnL0/uVBtJDB7ZNxaXBLW8ngQt/u8vfzhl+Lhh1+MVz/8srOw5/W6+9CHTpn2iFdeiXj8+GylhGPMr/Q6b9LP/0zE7/6ut+L/+sJL8fOffzE+8OL9O7qkt9+8jw/9yx+JV3/9Le5/8ejbikBG0G0JnEHnDlve+jngj8PZSqzXewUPxg8aH5QPAolh/8/sAYbDwGSRrYdMUDSSU4w+aNeGiWVlJOvWD7R7L+aabcCxeSE5yZUBLZT/K2fqkAPMShvW8MLshH0rBEvemNNAEp9A95JBbXRzjDXzM2gmNOzOtZi1ZxKn+8mEib4Z0+JSGJKoWLH8ziVotSway514UoAF57/cN7RRTI6sJLTHLvv9JNgzQOCVst94Vqtm0xhRbRyqzcRE4q29HKx9HYiOrZFc7mbuodDz2oKx1O1YKCyhigNC6BQE3CEhkA32AEnTEWmx6ph4sUybb1BD+WpBSWa5Kpajq7BWDRc6A6uyJBh1du23ExwDOUX0AqYZLqL9fnNpaKKtb7H3zvwM41/kG8SvOP/2WIF4im3YM/cQu4eIeWRfKyQ3XoR0xJg7RwspZyRpPv/UbcwGPj3LUewkz1toajLlWockhRo9p1wukitQObXVVht/wouGBbWufBiBLSHdi21f0ilYozQ0I01/LJUTU2iBgUtRaPG4STlHqlWpaYmiBaEHFoUSMhAHYsooGA67ySiN4PHrdDOHVYGX90/1F9osnPPsMnkXJEY+2FRAcvsAr5Ukz7Bm0XAmEluPREP5Zoah4lhaE8nUzYU5178vBMQgZ4duEbBjU473dwtnhDD0nNf2palppvPj5NB2MF6fdjSt3PlHXaK3Z3okXDcB5BO3GDWqDlFp1D4F1ikY9ub5bdAlkW/q64AFczxDzr2mcbWPn82dJcJIJSX3ru6WlJjta5bXPZ51w5+88Xi+/NUv1b/2J74nXv4rPxgvnGX6zbJJz+V19+KLnd49eRLx5ptK9X6V17k/X/hgxPd//4iXPv1z8Y0PI8b9r54mnb/3pUf38Ud/+5vx6Zd+Tf7cz4/4yg8O1TZ4AKkR3YsbQ1RWm3RqS5D3WWcdrehTGLTtIxTvhHZZnhYtU3aZZkWdgPC54Ny97pNi46JVLvl7+Q+LZQxpm5zcBc+cps2EuxYwPEjZMdOZvMYZejq0OYSqgjW+Ue0nIyyewcPZnYX+E/SUjaijyKeEfS4ZG6YpgFCKtmiFNZRJUDq/aMYb8MzWoBBSMwkQHSouTKs2bjr4cnOod8+zsZIiw28tXQuccDaGQUNq65x5IASeZD8R7bAWYtbDipue71HM3uhwD7rdEnU4sqSwwCUBkqqls/Ngh268m/eA7yn4nGi0rRMupdk1lZ3cgnlTegotloX0nEx+S4jVtulp+wiFrbX6bgoV08gwpnTOMOkgyRgSeuywEtrQvCttrOZcaHh2cR/6mCkpulXyu33eDxVcEomY5RM2NMopvuoRt9niJOvLHALGF0LYk0QLzxQzScQITHf3MMhFJpnxehM9zD20HhjN1dJRNsSMJhEpHeFWhqsyugJAEjT0u44tR3wBMyQKJ7nzTL7qFpcN4vG6Rt3bTVNM3MuEy6IthgjJYwoDUR8Tad8qS9DrY3XcbzkUo3eqB2YLC+fYs7YqiYJxK3m/dlkSxwJPN19O6TN5jMEBZm4o8LlvxF+e042sfXaqSDtXKsxiZ1vYpnVwLTcs3ffz9h97v3s6Ht5S7hlpMZ1K8wrKKahRKeBogazfn20sWX7iWxFQUWLQFow9kbdvUKc4W5VzRwRBS3lJKy2hrIbUTZ5n1mbdJqgRBhVHm/tvl8LVNBnKrXPLM9K9Tp0f03oPCgoaQnOiOejPzsmBIoJUFKYIqprOLfziyKdvPqkf+J9/NH78+34sXn7pBYxGn18yAhLy5Al7/cv/wnlLXns14o0vRvyX/91r8YXXny7OyB5J+pVf909n3D+e8e2/5+Pxyje+lC88PKJcIIVkq5ZQX6uWiRm4JVTLtc5QqbxkPAX7qt1hMvUEHVQe0KzPbilL/DpVj6aYVg2FqB45mynrCGi3aWDDYhkHfdo5Fbhu2zqvke31KM0atQWKW6wjatcroDBBIYSOt4gO4o5tAmE3a3Edp+5lTr/IXs7rW7lBZU/yJlVESNWobEPumZBlUNijlAzpbXKuTCmjez+YAIW7pCVox9IXA4hTX3edorOtenIPh6rOKaw+53p6rm/G5On3RzYHMctjUQqXzb8R4w0sf581k7qDeqr5beUWva6qWaKlpgtDf41tDGecXTxz9knJzHNf0TJz2aOKg3TCIo5pxidVIdus5Maktn06/AGs85lEUzUocnNAsVrBtQ9iLLyE2Iq+9C1mT1cIyG4Ap+uEHkh1LUwjsZVXVly6ud+tKxr7FKNCFYys0vwc65n95+HZY7MYpsewRHGG7YqX4ZawXYml+nzyObX8RBeB15aScSaXA80YGKlBe8a2dvhOOlkAC0tFXIrLs9Y5TvXhuzt01Eyjq8U0SB9EiQSqNZYEdyEZOia+JH2/uiGDztpN1FPhkvsAACAASURBVEO3tzQLc6Z9N3WpymtaDY8he+FC1T3lzneWU+WWoljEkWLHD63SA76NWzPbDse4pMp88dDyol2R0knloMkGHG65T0n+slfZFPMUfiADQ1XnEI1vuJi+LY20qQYCYecY8N92utFfdk5azLhY1G5gTgbkk1Zwkjx4ZKy31KLUb3cZY+NiRSn9mh5DmOdMLpTXCygfGx6F5+T54bbV3BoMIjhf0Jk1aQdnDw3PPWRdsa0n0vVLguPq08/jTt3g+4QXlA8injx+kr/w//x8PPrco3jwodxR5Dm9TGDdM1a/SjISER98JeL7f+RD8carXxtf9XWPYwsXfvnXvG/X3n/2a/6l+NoXXq+XHr0dM15qGsC505T93UKYQ/P6L8yMSUGsAOpcUGrrU9E7J+z+ZtGvpaLJ6wwk+SnBNCO2o9c65fHYPI/cjgUSCl34m4Vzu3xb+gDnPvf5oA6+nhd0JtOVhdWGLe0oj2ghZjsElgj9518cSlmHPLzCd972Ox7Fad5DiQcCfEHGuISEm2UAlTM9rplW1mRmTityinqwir1ZHgrBvZzO9vZD1txroAN78TYUJa05nTfJnAfde9QMpJqsWe4mbGhZKPJLUTIl1LEKohGWf9jnAuFHo4mA/v13/f6onnZVdctbC15r5rJrlBW2b26N6b6P2qSdrkjDEyZLTajjMUJwDAbSh7QaHSWOcX1g9slceKrYXoWouoXKezxeIoWci0eOPAmamzOovnV+2QLLbYAidVmNyrEoLLelaVObxbiu5oiLxyFFMWKSt8lsiM3UxMQ+qom2ygJHa+P1/bETXsBvjc6ntFqlFY55NxpqZUxMsLy9izadcNrdDAy879OigJwl4hymXNN5laNq3IRbVezTobfZkFePNJC6XO3DTCxFyaVdSITRDsk6chIDRcM0YJwHdJxzoR9CXRML3pUYT5n6B622ccC+XEf2JeGl/4qq29Sn3DrpnrFTqpwSpmZ0H1E6pcJzMhlnMfI5ZyGpysyMIopoMJ7cNl2B6SrHh05qpiynaxtWxGZZOGM9VCSNgcNACJSNFiZcexqS3LxgVgEHW0NLjQbCdEf9hCXSVKDGgafchNwWWrT2dQvm1A1JGRtUez2v+ILbhGzvOj5uF8U1uV6baJwCQI5wGTIJViW4HGeOQjioxUI3kIjDw+C46tpzqpusTl2HxNsq1MG9U0gKEejxF5/Gxz/5cvy+/+r3x9/6yz8YL5z/fPec2zTv9hdefjHiZ38h42/+1Rfjw4++EC+8/s64IufrOO0v3ryPD//9n4wXfsuDPB6+Fg8Dcf1Vnx63rkfugN47UivxX1Og3e1nG8Wt1DmuZXBDfs2aSjqfhbichLHW8TCEW/S+7SR3NPmJ3r/IR5LS0g6FPi5tNWHD56CEGiFD1tuz2eRD/KEyx7B2mVwpnySkPUXa9n6+2hPnjpVD22umHZTsTpYaKFSG7nhRhjjxiZEdMaCTjqpzm3fOw9GmOZggH5CYegPCihfZSvgr+DaduHP7MlVsQl6cgU9GFmiqIDJ3d9WDUHwQhE9vSBqoeck2NAC5FGo9QLNitXZqm+wGLBDlvl0EJ3X7amUkAELmpUe7vstNHOLgLWqYeyfqSOI2NTAkQvyyl+1trd9B0BbMNDvAJ70BQRwdLG9doE7V64MsdgOGm81UPNASby4kdFf0CCWBFoh79gUeU/p6Q7xkIZY3fak5G6wQJpT4HsROCyqYIvJstDKENKUBMrPhqv4O+NPaJCR5QuvrWqyHHipqk2kEYMZAviWn9FbVkm2tZnLUIY7M4amquUfCsSpdV9MRIHl8zfvsgHTapKykvCh3TrXUTpJWepOzoK93FgJTY93bG2pnTEUY/y/NUDXkAki4PXaUUQ+Jl+t87R+YJr3273snqRSSrRYZg/Pf8sizyUPO9zDOvaSFHni+lu1BNaZ+cQ/8MogndwhBqGv3tuN+oN5xPoSjU0cFITzuvZftVZQ9W+dcHQhMz2thvVSsu8iecvQ4KXTrDtzLJ+QEoFaeNtVcuU26qGwQd9QsZTsk1TAR5kmB8XkacbfB0XTbmw6LRnzUyOxTiFlcSwIOM4lsbjiKRXq0/TsW8poA7/7RAfE2Ll4NDqZaA02uP6uLIBMHLYW0D4V+kYHOpfrwpQfx+ItP5t/73344fuIf/ES88srDdwRevJvXu0pGzsX56msR//Sf3eInfviID736enzpzXd3RcfjGX/lv/678dte/nXz277nE3H/i+eiXdRmICuwN6f+pr4ZXy7+ttmMklVNLBdCLMvujWddf7cHWGrD9o0I3ERkgCRUJs/msKZ2mudKpIKuPwWknm92iCN0bs1ukERcwLgJ8juRe+rJ/jasgPHc2pas8WpbPJ1nXQ2Vx2faGZOTTn1I0EPJuuVut2t6pg+WUl8JZaiUhULGPGRRQ+8gaaEUZBwF1gkJVrFDg96HVYeha5iXpY51ZRduDpiaxE1hX/YWEnjBa4wyeNM6HqGdjePLeTcOqYVv3gEGNomOYx/DzE1Okzl7qWooU3dGtHJuW61/75V466Rg3fAVXUapzyUIA4pAKdqv/zoKruk4DzHpgaSIi3OaWzKzZziHVSoypL27/Bux0sotxbcW+ADfMHA20e2c4Ghw9zR2uvbWff/D9CEhxwG+pfy49Kgwd8mmhSt9qOyDZYoiMMYFQBXPwT5nu/26tu0Bg3JK+j8NgECfPgJID0df6D5JjzTmmJ40VoK0jo45Sci3lil9BiVAo5+/RmfUEgrnrilPAxbMINvaUNySm+lKNOl46E1oPRylZh98BiCWKZmK7KwanRP0P7Zmdw3EbS4p70Jcp1Z5V+wxx81unm6ymFfgFSnlcDXH5u3iyBLYRrWZWMmCq4hs6ftp58K554haN7G4Gt0/ybvk6kZ1Cj4kPrMGkq5Habb5U9m2sd12o1QB3grpyNBOzqMLv2rzw30lK3/sWzVknBGMxV6csZSb2VacEDVplRx0P224pBnluUJgS0pl3uV8Jo8W6AllbwoyKlnO20zoIjyviCTPDUVafjbsaO0ATZ1JdUcHdHYfp2NKzivpG0hPDfZ1/0UaaXTuhZHHk4qf+Kv/JD7z078Qv0gu/Rxf7yoZOfPCV1+J+NF/EvG5X/xSxCtza4W/0/eoitc//XZ88xfePh7cjXiKuZ0ZEa2PBVG5uiKsi1aCEKZub4fdq+m7Q5loBsZqs5BdCmZVHjiVobZclIY510Ju7pTGY4UFilBNDySAf7Hti7xbb3oe5X3+9cBjIn/UneBL6OCAsjyTpjTtTCTmf0iH5bb5BAKHkt5T8e95aXDh59Tg78r7yeNqTzKQGDSGpBrY3Z8Iy2XpWLAliPLyiabESrBl7XleTQ931OzJg7UBptQb2jVmdkZfTAy09CH9bJl6q047NBWjq3bGOeSc4fFa4WVqClhHYU3hnaVw7DESvkPovTyRcNgTLS82OZYcoKVcAbNl9sa29EYcJQSjj59DWNUzsTIsZzV274MJ7ylI56Zz6TibHnDwhNj0v0uRBBFrrmH0dPxN7O5DxalYAt2j0zytGDk1hn73cmtMf0szVBogU+402mHdp9kQoLwzyHUdKIgFC1hLUq3vxpJv0lhm/U+qM3IR/o8ewKktd2tFIvXfABO1BsrozrrLt8s8D4jRmKInDh24QqRgOV+GGNK+6+Iz7HHQJhI599sV62WIzJm8/q0lSNW+WP3Qm9dsTndSJv0SZsUkA5mS7RVdXDaIcJib9FPjRoa99FZn76GJFIfpjd0MGGr9eRxMdyL0FDS6pAGgtiwYJ1gwhJYkDxM6HSoK7bB048YEvgjsL9lFQQ0suHFYOwR6SHC5o+xwWpqiL4l7CVvySE/FYQ2BiJ0SqKczj+Zy9Astp6NjGrbofaSMLpaXFG0v4TU+LDeHluRJ1m9XjgNB3qN7Yd1q3Fch5CwlkwDThDg/vMrUrbN5+R5EiIIn2UVh4UFWM25GYA6G1MK0Pvo82h/r8c2bGGKMpK1wCAA4HtR86SteivjpiBdee/juDv538HrHych5Cz/6FRE/9KMZ/+ufv8ULH7iPY9a7zo6O+4qHL2bc3U7y7HGOB+XdupFTww3zpt6pTjFxgfsqmgek9xrdClGGTkMQTQCEr8xvzz3txKZoDgATcPC9NIY1XA6odKHjy/ijFviEGaSGbsrm9Kzg6bO2T9qAoYbjuOkL6m+AR2o2AE4bgGrytV2peZojy7kDenx9sa4WS0yUZo27nbSxwCuDcnRDqfumq9wd6/EMh6q5uDRdN02bFVKdahfusUAdxxw3TRrduJOqFgjlEAN6c+5WtdkvWPKLn6UU/+bD4ub+xSrYq4uqgYLyBCGhg6BPr93uBnsePdIMl+DaPtiaG8PrrlPYqROrVREcXjytYe4OR99FcrUNaHAYsorbtuOBljlaOhri7WzrMSLt6ietJXrrHshlLHRhOdWzrhJqX0DiWK2Ltiw0tyfMTcoNAXOWh+Xx4BT0cFxd9BTKDaO9TWmh0iTgaWbqsvZtE6Eva8NlhamBa0ayZ49ZQ5oVnIg8OqwlVpYPPxjfRbJgtvqVglh7y2f3e4bASvlHDe/XBdkiDJgie5F8KPJAL8PIBnjFkxUQREXMGOg4ivss/qLpaZ21DKc/cWgkYEytstFTbTsp6BqDKK6LGyJe61qIf2wXBlKb4JOqLuQTwPRA4S/ac9dtYKmEear4UA6+u9Xi02qCD84tjR9Z00HRX/XMtE8iqCadlerRsFNQTAIJ6/eFpwg0XxWSdZFNvW2azM5uKYu7wRYEHpN9GojsIUiubgaI/LCzmfAKIx1IyjY3JiF76ftCQVOLCLIu8jQVfmOz2jmtmbIinei1IdcaZbXDFMpCNxLf6XmTCMu5eB4gZnXMeuCD/Dm3aOLdJCOnINpLL0X8N//Dg/jip28RH5jx5PPv4YqeNM53f8Rdu5jMbCJSXVQPI0AihupxjhzOqWAJLeGbKcx/aNVNx6O9xZ9th1mQtbSJHAEsJVlFS1o5RdnvhLdfisdDO0fTlt1QXUjgcnw4dOj0egd8Zyq9RPpw1IlLq0AuL1ejJEV893I0TWGWqBlIm77ONAbV9NijwMgcnZesamkmPlOQGc9JUiKoir8JWBz7jJq7t0o8hxPg8BlW0gxnQEoB9XVmAlcaGzMVDq2CvVX3GBRQB0UD8VZPtKeikggo4qyZAP3+Jbv8gfZ4QnILZidVsC0GZmC0XBrBTg+rCnea0mS7NckJ+518ZuqQZ+5+XH/bqe8Ev6HJw1reG9YSW9vfBIZb2O1wIeBjaCilArQd8d/I3SkeFvSgVxWm30c5Dzb+OCUgtyUROl2Q1s70uCQmdqYAWMYKKSgJvsMwFyQzLzMK4XRK4VrW9VL2nA6Qo1wsiJtN+SBTCSpbicIw5G9WBITBdP9H8FCF17RlPwE16evWxhvUhECDZRjIMBm0+2FNZbpQREFQ2F/mBl+dhxkzzSCBSGhc5eWiA/GmJx7uCdA6KmkEeMCVmkTCn230s2cCtWwRlB3sHM9u7OXAxBPJhM91Z/vNf5/ODxcgJHhmKmcJKHGNkE8Ga2YCeraB1N5TezIlNLNnvNC1RyigJ5qToqH2ZFgDzhdlFddIrGR5WDyj0rCBaYc/Xf+udxqQL+u0CJbfkTNVfpW4UhjEsPDZqcZ5ZiKBeAm4hDRLvxS8lR1vNlaLFoqZg4feRmwSS17n7f1IQni942TkwYOIn/rZiFPn5Bu+5YhXXnmPDaOj4otvRtzucp7Kr1sfk063PCCG+H1z9+tz4wM9ATBmQVGkcGXO17RkHt8FAFg/mK1spzZ0OeM2G42sPELD/2vmA7uJ7OkaI3tqvoUv9ezaKOuAeZ4tqrGSFJlO1e7iIKXDVNfN159M7TQE43xM30Rc/sSDySVqWERqMvPe/ZnyFBtkDI/je8jVg6K4ikYXEef733RMQ7UijWPngipcZjOmz+2w0MKemg1j29742lpDSEbnotMoF1WnJYOyEsuQS1HvHabKB1monk4A3FfFTKHiASMgGZ+3q6nUgI6NeGnPahY4XaC7g9sXuH/ekIjE0lHlFCE6GfnMseMgwnvN6C51PsSHU5l3GYzuUfCik4XOdTgNyXpWosI9zfKq8ncP7gqzJW3J7ITCHFrnzH0tiGbHDoBuATUHt4yC26FEpKhzjQ7h71zT8Bt11cIBe3mCIqKMnbIW+p+kaoIlOf+b66zzMnHii71B9vaW/7DE5ZR4igC4x7syEQVLUJFgMLttWqmRQmzfYabUarDomKcRqIVI6wTwLilZ0og9FQb/UjBVkjgiDqSeAL+jY+YZuHXKckepRyA1r4lyyehzpgsWkImscjU6agkTSnMc42rE6J4EkihGbG/dqWMK5TxyZys3lp5/v1JjOnTLdnWoFqlIfSkKSIFIx/4jAwBxWQtDtUBvBdxjQhQUkaSDcbZtrKXHAPjpIpcr5ruzf/NScAHq7X13sWvTSHdna9M9aNaJ/jRpFo3unTVfC/XxPtVsuS6nCtEQEr5aroN1tBznBBs8+4hPXaS8x+P/y73eUTJyKrSeycgpkPaf/adPFkJyHO/tA2+LDBPxf3xmxmc/l/GVH1h/3VXliIaJ5xrjkOjwFL9zQkDsA5Ii+ZlGbSefpCETtwlKs2I+cjuTmSDEahg6K0va/DD89tCT5zwGQYPWz4U1ABgW1ugAOL6g/f8fb+/282uaVIdV1fvtvfs43T0zzBEswDhE5hApBykY7CRgjJEsAoogWJESJf9BktvkMsqFL3Llq1xYFoqwQowZKySRMQqWogCWkcHBMQYMAzPAMJNhDn3ah++tit6n1lr1fHPqbrpnftDQvff3/X6/932fp56qVWutolvg+u9E70aH1r7UCC2ob7tFYnIF+I661xM7gmcgbaR7e3NIU5O1adAi333B1p3QLKlPoU9EnJzAQrDHzPOG+ThKkQNVJGZtUbFBhWzXAGYaC8fvXAwaLk/GtoTGsuEZSJgkibc2IDQaAVdqoPOFyR4Nd9ne70o56FAm8pIG11cH6gxmByRXcD2qQY2viSHd6MQGKtzcOA446Dupmcl4rCcXeWRid6j6ZPdFgXPwIFXNap/TT+YOE9xYqeu5BaSWhM3MoAxu0BFJoA+qQ5XtQsQpw+h905UFaSkjDjAdocE8u0mKPM1JgVELEb0Um7r69InZWqjSBnBHIgYbCxeM7Ob24TXgDxx0g6KdAOX+Tvip5ncOLvh0bm2RUQH/NCWUpUq6VrRS5n7YkOfp+07ZxETCtxJdGQEqJbT9RXL16W+UDKrNxiPBbCKmrn9/pKFEmQic2dxP32Q31k+Hjp0TXkoyLwatkANN44qZAAOnhSiAwMYQrZLid4j2k2J7/lL7AQl+dekvnVe8u2IHpOwklJviLTP/NI5KI6jdcES3lw0uSok/cmmyHQTE/WHu9LSkwRA3vREcXtoipdpOAHRO/aqRV4i8NBm3Fwuzobf1tuAIg/75TM2plNVBv6fw1ZhdpdQS9zNHy/sWEJLKcVb+Sq83TEYu0urXfZ3Z7/zuYR/5mZfs+efS4m0M7DsfXQYqr9n7vj/qm7/ZhJLaAIFtFnIFwyPvnLkUtFaPumPFq0MFujYDwrtRBkXFV/1tWH6LDxCuzmVTBjcgBugHSXftwqfpqXOX2TUJTks/NcqIiy754RhDY2S2Ix+n7o5jRAWzlCC95m1hYgD1PD0jtodwOp7ZCrsX8JJholw6PUc41mHWejd3k4cIrCpzj5AkjBs8BTuJ0RmV08PQKuRhxHgn/H8bM4yNQus/61PeMeiplF0RXtEOByFDOQ3c3YWKq4fKDDARbtQ17VNcbPk2hraKs6U0iGAty04pHvll6AY5hwMZgYkWNKqKMGo0HNIIoAp1Z4diOkhoUAwhB3gVbbheQb5Ym7iCz4queXSJcIAvShOJcTjRyFChCGS2Oz8BdiDts+/k8Zwi6IKXoFFypM5ZnEGkQ1U+L5q/TNsgzldS/IfqwuQUS6TFtxiuvd0YGvCb9YfwOxxiiTxiYNOrxBBT0pQo8fgvcmOK1eya19ricvJizYh0sJU3L24scdQa7I45zDWoBGtT9RDRcp8vQwy5QcttZZttNGISHzaWhzsgOCSE9ACv9Du5DVNEDbHDrtMwQpzP4U3h1PxrJ7i6jq6D39u5MEnyRTyV463amSbUD9FPiRXOdEPbL7X+MG8UAWzEfZz1N6kSE0hFhHK7YQNeO88ozGoiBYzEgusW5oESuBkLKN/iYqCwIFUDZLCtPBRzAFk+CEZAjXATwB1dRLXD6JDWZydjK43uCMVRRbQVuyAVmduckj4ptlIZsoAkRVqc5+xurR8XL/C2/QzNb9WueZPICBbVK59/c5nLGyYj9++b3dyY/fTffY/9wi88b+95z+3dqu8tvK6H+ejV0/697/037F3vSs/b182PewmjshFShvEEXVvo0AHQGST5l1VKpHlX2egLDcdcq+OYCqMzl239ChZthKr4HFndqNnaCHCfurC568+FGsLO4qgIcpouUV304B1sL98CHZ9qQmSuVQ5eP4MTfc6baK89Bqq5F63nB6IBFCPb68F3UJdo/C3DBcRkBEVBvgnhM070g7d6SAn9FIKdA3LRSu9UW5WgRS9j5a6LoLYecIZANiT3Qjhgc2rs+MDnnLIL56hwYkvwiA3Wj7gj7Ai5rg5mZ0u80Lehg0/MnVuH+FGsAxsVBQmAXqmlb67MIdHCUYYRpey2v72RKJOgCIRWAnEnmjrQfntnjkcwDULHbpKcVqYJp111JZxCbEkJ+uFRdKF0Yi7jDgA3+TxO+7vkRkZ+nLdM+4rMESuRTMXwQfVJoY7wakqsKdEBY2k72PmFCMqnIzsuIvI4gYLSJSv6mPmW1c4B4cRBgjfLdnlrwv+VOt3C/vHwg5JWU6GhhMIFETg12DJBFI2orT1Trkc8PVtUhHY1JNtIf0aps6XYTFCpvGEdlzxjueCpjDYmqxX88aW13XpUh093UTiHvnzbeF553lDWXNuMCfzi+W7Lmo0lJ6KaSoLa6Rw/CVAx20yQUhrPVRXm5FvMerfWI+1v4JtY5ISWjW8ZSGFTJdmQNBK2Te4K9rwqUJ9JiuYEX8BUMnZH+7NrzTpbc7N4z0UNKR/HcLtVL8PjkbAOac5sXNuQewUjFuMEBDZdcM8Jqe4Qi1w0+OFlSQJlkjPvS6G8ru868u49mfj95l4vfybs+3/gif34j532iT/+yr/yFZORq8J+//vNfv7n79kv//KNfdM3vfynTkQM+/7J/bSXX/mYvf76S3nv5v6yCCHyezhpI/3TVkqaTRG+2rZR/XEiFG4DNbPKoykfOyHgqzp9axJIAcs0aLyaaXZSBcxf73jHYZtwxRqfaYRemD708l6uep4UW6ifyhWzFvSyQzguF6SGfPS1NNKGU9Cx5RI4AHMcTPU31hwR1OSCE4mYBmSS3iZwHCdrcBBKmaOBiDLo6d3DdqCS3rBRlDwz4EwPgD0QnV0oKkJ8caUPFFsATkpFLJiwGIm8rjGKEF4WFc0i2mgtzNHtY6pZoP4it+IItcJ+8zO6WGKFRZoimWd0iNMVo0ECTxQHkoOiB6LJMnaUOXjd1PQKZ8ZLwckctk613RBvsAxo681RjWNJQzGOEA2ecGIG1dYYa5ML0EccoAiJB6zQKC21xqMJ7Y8OKgh4s3HF/KW/TCZXFbc5O6CbFY1xLTrxMm/8JQeoVsrHYQTdqtCUK0GLUDLjzp2m9aP6DigKOFFbFjbQPROe6x6cB2qEVNI0jtxKcouGxqIXLcQslTskuyiMTW6mAVLbUQW/ChIw6MbjTDmC6Uh3DECniDVWUrEzovsww2FCdJQnas9FXMpCoDYN1/gkpjmjLyUJ2xla7AZjnynCKUjU9McOTJtNmCL3/LmEZ6zR0G3S6qWdbAd2OkcBVEgatXOwKR5EcGuOUVlFyQqOkx3b+It8ruXpAEkvu7BsO+rSsHISPX1s986DouBc2oUBRznwtxKc7CKZGWcHZuZKBR+T21CFuVKiZLhS5u4bp02gJc8knkzMrgkEu/rW2yqcUjZajrxW4s3JMuku9PcVX0RE3v2etP/6v3xs3/HtPe3/K72+YjLy3HNmn/yk29//+x+wF1887OmnD6s3/XW++HVeg1Fu07792//cQlgePX5k926eLkq9CuGE8SpoUtW2S8TjGxyQNxUhEsz2ZmWIjBHidGPrP6uUgW8cxX5kSYEWogw+MAgZqz2rzea1Z0A8M67tlDGofiMEcvzAgawz4Fir76QshSb0oOzX1lvcK0YRw5F1Bey7+LMBil3JSYJhGCKHmj5SgSxmdIUVXN4fzlOVUBF6/eCk9QZwjASBVIQ63WJPB4eZLLyBeY8mgJeopgv9YotS0mF/UR+yWnZOwmiNdfR6HlujsnS83CGXAWnoHoGnqSuLAXAqCeeKuHgCvQu0KjitpjkEljZeQ2gqWao9PamXiIhdyYaN1AM1V+m0x/Pop0Vg+fqvU7Zzd1gU/PHIk9CUB3mF681FerBpHIivQMiQri18WzwDTRXcBEGDWAgACs5B7LqdFUPFMLtoU8P1jZZWSUXCZMKVZPML7agzO0qRYTqoHIdwm6Yvc1OwDB3zDVVWrnqb24S7TcuPRY3jQdKcnIu/QoVDsY1L5pNafH2p6bsTDsDAXiA8kiY5tCbl9pSlTikTyUgw7dHOKWGbGUoXbKplxqOe37PfzSY1VytvGknJ/u+UrIinWHuGEaQbewefrojgETrXqAsGb1WOh5Nyeolelr1xYS5DsSbJbeMDYMb9gbe5ag8mfQzGNc7pKzSRzD69L1WQRQCL9xM3N2mS3LO2aMIOmzZjgkGjhyh5w90B15HWhGFsQ6gJBBl8wSDeCMM2ot7ZL8JKd8SYRqc6lkBMGF40l2M6YITjvWmb4GGDOD+HCwAAIABJREFUdKnv285anhDNRN1iDmkuRaVJ7fkmzvrscPwf//gj++AHzH7tn30Bj+5LvL5sMnJd2Usvmf2dv/OiffSj77Zv/MbXV1L3dpCRPnDTvuHPfKfZc79jjx6/an7zQi7hcF4tjT70wjft2+Je976nO2+s2cxEfCH6jaYbwtLSxqGOIGGwJ+0DEmA15mKuRDUFufc/afoks7q7Pq+XWMtFEtPTaA9pvafkcuyh1o/tiM609JTD5yo2IfJHP4bDf9GfwCY8Nn2nM22eI1v2BQSMuniQhT6hduVJbZqVmPKGIEWgdEvrmZ/g++IREIrPHNBden+T+i5M0gVTecYphswmCes2X7TAS2Gc6d/sgYdpYwcOXSMIssGmerDnRjunIm6O5+9QSbSG6sS7B8BilV3LYVe1KQfdjBzB+v03OLQ/guhu9YzlYJ/dZqYo8uSiGKhaSDYIVEehk6w7LaVNEgV3PSYhghD3m2lwNYjSMu6xgys6MbtPdCS7nFTaqdaMue8tIz+GUEc7pWSxx5QniFFhvR3bQcG6HxSMKPjhbYib4QlBasm8+o5cQZ0IR8iQkKW98zmHg+1GEiOmUzM0P1zhomuXb/TghvdD6fJVZEc308tnYnEi4eNSc5kaOjuY+NEgWYwHS0KSwmYFlhD263i6ExZI9ZrQqm2mU487T7DQWAODPt52sst6RsMXoR1X9ordEeRw2smG0YADBUOCBgpjgDFYTqdmDzQDEGZKzpocxD7NGqO2o0g7K1Oj+kDOOLMCCEayq8j0GfUO+jGp7BzvD79GI/VD3vzFLYXdhZuqa8UT46wpQJ0F7meUdjx3A2e7sNaDsTo7eEuQy7vtarUzC0odTcL3uKZOKXuYIJtgProfxXZUqHAFIw0cr+5FFVutkdON5vNI+Gz4Nc45spP4pzYE4Mue8td3eu1zYR/8htP+6l857WMfM7t3H1zGr/D6ssnIs8+affzjZr/0SxdP5DWrevI2ExFbY7XagPzzVv6Yp17owHOIlwz+PahGpigkxNQCJd5nAh+GeWVr1a5zHa22lA4H/WJAXii9CCOSvOI4oIgzjlWkwwFZRWeD1TuQUHweQG9zWh2FFkuM2qxhPDjZlEqb9UZJ5Jlht4aL7TNLd9oEySFJJSab0T+N383HgIXkg+3+3lFpkBQiHwKNQ+kdlRV8ICxJws7sWnPN8yVl1DFSFYRMRJ3hs1IFUtqdHfx47rC2cGEZLbJj7lfkgPABcFA8IBwcd0ZOH4wTNJCmC8NS3njSU9PAGyTHyCVSiWVJ6GTlslnt5MszJQBsHOh6sZfYHKBDeDzZbszRbBv+Ct40iYCG8Ehub0Ma0mwaGn3rcnuscWKShfcQg74s1L1BO3Am3P3UyonUI60NAE8plofwCZ7oOy97WUFitoDTm2HTyMDQwdbc/abj5mYFiEJCxOKTtSX6CTjOhojLBaUWaUdm1/q5fugWnw8r426swfvcBw8HhFZFSoRKXKZQBCuRTo05mM8H4rGSRmZq8xHMLDrMWi4D1hDpEVs6eZEj0HFqztilQCsSJrcYFNnMFc7k19Mhm56xhH/TWxpyKSxo0k1siMBbfHNuC14lyTXCONfgmKR7PXE2og5UX8GDwJRq4i4x3hJ95uQpk8WN7Y1u+EljdrRwP0xJl3mkKUD4PH+fVdx2e0T2qjj1NOjLjuDswn4ASiTE3BxmOVa9oEfJ12ByOWcxIl5fdkDt+EFECC55nZokhpAgDxqKNVUC8MBjIE3gqS6ySTcYwuXRo7uIeaMAdotikKTxQJ6rO3Azl/DlXydO5v/oR57Ye9/becSL99/4975kMnJlMFcy8tu//Y32wQ/+JfuO7/jc22rP8HW1aV5/+Yl927d9l/3es79gn3/5YxbPdB17rlsJOPmi4Z++Z6kdaji8uXMYdDBWvoX5EcxktkZDR2YsyEwirdKtOnn0RdYo5ZPER3T4Hz0pCVsaVaGQ+CULwhDPKwm5wdFx6rh1zvpGhbSFS8+NwMXrY8O6ySnZuTNrgDwAu44BwbINr+A0DCKDpFus4v1sX63lFAqSe2dU0Pm2Wbi2Oe9p5xyh0hRDk3v3ptbG4tQ49yyg/Kv5EWLwEk9PEn0M266pGtVhDLWCa083epC8/+HYssKpxBLC7IDrfZLNCZ6BSu3QBCYTlNQ+zwm7gf/btwPyklkfQVlE47eAi0tkBQ4J0BEM6QWlwLJvd8ZS1vyZcgBez6oNYKXV4XkJv3Kw/mmECQjPxpRrOy6W4Q1GDDbUM/dsebrAvkAxl3gTJwKTVSG031jC9xg/Drenfy5K96AF6zqaWUTT6wNXXT2ssknr7F6ANJ100Idigpn3Zvi/zuFW2aEziTWO6ZRXEkJWzfrOB/BMjIle3M/+lHMBYeF3jxAcYIzgvM+mdqTBelYceps8hNgmwAWaDlJnJt6UGiE8qZ0MzN6eRQ4byTTC+gz9gwTmwoHUtkZ/sUmHnPWUyEM4VvX9F1HvgmlO6/FKIrCNygYk/aZEARxFoxcVuI8AHawKjD9AJkkkgHne6pHC7NiIkCMlT9HtyDfGkU0ADBPdq0eEAMAgRNirmyaq6IES1qAjUCK+MWSehxep51zmG1LM9dvxoULPn1fk5BrCth6l3OqFksditnGm14SMJHTE8tShsNi51MPKMv19IQG0HkO9UpqjxCxB1sd5ZcUZHnJb4wgWlKdN5cc0RmyvCwW8ffKk8ePb88snBI9eMXvp69L+0vec9sefpG3hG7++KBm5vvnzz5v9yafdfvZnn7WHr/+2PXr46M292xu8bs+0x6+d9ok//E17/dnPZ9y/N+n3ctC+qJegRWAuZ0vzGZm40Aw6G5ykqszPQG9EDG0OGeU2ZzHrwE1Z3YLqyFH+zSdXYkMmU5cyZPdjCC1MBgl1g/8HKzZVhE2CaoeMUFWhRJ81yHyc0YSGmqDpXMP9Dy5fMjRpFBmAipGmpU3ftbJhYKVD/FmYAz4DOB1pUN8xWP7DNTRo1ikpPwsscS1TniPMJHh9NL5HKs42GMEVDBEuTNTup8bWj9OpFjdm8+CYgMashOtF3QV1inFHGiFgFOjomFacvinAF6PDxqvV9cxCvdr5Cmj+G5mOop2iCxXCMrpy8RmdzgiMfjoCABVRTYNr2SE8Vpqn6Dg/USjjbL7y0Zs2J6OtEU7VcOgw6TDLyizE0yRvz2zOuWLbXzIHp2o42QQKNF3gq4TV2ZN2+p6EWpkSL2DtsAtKgS7YTJg8JFopEIllGogEw1WrkzGpJ+px5CqseH2+k3V1qOlxEIUwzADjAX8HQ9E9ETZRZBDi/m2QKRkn66NSNxkSNpPHDzkZUSLb1gavivtEniOwBJrlUcTDBez0vSVO6NOoKbwH/4wJFo0H6GcvTMFc3hrTp5YSdv0qLBW7wtmObWHIutdF+3igFqRhFSr1Ik1U3YUOAtw+K5VOpE9qA5Vs0JaPtEfUNLGFABl9PrZSy/QxJHM5ETB5ZnqWTn5adPCUKFHGrsgbSC1kjoAC2+eCd3BKhZQCZUCCbvQA3jhY+GUOGBDfw8Axp3zZaJ+pKUt2l30j1LsdmOnHhB0UEC8lm4JSCnUi+fxz9+25Z+7Z8y986dk01/X90Ss39u/8Ww/t/e8z+/2PtT/Zm3l9UTJyvdmFivzMR16yf/Irp33oQ79nn/7MW5PzfLnXNYvmmtr7mx/9Q3vuQw/9wUvHIntmz5tdcwY0orKpl+QKb7ihdACkYhL8hHm3AHKd9nJ6TvrdJgVfQ3LUgILZQcPGCm5sF8u8h5L294jx9sNGpNx9I5sHsk/MmUhej8nRXefsVpGKzs/RoddqPDfWSpl+a/3LDY3E2IU9ZeCDnq0jvGFsE8us6cJjYeu44JauO5G6jOdMELVGg6tIzkC72mtIkDEiEW6OvTPef4uKGWVCIzPdmN8Q3DZWKHleA7bArI4K8ken21RhCvTc3xsCPuIcnkQBS8RGaTRR3EBGwrMOHpTsuJSUVjKU7A9KyrcxaQ2mcx33QvMHxbNHm7FFwzFNr9xs8hmddMBRvlDCd+j/fYryxU9gQhIF5xLnMUvPTIlKeJf6iVWRQSCJrG2pf9MoDzZoSow6tgq6gsW8Z+55MqcRVHv/XN3q6k6EmgDnBjmwL54GozqNUYX3+1xxgjgLgSlbe+gC4MEH96v3XADi6TS9WfsIXbtlVAnyMjmZ3QC0yakAlF1342zvFZrCdMuWbrZjpJLJzAuVTmAwD5Camb9CHKW7CRqgNHM8AUgUZMjOaEnwBqo05l0CY/iY8TGbqH/Mm7qyyi0nJxHD9PzwRdgXYQmBRK7JX81nkgGJqyOjoSvRrKZkjZNRHLugHNCpktuEg8qC2H8gSkqETldICLY//4RoghDywifHB0cEgUCeNRqGvY2E2ghTDntOKnY5Um6yF7ecBve02CVCVxQCtlzrd40p3pU4OJvKOFmhGzckQDicGsiLv2sZyWIsXGlP9qxqeHivOPro0a2976UH/sM/9K/bz776ObuNw+7f+4K84Lp1p9vjh4f9xe9+7Rr58pY6Kl+UjFwKmo9+9Mb+3v/6QXv98WF//CcvvPl3+xKvy6n1qadOe9cLL9sF8dxa2Uvf8oGId716PHr4stV9tXSvJ3Ou5KzsposJ38bVtFk1ehvwWcVAOqBVmCqycvoaEL5b413OJ8o0cRRRtkJk0Olky+Von1aq3PjMm2NKf0OUsIv8lBxavvhja4CvjIvXoz4hY+eyrlxTTiyOOta0qU0GxlU9Jw5KLBwk6GMW2oUs55NAKzbAWFFdX8uzoNgjY4yFJUaKt54mtMRp0IfdQwSVbVXT4d2HDG5oMJTSyBERibVcgLWx3ZsBHxxjajeCKHHYvdHDbVgmNpFGykk123mJUUeSmJJN6cNUDx5MI/rvlZ3YfkDBSQGHAWmJSIlhO4G66uhaJEsfJvlL7UMIBPwaPBx0ZPfDlTVrFWzHQ8IdZM8UiW4xsWoLU9b5dMAcMo2MadLn+JOcUKJve1eBaAL/F+MN8qDOcAs6DtfEAs0k4QyxZErR8zwQzVMZIYrdWjVJYewuHJgDWlWNs+WzG6J4rS6qy2LTQEgkPEYOb9+fEHNqDuBuro2BVXK+BOtZCGOYGRSeETD4RRtQ9RLIVjszuAYMt4vI+oFQgyAEglgxzeLYI5oAcfcUMQoCBX2GBYdhF0CkAM7I9Su/wh7olXS2Tw5fkiknpBPdoypJCFUTnID2o9s0YSwKCHSAqNUqhGmAMkqckK6HkZ7BeagNwmY30vwgf2bVTcRAYXZQlK5hhilnmgJDwSBsGJay6dw7k9VPp8HpaPYDDnWQ/GwmX445bBvoZm/u4PFAxhqStZ5gvaSUnBWvFWdttYVpdWboKHW2cbSLQeMiQQJQry9is02FHqBv2gPFFgG4Ls3RDvrbIBjDoNqSXhWpycfMH+ERkT1hWEyjsvvHjT16eFu/+Esfs4//0Sv29Luemmvj60JF/iDsB3/woX33X3i4WjRvhWf6RcnIo4dXAhH2X/ynn7V79863TVp98MDsE5943v7gD/5te+rB6/baxRn58J/P33/wiXz54acN48O7v4juvNiALDd9ABAn3S6ZP6eL48WGHb2hC80dRnt11EsL051uSLPmHCdWQxkd+lfQOFtIGpjkZDsmxwtZqKUnc5htsgNzX4J8wMx2DVZRN7DKpvUdDkNnB2c2nCQxKartPZT9p9XJiQQGKikxFqRgp1KVRDwUNKC2hAGYaGMIiAVYHRVdKIoVU7G3swJcDwjs6V4ulipz6OakUAxFNowjG2yyBaLv6Tw4G7MPuaCgfge6JI3BRsZc/BlYizt04kBiR9gE8YaeD7s6zlMf37tnEB0IDqiFfIF6ymnKMZJLw5tX6glJqi6+aFqazj7PonW3bZrntC+ahtEqL1AjXeUPO5AmBdH0fyYrgJCDAAZTZ8RtFULKJQs6165YI0FqUDxjXkjgjgcrDlVCZA2E5FoJTfyJmpEvxfbY9XxLCq/VV1buQJKoQ6XmlgflHO30s/ZfP/91EAdFaPBBSQSGIPRPG8EqnESBzOV0tg+MKrzrrp1IvCFnC0iuDE4n6yOy+W3F5CaTLVsjVuPKqa99oZLc1Xzi5R6E1I05HAYT9tDZ4LgdPWykGrkOPiNWmdco9WN962y4AVK56B9mW85xClEApwkZYBX5MOkdbzTNO2tEA1YI/djVkTRskqCrCQgv4ZJjuqRRV3jlkCmotnguOoGH9iVGOluozZpI0Ycp6VOAOujyIhOIRtiA2CRLj4YeckDQRUpHLJ7kgrk6qa0JRGfLC23DJ5AkV6WYpy62aQ5ahKO/HbtV2oJ8yh4JHRQKI5N4MBo+XxYBRjdfFsdYn4a/qYlBYMVh/wJDpTBZIabz7gKl4LKFuXF78vg2/8VvfNr++NMP7enHX3zWv/6q2YOnzH70Rx/ak9u3PjLmTjLSg+vMvv3bH9tf/r4/6H7rW4BZvtTrkgf/P7/+Kftv/5sXzOOJ2e1j+5f/9H+z2+/8VN27YJiK86I4nu3Krh76SpSvA0g2BZw9sF6u+bfNd+CiClKneET1yJcZ1qVRSXgflmlN27k4bBdTB7lk+1n3WKEyTuqmbxGlYIyo7EL2uQ/UMzcsURAHCyJv9tN1BScYb6jznRVn0TNNnw9/ECbXjWZ0UZClmS+OXcujDaDP+IpgXqlReUGMEkwo0jNbcemNW12OShz2Cs9W1r0Q03VQ3iy7wB3Du504yQhLukZG4LOdnCsSubDTE2UuJULAaDtXiI4U2xzh3pHButFQ4AG43/twwAKcjohqafcR2UG34GFTZLlfM/ir5XBJVAjts+tHDnBUYht9YRS5ONcyuIdo8rQHe8g4wAWEtxwghzbUquJms1SKtGDI8WA5s9Jmp8z54oZjD7B98wWBngU/ybK8K3O6klbAmaMQUZbQsxxFFJadcazpOE6gQI8TfAHcDtSshH+8h2X3Uiu6afFZddOrNYrgM+GGIYWWBy/Z6zi4ew2AnEVcW0pqjtCBUx/vmGPWZQLv67JzLMVdLMdQv7hnLoB+g5RKB3ZDA6vUSM49ad4aNerGbkN2xVsbPkAXsiwgxDDnwCK20Pyg6Dor2m1P47U8EFuoNmWdliZrDmpL6Rt/smdc24nYhNSZ+IWJDcxxyVhlDrCtLe5IZ1EFIDdQBtXyKMW0f7XVTAWZkZ5+XeOimmI6g8KJk+4CZPTAiERc7Jb5sI3vSMbpWJm01WhrFfMJulrdzqQd1UO3kjtBSwKClOJMA0uuTZ0IbS3K7bWNd5QBVdCf+TJkTJrzkKqYrIQY0aM5yCwyuS1CEyEU2MglQOaYpCp6+q2lt/dMHOczz7QsJu5+V5ThYT/0Q4/sz36z2W/9dhcYbyUhuTnRSH70qFGMr//6vjEX8eTtoiLX6//79NX6Oe2FF/+l/cOfe4998H2v2yc/dc+ef3L/uCYA24EndAXyG+R1GQ3FHUZfsZxRAFhL8P1IX/ksmYcrGCVc0rZiZ/c7DLKTrohDm7lud6OvlkI5VCxdACoHGHXW3axkU4CFbbKtYX+2xmg5yC8p8otpxDdVumIhsaPurMr7C61IuMADTgTq0aLTAVmGAU3u6hDaLUOjqwWp+3NEYPsf9GYwjD6mP0JnW+EdyZP9eirfksxtwcdOwzhRNjW29k46CxI/XTaQt1vOBl/vdRrBMhS04L2iXZLt5YCsbmsu8DM6qTiuo/js5kMnVHvrp6Qr4Twq4l9d/MgjmulQs+ww7dfHvqmx4jghNmr5guzebQ3k7plqbCYaDR2vWyzLWAzBoV87oVXnmWrk/fRVIqQY2bmA7LoBf5XLi2wMG0Dj7gjc9oaLMAJq1VgrjwXOfprOgEWM4NHHVL/45J3mBqKrEF32VVzEcjXFBmWvFO6/i2xoSCoJVznZrWwsMAPzjQcDzcHBHGxdHcZN98lKWHqtb8kJAnqLhQ+EmJyYvz+JGqpQcQVNyiXOfl3/yf1YMPXUgOLVmpNnYzSGm0vAs+Z0y28hpDcpUQmuR5RZklAfmJ8/0rAWgfbBQa4E8apoT7aC84lju9Sitywb8jL6EzRuT/B+jmr2ZOgmU5VK50CddTbAOh9G7HByxRNKOPYVmNEGWj9yWYf+PmWKZATujKhCKWM3fbkSgNlUIMJj4h5dfn5wEUNlNsJgUaIC8afa0pvwvLNmpS4Z6UhyQ3ZHCr12wEPQLRx9c5amEa0OQg/JwVRyrXT6/GGHKpb23xaKsc33jXUUlAf0zIJ7O4oDX+vH++lD7Dg5C4dVy+IGOTuHz64XOUvoyZ30wz3qft0p+Ob1+qtuzz6f9h/+tVv79Kf/dLlDXBN4ryTkhRfMPvShZT9mt7ed1Qi7eRv/ZG9+++EffmTf9M1hcTxl737v03b/qZtl1g+afXsujCNBP4l1G5OlRom7ahSCcvU3W9BcsYb8r1KjH+IQNnCKmDZXB56j/JAyuivabMRk418TVWDfT079QlP4cIk9e096baEi1jSORGL95huRsK3D0X1lwl7eeDQIzmgvIDi3qqXDcFPSA7QMmqzs+klBtCAUrH4tUrXAPSQamCxDjXIb3KPCWB7k+0Zwlr5PZQyHWQK0jJlHtgUV50RkR+as1nbSBEIUKyPpZxVZ0VxLHgcAOHXFZHR5A0VVM4RogZ8FnFX5Jy6dni8c5ulFKsOgF+toD2Z1PYYXQbHLoliMTYy36eruSpP7trJPJtIrAAEGYUJTsI5P/FO0X6CMxDkQTjHhwCkpq1anNgCKitJkVArjqzvjkHkwpEcXT4mRK45MhhZvsYbMRYtbTKaNO6a13jsJ8K73zNElNMtoRN8doIGZ4dKISBTOdyzJtaWvZXPsaw5yRrHZMbyoj1sJQXh9q0S5DvYjCupzhPZ18Hf9dgScYdEPWKr0XB0npk64hWlpmkXYy+8Eg6EmXeHjWEUX+hDqiJQDp1MoSOWdZUq9+vTupd+Z6UBMhvgYxfhnpA70HO61tzrhxELsyqToMkENelIeXsBuClwnuMSkk5KA380TlZuzc9deuug9J1c4hOD4Tuw/JfwrZDww08J4iBXLkDSKpXGGcpAD92L326NY3vXdocoGBWHXLIh8IfCnU+3dMaXP8qUxd6T8S5PVMjFP6ne70bwc9ImROOO3mjhFz4DC2PKG2XPGRwWgwq4jcP8AcZqOgn5YAuAy2TelHTJ7sSOKoEsNM7QLyTtUShDytAPna8f9ELiaED3EmtKSoI/lHWtF/s+6b7duP/IjT+xb/qzZZz47+QOzyzfzz82VhFTBLr/MHj58ZxCR/fW5z5l967/22L71z3/S/sHPvctu3/vKce+pi4Bxr1FfsRbAF/XO6wItVioK8NcNURiWDw95nOz9f4FPXjl9oNuq/k9r7EjtWq6YRYxucedWog2ni6uPH4TZeNC1CZieClvlYwMEL2tKquQ6RjCQsdKco1GUYqELEBJ79o04aEhOUBOnMdvOjj56geGokXHBrVoEZvDpPe6PTQaVPqVTkYi11p7B1ql61brTGZNJk5ce0DoyWa2wsyJKGwYjmhQ4PBdaDLoTNFHNrcP36uWduGxAqeiqb9CwcQ8BfuryN0BuAMcuYCLW5WPOGIum8ATJNNMJJIIlgmfJARr8OMzXFKZqfHo2VHaUm7A2IjVK80cZLumczVUKSOpCPLIL7lBPo+2KkSYxSQnm+ODvy5ygWKiORFeUevUZwek3KWIMKGDR+w5eF8BD6jJgT6NBQrGJ0wTcRpxwgG5s8OYwddcv5buS+FLBZeXkyC6WSaNWpJsb/TWTPA5RApgNcH2s6zmRB8ZglqsVFDAdSaR/ULj0Q2hQp7bpc9oE9A3scmpOeYdNjOGKiHliXK6qXJXeTbg8VjG1mnVOs3dK49A+xCDjmN3qKOcrWLJXz/El0xT335jBgYfE0fogp/S5jYIMkItBjr0IwUlg2bbr62QrQKUkbrp4bN2vXVyzcIxZ4K07dsEtmcy4QDw/zswIFwbL2mRxkQI76Do9zrFIx9ipJghLJmC0aF7ki1qW99guYtqiWXpa1cYxLXCjGf9n0CTcZQjkqf1T6Hd6w4wAM0PnB4G3IgGWVMGSeyOagXB2rYtcJTnkSlcDvt4TyoPnTxPmlsWqIZzN/M4UDk8SYiIOOnNs8cCceGTl0XMjvM4TFFjmb/16/XW3519I+8EfuLXPfAaVHxVHeMJXB+aNWjY3F0+Er7fLD/lyr3v3zP7wj8x+/+PP2bPPHPbUMx80v3lkjx49tARGFWln+1A5qH2XITP2RNL6RnDrMPgIoV2GOUgKMSZsPY/DMZhQmbSarnA5IxGMgZ/rPpGcB6dJkK6irMS18towChz43hnZHWGdRjCEupyY0exppQdVCcljpEngVtMlXWbgI8AhmJkyJJ7nVqZuVjdW1448i5vbSNRbJxs0I6uPUPQSqaHjOIAlgy6Nn+zUEoNOTnWq8QDHWW8ocJE1kiVzKYdosHkii1o1hqd6Dw0+4EavArIBrmDTE/cnFhhBWRSwyp7STMxBCmu6lNimlFF+sUHX6n2sNwZ/NOUF2ec3vZUdXqKrWZbNT1odmxzuTY8lWu+kY0Q8Wg6E48UusmRh/ToZL0RH+h4cNG/ibP0BlRUCjNlvcmTt2L+i/dc/30ZIyw0v0aehWKkB/pRyJMd6Apv2+rKRttURyIylYL3sU5MOckkvDzIItJUS6OECqcJAl2pbVz9jOQCQ6EpN1XooseZEHiQvjcH3PF9EBogxlrwWjYweJZDJfUSbXDaSjMAAji7ksnjjwE3Q/S0i+egV9HdtlrR4KsOEOnBSwuaWMnU83UIyDqoh/XfJ2O5e4gojJ6xcrZQ9FMDLnMoF3QcFCpZoaLzo+TltKtLhNpbjCmQcL9WPEuTZE3DfJKgwGKQ/gstPlwTe5lStFHC1wBldA8e0yK6rbYU8dmUvAAAgAElEQVTg0WuGcwrS9cgDYGxbPHUQh242Sq1xFK6xxnV0+YA2ldNnTkKBah96poDs1ocgGYrjAeZsG7pzyD3F6N4J8x7O29DWPAHGBQsQ1NJQaLmN08MGsBNWJbu1BHy7CVrpBEzTVRZngHNx6IQEo4dFbbhatV3vLkzwKmy7jb3CWeyEML3u36/Vpvn1Xw/7gb+S6qwYDFQvCsg1+f+N8ovFZeY/V4vmnf7net93PW/26//vh+28/Q77tm/9kP25d/+b5zPHi/X49uFKImDhZUDGLzTkNCntjSV1o5kScDgF2hWbVzF5IoY5kMu0M7EzxeUmoxkEy86x5YF5MVjWbb+mIaGlQCyyqTzyJnbf7nEfn6mQw3yeiTdJc6pAa9RphWJout42TSnSvFI1bzMoOv6lQQC5YlFwMEKXOsmPoT0KJfjXo4fvDYGpSt6/SEIWBvpKtcmgcHjU8yGEnq3EDoXqlIEbXshxUKJTB9RSFX5JHrsn6yOcp/MvqKCdGxF7EoyKbmSt1DUB3EqbYujtQVRDKrpTKajzUHrnpopRbVuIL2tIWHEGsa2+hWOFrRsVPGkJ4aOjPExdJ1USpKea7IGnOnQkpbWwkjoUctfBRCeTSHZecpFTOqojYtZkOOI9BOzqCw6S13sVPMZhpVvjWhJ8rIulUAb2//QKlPUnB1kLodmIwehL5mW2UXlHLE4l9bViz5PeotohIDyuhgF0L1h/Cx9oU9L2LQwsgyBXkCZ+V/IGbp4hkeAgYuhuOiXo5xO0hFidNwxyVmGsRIJQCOFzDPTrMO9kd2fjsMBvz3Yl06ylvugqzh48T3YFr6tKEL6bS5gySa4oCpwlxUPTkVRjp02YA5OEnH8b0mrgwLAlrp4yAqOLlwRAgjFsTiOkJylf1gRSh0LkotCtRddTX8Fsp59Cs50vAs2wKEC2RXc08J41kRJ2iM6ScnVCjawgFyYItgOYv/3eREJga+M9Zq8/YCVFhfaLSxhf5molcjYAcctpurKhbbT6M6KzoB4HPCj7QO9vN2cNhyAcgOEotZqwOlY6UAUB1CJBixYUJC6bLKw0f5zJqMEhG6kTLRKOBWylANYYWR9bZR0+n8i3x13/3Lvndnsb9j/95H37/Mtmzzxzty2jhfMG/6w2zVfz9dKLZv/8X5j91Efu2ePHv2uPHz+2X/3Dn/f7T3/CH8QzjI99c3sSaibIV8cJTz7vEvHspA2BFj3PYBKBqqT5Y23UyBEbgfasUxEPgyZg+iO0jtJc4GvPnANEAJ8c2YXBw/4AUbuPZpKRDB/C5Am6s8OQbDVVrQRX4N97RUsQfkKyJT9dMl5s27+6hiiSndgsOpdJDj4uwZUGhuDyQ3NsHSR5leLznVx1rTiYLwaUdc0rCNrSMYPKkjejTabjg00nlQyoWL1bdTQcLDBpYLstz7UwJBosoj3pKdJYDUSWTER6cwKKgIEsfWV8GCFBDNth6JY8v1WtUVoQkZrfxcY1qLTr1sZh/ID1C0kbsBi/2JmOpuERlH2vFQvJo8le2MDD5IwkhE9k7y0NdD6rZprCv2C1vdaRrS4Tmh6uSUvrDQJO00REDKWABFjAyOLoXz+NzjxGq5l+TtF/kqYYeZWhjQ855OT0CWlq5YUOsHoGWA+7FLghc5ToYeyHiXnA7Migdj9F1i2m1IzKJNeu6A4+tunv0VXtFekU2zSTZHydFqUbCVj3+3onU32FLLDEaCSY4iCAgmaPyJ6H3cLHwbuvG1t2UAbdOJ8eOJKVdAos9/kRlVnkgqANQaiGV5jG7NCSlk3YIVLnSuDDmSdrHGCiEdl7yKgsbEOSQODKGrrqDNeNNaEi6SuPZRwrEQMUoI517UOrz65dWBct8Ftl3qDdIuu1hlx0jeAkzwLtNFZ9crZYK2tcAtboLM/WKyPTIKgwmvX+uCCY6orv3ZfqhKJYIVabk3VVC/Pt1SYCxpwLyvdiL8WoPkCEMqds02hacEE1O8CJ6s5xAiE1wngKkiJpRYGBD4Ko8P4x3SymlihaL4lnXdNoAnbbm/HAndf1hs+8K+33P3rYP/z5w37sR0/7V//qzdvA83XzN/7G139Vk5GLIPvxPzjs9c/f2NNPPVy+9Z//3aoX35+3x/MgV4SL0KNjFu5khbGbgMZdY+iJQ6KjDt5YMVhYzzlokYDpgCBhDh1k9FPdyLBK+i6u+WJLk9ColtOxq+TNkSJIeGchlMPCLvF0zoZtXxLU4kXDtXTQz53AzpYj0T+oqPp3XrNhkFljx2k8DDG4AQGgnLxO7qXOyIDCV7V+CV2VVpvwAGFNxxJCjeeGwgGiVKLRGwtuzlbDEfTNJo3pIBCPFqyOjm2gD0cfQ8karTf+Oe7MFJWUhPQzUbBwCFKsBt1RGufm9/1PFiSqPk+2dYowBbT1eIbZDnQVcLJgKY9j5lo/DSHTK+E6KJxGWWyF9xkFMWxy4lIbJEj3TOqtqP4g4ge6MiAgrIaaGByYk1PdldpWQHJYRyMfcTQFFcYcRSJuWct9QyIWI6MEzcGCoosqMuZ6/fcp11Ka3TSwCxKaNFKxdwqIAoCZyAIC5rqkGfslToI/fzJ1v5KXHOICfT50VokMCd7HWd3xaSfKxBmBIMNJfa0bZlbCpA3tSahLxjd3SFDJvQqGmyQbZ6f1PeDi6EUAqwBwOjAvtfkqUGQZLhOok/U8CqJDUaR0cwKiQUgOArwAXyTz3ikQzlV64VuBdBtDZEZXFcqVTBzwyLrW4jf69ID4vD/JVgSHEmf8/gLGzsWuCIOBLOIbQFCuf8NqVgaPSy7rLr2usA3ydK60fgoxJdoMw4HwgeyQzLDYE8KxMric1mc1E7ySTcuAHz7rSFRD4E11fGh7IONkGIMJjRwi1sGDgO6kILEXmMtaJjo/wGS1Oulc4vJuDBwVuBE1/TCq5YsqHcx8N2Sl2l8GLjNXAOHHruPQ1ZwGeyOcWSsVqUZMXPQdtoK/MCmJo//0733knn3/Xz7Xuf/oLU6RuflH/+jZt/Ybb/F1WcI++0zZ+95za48f31jcpL3v6XtmN26PqCMFUulsJbP5Nf4FGNjdjJ1Eyr3OxYWjgD9uWqHTZTA2+RC/uihdUWTdQOx+/C/P17Yf0IbVOAP5FGGG+zoMTjragY+I2jsIkoNsubMEKGzpkY9wPw5E/STZ1pb2GBPMaPjggI4RkuiGs7WDUH43W5rKS9n+yc9dql5CIk7+b0KmAWWIszvZ5ZUnsc/AVLA2e9q6vuuvQPFCxwM2xzB5cBMqvhmL4aRAQZDRA8xG3u/qPvX1RXJKIBRJeES3c4tXVImDmMC6wQm4/2jPzP5MHJcQszTQZe3jsSauDw8DNI7IoCk9ectSy8zBPtC+OodGM3CjmIrJsNF1TDkPI3tjdUAJjJNCGRq5hlDUnwkQNwjgpE8pWVyAitMCGYTn4kwk+UEjNbjWkBMzAej7wovF/el5Ce1wJyEFM7T1+yF2L8lGU4y4hqrDKghkZsxU7KsGq33suTibG7SYxvxTxx7gmflh0wKl5oDYojw0MXgFBYSLVEKsjlHZiyFonhxzFGKJjvVV+zgQ3gL2TiKQUydS0A18YnencQMjXI/ajR9JcFE9C5Cm2zKIz9qn/alim4QzcjD3K5gJXKCvtKpAe7wEYZo0CMPXv3bbolDdkcLwYSj+9qGYsEvy6Q/ROdvo5ghKtIEUg+cBnxSQsNRTUjJEP6lr8a3FTG0JMzhOw2SJMA0OZgC9oJXCp4YjmAg3CecfNezLVCh1IeOwrEHo4NQCofZ4rym+kL9Ht/BEm0ZMhT8a8nqVC0T4wG+DmXkVKVSbVcAMEBUoUA0dXhVQItwrXfpi5khe6EjZxz562M/9/GE//mOn/eZvvjUxzM0L73v9zf/023i9cmt2m6fdVtrLz6c/++DmuGkAg4NJHDUeQAY8CCW0cJwGiSC4n5vo1nl2uLa+N6+HoaK3SI8q014spj90Rea0Akw3Z0XHWD067XWTD7a2czqAHHU6BAimIYxbEvU4jZBQ46L66MEIDNxblDIZVDkMG4wqKCGO05FxDeBvmVojNM2zh2ztwLkJTWS6AkMgjvdpIyYpiAXY48EuF9mjSDIksKF1QKmXyQyyVbQC8RJOKG2nxf5rHQBKelgemz29uxAk++97ErFP6dDvcBico5i7Nc5e9Gzoc5jbu/MsP0FybAjTGsxvxg2+ZN++uDxBHQmzUl58Y1qyNa63UT/EQZw4ORoaJCUS1GgI50Jcrth5dPhKo9Id6bGeEG0VUOxYU6Ey6VmgNKIzfvihGTgIcO7oerfgAGSC/buNJZ+BhOLL2ZjaVQ+G+pKhiGMcggIiznwDRcZK36+YnLvOVs6lvloGPZuJTXYd4zoDZ7v3jqZ+IthNYKppOpZ51hqkcrWpcwsEKLwhiolk54NAUpLbS68RTNm1ub1ktt9t86vDQMSgCCixlvbKkwIkl3/NalwVn55xbRqNAzlwhgai3VPqQy/VR+SBqIKl73PTppxAAHpdwAFS0+BQPswsRo4C7z5sUA7F4Csoe7GdFNZkWDIYAEtHNm6h1few7aYp1rJ73eUSL04TfGoYF7btPxFdizQVZDIuzEQ/QKjMTHNEjVVLt4WdtHBy22iKNFKdkU3QxgwU5ip4T0aX5OQDSetEX8Ne06HHhcYCUzuUA5w4waxefEInVWpL0ijjZZaEFo3dW+xIkIgCBhNnPb1T47/wFT10zX7yJ+/Z9/yFc9mFXEraN/uKo0772v2T65+nnrxqRwpFbzX8qt7O1q66mmkq5LA6TSt6TaZZFC/0wy41eEIyjeFm2tjF1sr6s6uiJupSBBWDicUcLkQF9fFECXmKJ5mQ275i+pLdcx5Fv82mCTQaEhkownDW2aIa7P1Au3P0+gSKZiEkvTv3P1XTB8RCB72wksKtDLUGMDh66mFmQiBu9KRegn/aJmyWUMURZydSS3qG6STAepO+BoS5gAooJjtsY6aZCb1HIIdoHxBRPTEPg/e8SZSn3jaCyFhI2aGDNVORkYlr4n3I6xCU1g8tqNoyMAIUR1ndzBKBBnk7POZk1LWrl8al5jxVeD62cVRxd7jalKiv1emfqjrIYSOZpvjmYtdXzbYycFCS+fECzhNPOMFucB0myz5J9xx6Z0a/IbTqaOTc2KKeeUcQgk0lBTYlROKC7PuJnOfzBEmS6lbnI9E+Teb2ZFBDYZEKoSIA6iWhZio/se1MRGaZ+OeOzQeP65EnJJNl/uaBMpdp8fgE5AQOMCPJHYZ/CLk3rEhgib19fu9/9WcLJEpBTYVpS0i3OEOChyHrnX62QZCzODuQj9da9Cq94sSYdpNB2XaWyVxoRzyaqbrmIyg0Kfpic2RPvmFEnobTHnPpr1Gz/0neZf6Y89QcZmBV0GMm94dR+LiQ9BoK7eB7GmAHNj5i3ezaJEcbA5WK+iFmyIYxingQvAhOqtv2kr5zSvo38Ye4NRO7ocE7KTGIOxysBbZ4u/Fh0wYMF0tzqNBh4MASqgiYrXDsDxndZAMpn/vi/7n+9rkXzD71x4f9Lz99z979bntLr5tbf/LWfuNtvK6q89bLPnfzWXuXP/ajnoOoQk7HHT0CNTWn4Pdm0xFI2IyIhjYIA7irUHOkGpQ0WnH2iNN9gpY8yBNKOdKUXMCnT3JRdfBMZczD1VznhlHDIPOdjd+8ADehf4rKWsi+1aR02uQpoFiK23Dl0wE6TWlomnHoq/XXyZgDTjUrwQ0UW/TvkdBEhgPYzk4b8bNLZyK8PZR/K49LUYbu9Qk/P/49cy5vTmGNy71PUVasKdRXVvuNj50no5PtaWTBXp94tGxEdlSCUrWltvKUTpIKfhzxQkpfrxWfIbKbIyrlnkDqiZZ1BOjRBpzPywOe02CYmeQUocIsYLljW4HaQXWZq2JdIgkD4y132r8GMCsIaS1aaeeUbsUk4LDthJKKT3VSa6ESIpxwXAFkpw0MNZKtVgcoYFRs0IN+jpBQ44GAFvANK27tdmizKQoZw8f8pTamI/XKxcGMrcReeWagL9ARm2NYaQtxEruGS4/Yx3dektpucEPCW2tmYePk0Uw3GhzpsfRm4FnH5GRbDpvATX8e8ljibjum/L92qINpG42zjzZtzkYDcN80rkPSU7Y0TMQvEYKbMG3Te0PfdHtnwjRmZIH1vU8Gze6HhHLKLQWkMzeMQwqTFXXzSzm73WnTGVAJ3AtGF8JODKGiqKt7UiIiCwbX/XGCRT1kV5myLLQ71Hj3T+QgxCNNwPgk2XRKILtjTQVprKj7eHCa0ChUeo/wDOPh0E8+sPnIgu5DJotjtKeMECuJ/KheVSn3zvXPEe2GkXn2vHGo7Pw4yKOyL9oEs8LXl/vFXz7sP/nrT+z+/S/9c1/qdZPx1Jv/6bf5yjhX1fzo3ofs9E+ex7KYSag/28sJs8xtjCBZFu7yE3T+QdEptXA5gQVVIo2dXcuTix4nh3F+5dpcJAutR5Wkq/XHpQb98whL6iSdxSijAFwKXVAzMLxt4qYLU2s7LqGKSaXMUiS7ZmSkcpbSYIP+Kkn7lSLMzX2ZbCM063RmA3aIbs3tjsf2z/uIcRUoZL9AuAOIwuirOUGCb8HD05iHhNYxCynIYcZhaatbnLWc88c3BH4ZyDAg+exQMCdYjqAJyIFVTPFEhjV6uXoqeGJHbSGHtRiZXmhsLeGlOh2MEGWiEqS0lgT3UXAozmVPlFf9c33MiUYiB5NNWXs3ptvUSHeOYwZUaq6a90Prya1c3d6oMOi24zQnMaPsI4szeYyJy0t9M8xmoNcIaHUydNv33okOzmjYnRNiaLpe09zrHyNhjygcD0iMHKhjRvbou+L6kuAUjDM4eK2201uj24s+hWZOyU0fqpzsh9sG7aeT8CcUn2Wp8LAG65lwKDW1LTPDNgUdIChFUSVy5wxzt/nqpEtoBIyNgi2MPtRrvmQkEtTlKp0k4+NNQVhr+yw4Nsecy0wU2NI+e2r0Er0nuEcc4jdCsO4OY9GHslw0KAB25UZcdYnZpsAAnUsFjQfhQ2cbhifFAFnY4mpRjMJoZglNqqVqhDCNGit6/Owv4efkAy+iedEIO/dKQ4hOTWjhBpSwW4WmdjCEFKyF3bfcg1/dSQXbElYjRXrSmD51lOqz8V9QP/LAgpEMGXYOsVx0Ok0Lqat5eWRN5fBlXtdfP3iu7OMfDfu1fxb23d+V9kefeHN5w81hX/nN38kXxE/27HH6PeMexyPETIaRWMYkDNi3XJQwYASs7XTJwkSsom9xZwzn+lAx+tufzycsiJPOaolJiauFGFWed2O5CfNl7FZPMJZ9KyuwnvPbCXqQOY/QIn5g7R1OQNijsejkCNclz0zC4TW3p7ZNpKGgYPvGzljVjgTzo9TsIFoxno+Ms2TgJgaZ0mkjBR/VDE8o3GI0uV12hQo1PO9wMoq2yenyPPRQvxPsR7Al6FUKq9MgSMJRTUE9iVPGHOUunHg/GHhvtv/WbIx5GsZTQYWlDxfE5804LJbFlWa9AR0DvYa8QwM5IgYV01JbQ+7aBnRRVIPTMfCLAUtHmrtgKrNr0B89y3BQ0hXQS5WsUpspeLYe0zw8VcntEzFY1wiaOwHOzM0hDr+IrKoILZHgp9kZp2QeRALWv5/00rKRY265NxYvJHm4aT0fhQCTuOnOTcuEOhmcnb35Xr/RRnhYlRJ28hYEqmvGJJN1/VTpbd41pPd16/F7yb0Hj5X+xZy8ZQBRQgbKtH17aoPjEt4XhkXQo8jEpDMWsTLVLmI2cBnr7mpGEjjZsr3q5ICtc1owbOuHYCYfvnIIjMcEbcmGYoW6A1wXoFiBsFOKkIRUQP7fOOPuFCg7oaSuRjbhzbrOAyRZUqxKX1ToiVInfjlEYuYWAoXRNAL5XBGpbC8ohhcEYdvW3DW1/oix4MJNbGMzcl0lvRRLinPEEL+L5NkpVfBEXWJCeKqZKMQV++xVjGYrrBbmaR7T/P3Krwf3zR694vbTH7ln3/XvPlqGZ2/mdXNes36/Rq/zyWnnE7N89aHXk9vjuP8A2CGmibR6iE7hgFBVfiTcvdVLo8h2NCzhAydiqipbsZRXT6MA8RzD62kkiuQnQfNyDJOjRWt/NGqShHRr3I2rPzNomajcVNXOppIDlBizYVmKgCimNdO1dmA6QJGCRtEBWYeoOnwDh1Hv0aBwnYAnMT+Icbrv0Nek0EYkZoIUYYreDpEs2mnljHg+toSKZxHsMwiFhlnCUKmQ6ARgmyZ1uWZ5Fv0t4HGt05M3L/GxIQ4p7JhRoW/GJzxCMGoH0EAVrciIcsKQfwabulPZWpiLYxwvPG0BDLrRmDX2LTRSnO/WZTntPDv7cp9gJgHAln12/Pfh9ahOYqnInm8Hn/6XAC9mmzDMYoutjypq6aOdJ1mkF+3jxPEmaMLu3Pp5mn/zjFOlvN111Mz8yoLEZ8BT6As64WSHjS3r/thwc851ZzKrOpHQWJE6QuE3DtYhLhp1ZmyIzm/yDMAvCf4YmsW2t8VRHa+69hk2ggo8wvuZQSFvUrBsTNT1f6MGKAQWk4iFvciQ/BDXWh7Brbmy3PY3rtf51FAw9NQLUllI8HLN79wyHozALzqAOuESrk6AgjUNmETH8ViiLmYLzgGg60YHAT/etZ0Kir/KNiFasjr0SIZKCJoMpecne3QGRQwZwhKxYLmwp0/YRCMRjcAlL8hYkXJBKtsBlse1yk5fTZuxSkJyLZe1sYZiCxdIKuR7RLEB+aWEY6tk6IuMg09bZJuOM5wWgeUbtkLXtMlvjDlQFUnmoKXnsXTqdq+O1WHutZFzp758zpCn2YNn0371n9zY//2Lj+37vrfsU596Y9+Rm7j3Fp1J3sbrMEB7T63sFMWUzlJXwEvcGzebwkpQsymsboU+4x0qedngEf3CbifK1PE+MASuSnwD07HiNR3CcUN3M8Xo1qZzU878Apox7C351Awj+rDmVs0JLW2uAw8aYwOgf1VEUBFm1Co3hQ/fcE20ZmlIPCFl0JH57+mJk/nRh3ujFcWTaKBzfAIMfyT7AdaxoR9Anp3OnzPWAf4kvSExGFZEzpElwT+GAhUTv209QLRJ9wYVPUyAVpCoDOcAaNas2/oNxKVOMQEhpUDJuJcikOGK2ORvd2xWV6jrnHEErpIYDxxNegZQ01Z1wi1IektgCuhcJIIQGw3sdkyvm6twgiqsxGFcc+ywv7yi+ZBLdgsdhkVRKrW1OrFwnZzLCbwPSPDxin0QbZElX0py0ItYgsO9mlsHCkVCLHj/ldnHTmLUKsOm0SAPNs2ZPIPmQgBgKm7eA9cxwk/u9Y8xgE6d705pRoipbfcwl8ON674E7jvmvG09wa1FZaOfYrq7ZwAzYSj4LEpLG+dx8PsUiWLauEUiTrB1t/aWy2xC1+CazWx1R4qL28T7x4iFhqZiHhg89BqYrm/tEwhi+X85dixGbDAzR/eSDw6QAqxYYtRD1Hmjg4R7QC3b/D8Q5PBE78gp8VvGpiwd2NjJUSrMxJ588UNel4zXBdScGpeSDdEKNJfsP3mm4fYGuuSIEgPlqP9GZC5d6l5YwsnzmkGe3bBg6Wx3dj6X6/Q8V6J6bCKuTqaCuDRrH9Tn53VYu90cDsv/C2GPmmpyapov/VroyKtmf/snHth3f9dDe9/7zB6+gXD3xr6GBFaHndiT/HQ2b/tpcEaqjTBl2zTHdm+uofss0lfQgAylkJQYiIoJQCzK71QEAaPJE9P24nQNZ2A2sjZbnlArtjVfSdOAo65H1DKh9lSR1qvWh/A3DLWpdbtaOdYQu60Xogy6a4QeqssYb5y8h6OOQryt62NTefPoFOBqGsmfxPfAfLuMTAD0D/LTW3N5oRGuq8kK1z5zGubyBCaTpkq3auNHqApdMZHhsJDO9ID+DJak1b7ZxgId/IWgGxOOimU22sQf37//2U+xR+KfaInM7gn6AhTR4ZndgBJ6I8wl5Rli8XdOu8gRx86o4TdOAmKJyXLOQ+vOqepUVaFq6cWE1pRSTRReGlREOe4JY2svkIvZrNyk4vxkqA2L8xNFvSqVVwrdmJU1dJdS5NHAYIzUWFZ/DdVgg2J9drOxDzYCN7tNb9+jy5QrmByFUtSu79MFenuA/JEe2zhWWQxyA/S9O+9i5CwQBae5FpVhEK+RDOa8N6OR369/89MDHWMb3kD74+K66t9QR/+gy4vpN4SAG8emsMuZPbeFYhSuU7adZs7LZvfdvsT6z/Yq5Pcj0cKRcDpmONOrnr/XXC/3k9ayXFGdM293I+T5mQTgVOX0Yw2LK77CCUiFhSAbnzO9bHKTtThWj212rFoX0yYptXPZUInxvjy3n8fGpqcDyYaJ3gaiZfL7e8lcob3mUJPKg1X9kBj0zmT53xE3k/tYCHUQulipBEdLJ3MZgmq9Mgj4bEsJM5kGSipCWTLtXTc45Uq46Ijd+QF3ErlJ+TQFatuteraLHx9S1NSZeYT5bXjsQs6v+Eq4sv7Obx32U3/3xv7z/+x2TfP9Sq+b4/EbjNJ7B191ph2P0+5/6pWKb7ln9dxBeLL3TTCXlD9Mx2nAmsg4ZNWpBD8NM9zVMw4NWrnu6sn59kr0j3XInF2lqVIfN5gYh509HPEUR6G19Yg5SI1iV9JuWa1xd9G1Z8Wvsbjucso1Tb83QQ9imX4+V3cZZ6DMXUoOCUZ017T6EWQxbxAESm3HzBYlbr6SMMRJNsB4kjjFez3cDrNUBjRyO0FOpPx063OQobqz0pPSSOVNmAkjWYUNM6zPWO5XIxpWmCbgSvVZ/xCymd7uPqhFDWc8ZcyzCNZMSSSzgDO3p3ZwjMdYljqr1h4UFPO8ipYv1LWgnyFORNLuCWh52ZGEf6ni0fq0qYvZYqJnjal7HYB9DGruMorTMAS2jk11QPd7FxB7pVlYWPxuTHIXYaLpLlhqIC27+C9XHps0O2UEd9jXwHkAACAASURBVN4tIhwH20+Mr0K64crpQItOmQIZZIbLjlUtp21CIF8tRNhMyWrW1qVSXeuviC6keltsp4SqbaeQuzh2DghHclnZzBc2tDlKJjxKeUETJTYy5ha7lEQISPBedQcVolIStboZvFFZl/3E0LASwQjOrTNxs2YPB4bItPZTLXEctqF/N3IzplVloHYNIkEmJ6okZgTOS91MbtpZQH4IYsWoDgB/f8GXCOF3SBjG4cWuKhR/R+5HZ1LDD7US2Nx51HDtaYvd/nbVRPxiv5QMfrp+wz7FhAmSLMwpoKSEVrszjfx8KhAaO23TdKsmugKhaxHLPODNFW2dEaEj0doXQa3i0sRt5pEEbdD2W3/SvThylCTNQOl3Frrlt5bHzWl+XLl03IbdY9x+M+yRy/n56efS/vZP3LOf/d9v7I0YITfJqPM1eCUkifefeeGIe0+Oq2olFy/Y/m2b8TXj70RgnJWMQ0U1OkG80nFhtK9C6r7cK4NZbA44StRtGE89NIV8YwCr3aYl4yinLQIrkfCSkZeiNXvFhGdJxQCflBAo4R3SiMiWU1DsTWQSRrJfGkuyz+6vk5hXyOuNvV3N1t8AEy7p0tfrwSokwIpZtWnS3McbFL8vnjnshQ/iMaYbLJZO0a2M3SI8v561TJMTRkt50xrGnTL7K0CsVEMw+aEzq4K6o2XTiVi//8ksimZmrWjTo6JEMqXMZ35RgjQIJ1MUVxhRr1tT5JoWc8XJcMiH3lbyZZjd+hO1jQU1ayi0KO9Gl+LWcrhszcRJ4ZcOb01M5nA3MZRl2lDG8xVFK2QfSmlrI/IGd4vdhZ6ToFnMc6+a1pt4FqJMbCX9xmnGHLGNNYF5Y53TkSNTNROlUGeiLQDfXONZhm0HOUffn7bKjI1iNesbw2GZ+QE542IsMMvWEZvcAmS2dVGqjo7MxsA4ov7KIaAlIsiOVmNApnFvNiR36rYKdIcyEVJ4Y/eUAR/SJviQxJZQMBuAmfeHYMkwPtsfgI9dHF0HwU23Nr1EVw+GL94vp2DpzJ5MCdgVzdYkAqbdR7Ib98Um9ipS3RCgiYVxyePhgDREnxoDV27rmK6aAPcf7QaO6SIovSJMXt6spqRmaqYuUjGuJ+FEjdFf6tWQ/dwax2W3tMRYy86X2ZKaX0nPtiEqlhwLC+PImUBxkKyILjX7RykZpTkFDo+EpH0FqpOBGBUb7KtrARB8XSmT5bwG1Bzoe+dmVPlmXte9Om7KHj00+/jv3WHHf8nXzU3c+5olI2tHRdlzx4sV/nl7vXtkncZnD4BeOVubIcMydxapAq+SXB3SZAuh7gbchSDHzhiBga3IXytmU4LP7aLFIkrVqaCxNBJRcns8ypTYppEGx8e5so1AQRo1AXFCIZYTXSskMMm5Ux6jmyPFyg5HCaIa6vPrtkAozPRoWwoNs5CXlukKgJP8NVmrdIHkm1RxTDlOS3wHdDsle1Bbu1txQxSRxN231J83oPj80CFBGDQy/iWtU7WdA85M59nI+k829K1I991Z/yteYfodcq3DyTYf7Flwch86mxt4S7PJymko3dWy257vEBpW4k06dFu2wzm4GFnRMEYitcmkOxtjIUm0C+AI2aI+uCJJHhj/1e23NXQOsz4kpsDR6Lq5SiN2uN7m7HKt7aVXALE8UNgjnXUnwQtjQ2BCzwxOn8NqbthSO3k0FXq7vUUEkPAYAcOO4JTHcMsGTZ04cSD0KJgjtYHViKNNvEYcFokGe5vygqSe7Ejulu24S3x/n3LJArltUTNoUhYRc+xn5jyz1qoLOZQJbeE+VWZSMGTra2ciRDaK0kHj0MbO8ErIZpK6Si2GzJTnm2lzg/+wIveqw2OSAGOcdman6xvSg4NEhxQlJV19QR6MMkeVIaOkOezYynqJ67A4uI9saDGhoZ/a+syCCQVqcu5QE4sDaGYxK27iuhFqadOWhfC42rA8h3p4Kncb3xOWRUoW0gK7RHOHmDIaR/MGxbiMIhv4jlRN8g1TIiZCzI7Zcfq2TQ5Iw+DSALzAny+gprtALbZNjDnOunV91zfILPi6pL4P+p83et3U/a8dgXXVz2faa88f9dS9yKDDtqs2XRAXbaM2u2qnYGNnEkyEHJwdgNlo49vuG8WLVvBWngLQbaqH1ZaoluzA24qyvyaA7aUaQ8k2QuDGkwcaRsUEJgSFKHv3xCXP8gGr1eheNrKOnuxw8QvY6Pr8JDFeaAX72lSWoMPt3PYEY41inqZrT+OJ9Zc+b13fCalAlG6y9SiSsXEHd5V7uf37GOR3sqXGpHG6xISF7muOwx0yLxx2ODX5nltlU8TQi+nJOCrznq3ma86iGlIBySMCoFyZD4gMgB3oHTo+tQwaHA8/lTVmJEpP4Liqa8CpJxZ9FJ/8rpJBpenAIuSPxc7QpBxqdGz2RsbcuU/ycHCoBg9zXI78O4d2z7EKyetT09Jo978+hTa8G7lOEZUoHgk/c4riQ8ZHp6NdDzuM3qyM3SK59u+6+nsnxB3NE8W0IW/3P61Pw7aBIs23/Dl6viXYWQwYTh7uXMzVM2XAVlefZDCXDITW2S7JbqOgFyrbLj8YZuHaVVhEZHub7g80/IhnPrcUB2uocu+8ubUj2r2Qq+DYWSTv3GTPXPfjET7jBEbZRaqdq3fyxX5v8ll3EezYk0LwwjcRI4OsevL4cIM3YqQOVK5SroEiYdbVIYHOYNzsw/jEu+kSAEATvd2Q0WXBwXLz1w/YsW9oGRjijDb9P2eRXyU2IjgtOTXhxjOIHGaz0wKn0ZmOSkkCCk8Ton5lwqKYV28hAEdiUNGfJGWxZJQqlTogQJ61P2KkGm7s6x+CpdH0inP5oK07EaM7epO5yFt53Ty8n+/cu73B64rnj7PsYx+8tQ8/fdpzn7tnPNQQEHIzTxT4lUhDpirmmdqHSLJa6+ai8/a3HJYrcrB9AAzBwoBUzgH5FskJpwNhDNatMFRrETLnNBgWPDvj5Ngv9ZBPOTZnPGdXFBMN5fPtgWSmXpAa36TDEpZmNNPZxR+jraA4BTqV5N2hnGnwIjr64aU7zS0L6zXzUfq7ojhrTZ45/AZ7dsNSASdG3+kdLkkyCsG6mneeHKFwcJmGQ+wnAWqEaWSgIFfFa+PWUBhJHEH6RdeIPqmLKhFXoGSswr+ffW+yOSLJEE1uYrLLI6Ko1kfHqFNXlWxIMNK1lJjdx1Z0r/ZjIkTJJawfUJb61KCwJl3Z+3MTQm/2xOhOTMqEfo0E/doe5dYz4tMmlt3TKxt9YCQcDHmjQ1CKz+yE3yyUyG6WUkW6HVm3BUvCIT9CHqlNJQRMyIfNE+OtdOj1HONaqo0ndEIA5tsOG4Criag+5EGWBvJEwvJ3QYEbKLHaBLS2kDdSDbuEGU6hocGESMqpgk0hDF5ZT4AyMH6nBLK6VztMNgYDBVIeLMy4hVWht8BT2ZU9OXbfYlApRVQaPI6CWzsPb0Fwjhz67WDkg3INY6YSTQ8yRSDVQuUjB3hmHEK7EoBIyjVt6HPJzI+4uBHVpH+aiYBtGx1gMBUOQJ7Bnq4zRyhq7XTpAmqsmRhTspGpJxtvwp7s2Ck0DznLWbEQKaL1TBA3N91TSpymMwfwsymJGD0yVXGZJo9e4oVc6g2HfV+lH+0c+NV63cSrXzufkbw9LR6aveePHseDl86oe2RFgWrcncjrSYg+Zy7YOdExsR5vSwhu0lGD+INE0OzCS0CzG73A0onaK6eNyIQY0mixXKUFws2EGW0xsDsDsxZmcXi06veO5mjKhJ3VwwGJSTRgKaR3XKqMiO9qeXR+klS6Ex/qvAeQDHinfTgF8IYAC4zt682J0Onj6BiNjQ2Fnj3Y9rhzx3pb2a8Rdmbm2Ld1HcyIdYsjDIPGUTZOa9yH8YJzkI8u1KECFIm+ayencuEHgGHj7rBDai7RG7vHPUs7XJ/ahUOTkTXukOTUCUGGIzKq8WYGOac9ywLttf0RpVh/rvc4+1KVs9IoYHWgG0iW7USVU5dKD6PWDtl0I7XQ95Jyt44VXMEThpna1pSDY2Yg1a+tPSBovPqw9taU1UQvVezbtHaZmaUgpart1FNR59OQX+90gFJRQaRJuxvgHZoCRZG5rLvltMNeD63LKJ+fMle9SJiC1oLUi+QqL/C4sEvaGA7Kp9LoV2LcwqEaUocrSGM7ZSWSOVKL5FVfV5k5fEy4kW02fIgv6zHnmiC2cqFUBhH9dknjR5OnofzMyBHQZMJNJLyXD86GiZQ7NStDNBPmdwTziwRpU6u6vz9QCDFNjDZJ7Fchx1z49+mq2uyivZuLnYPdqzM+IGzp8BXqaXPP+kyzra4QfBQigsELOI7SvM2qrmfQFdMsbjOOI16mFFd7hZabtP5bhUjcub9g5UeZJhDUtG1UXQ05BrUalC7TL2CpzgRWCBFy3hV/eqRKnzin0a1nFgK6x6vSaxM42+mxgQfZG6vwRQ9a/hfkw9f3Ob6qyMXNs/Um7dHegdeTukCusg98KrIe2u2jp7uyWWdgy2550mHUl1NS5pPwa3mhzCoBZDXEbEqrslTq8XyBBQnpkmwGqBAENwpHdDtbEv2SPIye0DPlgB3qIRzqvImAYghry1VM9TfAlkF5lay4SosAIjxV2OSyuWRvjoq3PTqL2+EAXRwV71AZlL6J70R/EhxfOJN6rpbz0O8XT92wY2TqtjJpdbnYoqG80BljsYkJrerzo5ySVJ2J6w9PNoHbkQOHf0K00blqAgAef2iKJET1UoIhVKeMFWYD6LD22TxlRIghrRAn2nbR9LgAZYMqjGJhFFjE6DxxBafr+mHFvGZTDP6CFZpAhw0NO8xZiS2YJA8UJ2cYybaTQTHlJd+WPXXfEpgNwO8RJpWQv3aOFGsaEYqp9WhI6RAYhgwHWTMbdMxZhImowUpFGoyOMbTYqaJwEuxwHMkJHCmq6zmQcyA5ce1zcniZIgaS0NETmbtwWKP7A4TD1tRjvg5Pe4Z26RiKvQ+AaAnXEp10Kjegq3Z+JfRHetqFw2s/lpMgme8Q16310y3kqNm/UKptcxI4uNrnpCHAfEEyYO5WK2GcWUcvSqYPg61OF5inMhijbCqg6iuW1JybWJDlkzDN9K8ddcKGj1Ww+Wq9tHOCrTRi3QmnOmTOZ4wE7UlPWYrexXQRUAc7v/iblheBp7U6aFFyVyzSz0iBnz6jEcEmJQ+g0RCS5ToxIxsbj4o1YKfoQwNKXZtZ9IFD8IduV94GQ4apG2ru90RzADICA8VqisJwHNgYgQjEhYuipwVT3qNG1m2dM4sb6WhO8sV9v/qTJzVgBkdQt6/i6+a128ugpNY/WV/Nj7p0xLWwys/dfroenNfzemFid7GvPJMGYfaLce4yIqVTH7OGqWqKpCgA183M5FkqhLnXS/QwJmrB9EYNJKILY3Sb8U60VXwBbWz+7WbhZ3tUZkvZOPyfH4FaI9YAj7W61G80Seep47M7K6AEFdfdJAFQT8K6DIPjKr+ge0IfQyxE32r5QLc+e6bbsoLZeKZ92pJ0Qs4jk3ztL+KHzuliQ+nhdDPMqjp6mCe/xdqbuNf9Yb7dMlz7OGGyYS0Qu0m+o6BD6nGqUe9s4SUVItTdpCw7CJ6WU5rBi1R6CtETAF/czpS9FL8m6WdqJTm81nTS6HlvbQUE5O4ZX96TzGOqhAYlWxvrDpzOyTBzVHdf0sQhKS5fkCNcFD/SCXOjgOQAKeIhWBIPFgVH3lr8g513JLcTvkdQPYCHWH08i1xHwi6cby8THh6QNfUDFnr0pOdL+VCSy8jLEC4oaexngaxXgim0yvzisPnhAx5IfkM8RTYCI80t5QRzfMrJmUVzYKyNsYlsjRlyP+hfuFy93fgmTTTfrMOTzKk0TbBwwofiotr4qaprrHW1eskkilD4GmRkkOs4UGMTmdSvw/qi0ZPTAEneYcw6UewUdb461Bmn8HEcWXEZYBr4+C5UbQolpDusSJVdUxPLECYlt6N1SDhiUZIUS6fvPFEQnJOeZEW2hlSQPI2A1mAKDc2v0FyWxl02SGrr6lxl1QvYEH0WknKmzuxoO9OK1kyLZcWVvu0vllnbNHlaBW0h0jDZgJAXmeX9fBLNwahZ0mLieFCXc5Eq6zxvX32lf+aVl9/otH/rr5t3fdNhn/lc2Gvh9uwzaedX0XYkz7THD077/e980T780uvHu16+NX9wrYDrUvO42DN9XrGNsm7cuZ5b0hCkWOsGeJ+ce95bk3LWIgnJE0T6aQT28eE+ZTXloducRGM+mYq3DoPCIjRfcGaY/jgDmA+Mm7JfxRFe3Pgn6U8E3copMO9W1ApxJ97/YmJt9RCwIyG6xOn5qS2IR3KACqJi7AeFGyKXwZulNNUrH2vzLnIiHAPNLpgZDhzBedh9u9Tuhk7SDqe9UkcBcjhUL/f1oUftGv0KCVq0KUFb4zm5+xzrh4J2ZfqofoVZoMJg3Y9Wrk6HptT3/U+AkYujQcJpp0gem5O6TcDlTJ3lXAc60gqNKU0zNRQgoqwVES481tmDPskGTiePaeTN4Bz2MQJCAUosBD+mKuQ2bs2IdSStBpFDEQIi0wh0FwDSFLgWcCUSD2ebso1/Ha4P4rpOQ2QtPTr09G+Qa4oaj3RUcDuzdMggije+d2r2MogY1V2sHPvJ6cuWKLwyLy1NXzIigchBCmlUIEkzjEzviEEqd/9OtyGSHo2UxCVHxzJxSBgarbuJxtqaQ0fGt2OWZjpGQJaOdSCtCw6P5BmknF3wkbWcQ8ijgRw6SK7jONnIXFtN0PGFzYvEKbcVOOC/oE0JKxOabSVqCkskIKQb1xx3nWOivUUgxe7opuVbXID20D8RWXy9f5+GLixN1V4kFN1XhyGYc1Yr4+2wIzUQHKhoL6rkLNL1L5lsn89k6vUKNJc7bB18EsVWm2/mwzSB750YGAuS0a4DXZYyd5uDn76rDpMc9LiFEZU4Yn20FQeQn2w/Yb7YyUmyWN+4ldLh0R+mSVGbgth0QoWchCjKaOtI1UIrMJwL3GoxatslHhV1wQcPXnrJ7E+eNXvuxXcyM+jXzX/3X33c/vlv3LP//n94rz1+UPbgqU1o/g6/bp+cdvuo7MWXj+PBGTfZi66PrRpHRUa2Jix0sEe9r/aCOss0/UwdFQ4dWTq9bJhS1yba7CnJ12EHTyWLJN3I0OLpy092Oe1u9NMer2uZNLFyRa5s3RAL48Ym1tKto3t8zZclWaD79p1sYf/sNlkkpMIJeRuI16v6RLIdwGyIRMu366LiRtflNj6QVHs5ekStj84VXk6jsBpOBQkFqpeLPp8qUja1EzUZomCk7CLVKcCncrLU+oHOaegVA6sm4O3Zx1fAs3KV3AfSjipNKQn6CSWb9tT2t+XAsgSoYK7a509zPTS+it4VxVk3RgQVHsFpG+1O5fbyd9RQDxZz6MnMyjRmkp1gkDGnssdgfygzAhA5S9UKj0KbnqDT5rTzXMp7Rc/GcxIPS19DGN+yvGyvYfJyIVU5cJSn+aTfk2QNUgQ1acirRtLvYnoENQlaKbDmXmnrYssZEwZgG9QYXFMy+isdKlAznd6GPQRqrYHD26MUDvRMt+C37+sS9exZsoSYJ4m5xdefnLCB8o0PfSkKnAa1bbrQ6cQaghXQ0aYQq1pnZ3uWNfcqwMvqGuSCSRxmoJx2HASJqz0gdUwiMF5meIccJ1jbSjPaDjSCgNjXrWpPU9Kb8atwfnN6oc+qgkIAbJm2r3Oas2uxEQwoNImCQAKy9y7i15I4seA6I6bLMgJCMmU3Mp2SbMsV1XJWhhuRi760wzRtILC+U8Vk4aZDu0BXTCLPeP8ESAS0jpwh4/jGHuvVtx0rW8AHJ26xrcgFgXwXHgaM/xKJAnHFjQQzyRVuh3faiE1nuIFYUSVQZPV/g8JFeIC4pKQ6rsAsCvbHxS8nQZDldSl4t61M80vOOv3eyy/H8cEPWPzNv3nay390wdoP73QD3onXzbMP0v7a9z2yX/vlz9rPfOR5+zPf8MQy39kP4eu4TTsepr34m5+se++/OW+ffZaJanYRLBoBiZ+LN6l+TanftnEwER7XnTvYxcSwM/Duem2tmHayJAg4jyLlX/oY8K/YGgVtOViqwIzCKOxBehscYUcopMmAGCsQybFJi5OQoYmhztVCUTdcfAD/B5FykkdCWEsfDBDHZlDmzzZxB5vgrQxQEVuIQToUZXLt9Jya4O4cRmagVdLxCZkWMXmHZSyH+kXe1aM15RY/WVRxoNiVLYd7N8sy96UN91y4aWXpq9IU3zQ3HWwDKkgHs4ROW6zFGWypNnbwB8maQfbRHaijTE5U4W0tj7wgDD0EbP9+wquSToZk+OKvA7JDzHpKp6D8dnJUj2ORJUBGQrbqQD4KlUxDsCs8F4LfNLEWahZc/SWQgUtIS+M68zoPDAzerTiOxZk5jcCG9IH98/iMxpDQrIiiOoJHmBzq2Cm5WkjRQJrg6mx7394eBVchLT2eIlUY6AXiEIq4LlZzqQ2dsHME00CWd+wHNBHD2y/3dKeFHRNFof7X39yuPtqQc+UqJ65CM0zQKrpIpTAJ0fFv8D+rrIn06B6gBclkjSo9r5WTlE/KTm8qjmo7GkMtuI/gpOr9H5YZNMPD3qHHAAlNdG5HFU1fJQF9wR71WuLyRibpQrdIaB28pHGEFToDG/Fh0TMUJJ0M5IauEqv5QCjlPMCk4gRc1wPbpliDhHNORiAJbx0cupMYjanR4ZTWVEiWXGT3UD3NQ0a7cOuJizd2feOjsUm0o7D0ISdaZcgqZWt4UDKDg53MfE60s0OgHGO8ZINvU0dxzENxQBjFavxmYJDttpEUCUxxSA6Tu/o3amJ3POmCJhEOt3SzeZIrp33q6cNfe93Ov/W3HtvHf8vs/rNfQB94B143n3+5d+UP/OCr9kv/+Fn73Ms39tyzb9qC/i29EmYvNw+etbg5Tw45cYIRrc7gcL9SGu0eTQWqhNOHY0JKN+CDDT7mpaYCAEk0ZyCqoSOWY2cNTioHHzIKHyzJaG7DUVTarvR9VIVXwAgIeUHEu9DlXMsWU2HMpxrwEUb0lpI0tdmJ6Cgi7l0fz8AA2oXYEp76LfRzrUceLGiiEpcQlroYRu5CfneJuKIJ5Omc/dT1BKl+6DrFps5F8XqQR5xsbBWx1/4Vku66k10S6qBjdrQclagO3CdMoL+rxUpsQE0HEv4dTEdgYvQRuwYM8SguTQuCiTeN5qEShH8cTqvryfeEN0pzRP2VFhMGzvSyC0qiqk7kcSQen+NFter8VOco2e6BXxyikSgFKAjZJkftUrAK5f/DTL2hapqUnB2gRZoywNe4bsBvnJehCYiC6WmIy4qJIwKMDF7ykxaW7jL4av1jboKzwsnb6mKc2ZrZhczcGsOugQNlk0D9QOo8gU4Tpb/dlMgbkj+sA6mZildxGZoHX3QcLOSn64kzC6QToRyRF/mTx4oX59vmnP+kU6z1c2q+UPa6AqxgY5y3pyUgdxKB41HcRCDUtRaHcfxVnQ6Qaw3ZahGTXAIL93L13E72nwKZaU9zdHRcOg1IhqCFTnYXGl1HAAjB/pSp1iimDcYR9huMqpR0DKQD5Os+jLES128m6FqAInIugRFuub2CJ501RXzf6ybgUosoQwTWd7zflEHvBHusBw0W4/V1tL6EKoW23zqS5skDMFInFXvBnRpOHYpsaMU643xJxsaSIds8btgpGjSJ1dyBZ/nYXpd64P6zCoAOnduAQUOzO7ot1sGHhSSLPpHzYwXuwwUnORwtr8/tXX093Qf3z7p95P5//Mr77A9/45HZC8+84/nBzfW1P/tZs6//sNlf/N7X7Sd/6j32/HseDynmnXx1UmiP3/uCHfdeDj+XGOnoSjRwLFAqkmMcMxqTEJpEHZdvkbpbcchQAW1lEyEQIADVeucNQeoW0w6qA65lvxhjvYVodSAAnqsvZPJ9UTQuvuHmntST0xLCggObTOYVfa0zjqoXjEPIDwgDJcgUHCKmSsogl0sTZaVpwKjYcELIj53Xr1oAOfxQ9atHq8z9d2ZdooKuZDBCvAuRVTuvKrgyjFVBk9gJAfc3DJ6SslsxAkBXLmfi4+RCvOEHwmKmNn64iJrhSDtWlwiFk4+8QGix6dChzL+9W4ZgzmKzcOrOfxkbEMZjRtc1tJU+610GMwv7OZbxEiQT5gcFoT3SUZbusi1q4yygbrjzznJye+I+6hINNKOXHNJZtnombInSLb/SITM7pdgj0DBTubfC7qlZYVPQ06IKkuBWtMsPl1CFoegTtmRFn20ZXbBW5VqpYRDOqU5CeymbMZgDAIrsw/A0l2SENw3UkdZ3rayZnr3dWOk0lOhStlB+ZCewApNaYUOgOkt0MGyQpSCFTm4T7t+aGxiLsCRaDAfyIzvDAdNoJaB68JkEwZjMAWsN8fdtc1HTMe8/DE4MqF9QA8nmkK2R0sD4sBntncojg8XDXsFmBh0wWK4TgDQM5QVuTeo3hwrjjc5krMKkRBPXrL3dm1zoKnycrnTrvD6RFTFAiKDC8DkV6OAHpU6et+xYnUFnjGbJ2xAfgNLr9w9EAd7grBGwpzjWw8nvh+jb3HY6LrNV1W2q4pnCQ04FVoWwRCwzHiBl4v+rjzZZIslJ5IXByofUPh8tltGwz17/7CN/39c/8L/+P/779n/97K/a/SvnuXlnTUduGNA+91mz/+B7XrH/85eesz951ey5Z7nY3rnX6Wm3nvbZ4+W6phTfi+NyKHTOPYGKdpu1WDpASme2cU9K3SjHAXAwOkfgeKCapJfnFvhCyGoCw446Fwr64QVHX7SqvVWz3FWCGORgPmW6qXtRUwVySJEIIwvQNy0/xsSLzlhHH8iRtAfqQuva/0cLe2r5d4z1mCxdI2Y++drdyrG6UFnoKZQN5TI3FZiBoylFlk8e2OzxowjZlB/0CRw4NFhALk/u6gAAIABJREFUyDuLqYBhO1fjGN0OC2oODfa7PVwoS5qV9puCEy3VHjVZiE+q4c1XDt9WLxiLxRkfbctbLdxgm6DqPLAiGlFmcNBCgu5uZm0MckQc66Kz9RO9wwR3DXtdCfGB0iTJczaKdBwUN8bsvi3kR3XFtj4/9PfYKZi+aH2k0ZmGniLkR0ZyVg1I2pjAu2rUaTwR8jMiWP2tgmRZz3DKjoS3jSUM7lzS20bYlaqNXalANkBJGoX0J2Fw1iu9J0ZgrvoiciVSiTB65tOPn1Xh5M8QR7EAILeiKAk/N3/AcFmPoMDB45qEEI9Mi2/tz3TOSkVHsWdKg5qTi1pG1yzzaUb2jBN6v3YSkeop9LufxiH3GHxUW+XfX4b4+0qcWpMtI2Oj5bOIRgBxxPbKHstitjGD2XripBKnvRtHfnJmlFOdxAkMWrCdf/ZUsO5IacuMHTRQslXUR8nPmclN+Zb5U+7NSlIpOnKh6OwmkkRo9JwpSzA635mRkM2zpdTaNe031p9FkB79bt7r9W0OUbsgVFK3jy4vfQaoPr6iTzpVYkFeGrL+8IkYPRt8rb+1QwO4fM7GBmrNrKKXdpA7FWL27TK5ok8fAHenh4XbeQvnCYAu6wdunrpXr778+PyV//nX7Xf+6e/as889eGeyAzy469qUjHz2ZbNv+EDZX/3+V+wn/sGH7aX330VHxk3pT/+K2zR7Le21b3q+nn/m/2ftXX99u67rsDnnPvfJey8pkRQlUZINWbacOH4ksVM7UgTbKRLDjR21rhO3aWIHKAwUDvKh/QfaT0U+tEAKFHCbNgWK2v3Q2AUiu4gjpG6tKG7jOLWEwFLtVE9SJCVRl4/L+zpnr1nsNccYcx2apEiJP/FSl/ee8zv7t/dac8055phjvDgu3Rzml0HwkD0CQu68bWzOAQHvMTHOrC1P3Rb2FZcQJu7mkAdJ44BQq2e40MpnPtJ4Yz9mw1winW57NLauFmL+B5qG4CvlBie1T6LRAgDo7GW5FSo2qTOVDO+znuQMAQcPvWdfxthQvI85GMfVliaz4nlvtuRp0XxBsz7ASopi5PLmXeQf7z2lgKGkD2d9S3UD5ndRvX8U516nqxN6oDu8De9R4vKScjaYGE3t3CUilgaj+fQJLzWGygCTRjkzaapiYNG0rPKQsLCMGqjmVnFLZ44WV6QY9FNMxVGpJJQeev4ybDm2sWiODHmrAxm3k3o1nJYQw75mngJ6LEVJ4vSzJjQ3J3eQkmPeJTl0UrxctUoXkHDVjFyYg0BbjWiFxoxGMHvm/HHRCKQWCW5wxSoqDrObOBMzeU93XphGH9CCpyhfN/vuNXzhG6lUxghNMAiHLDr0MCR1OdEXExaK9cmJTscD58gQ3m2UvoItuu8MZtr7G6Cgo+2RzRRgKXSs34BIyS7irTZMa446D1GQMHakCRIYgVjbKIiE7TlcBVYE5FCQ98yVSHdjicTNoWWjsqAgLoaxAlad814eRDggPAs2/qJhPds+w5X6s3tUlf1mwlDkYT1gIOEJb/GKByAzEftBqiM9tVIiyvaoZPO3xXgJ4AmIpJ1RRSSAQrTMqs9P9wIQXVfRgWq7FFcj1UJJqT4NBErUK4IZDGJuaP4aA6ZxYp6MJmsopVbcfMjBoZvjn031Jkb18L6ApCh0NdApp3oVBogLrfEcXGQs+jS0EV0vYRWAzFAsScco4FCHH/e3lGA8KoBjJit5/k1pgZr0PAja28UT2+/l/pl//Bn7yhPP2PPsfH0TLwesdA9tDymeHX/43C2zH/4zt+x/+ye37Q//5Yldv04WntlDD92dDnyjW6Vv+LWf7XZ6Z9ilL535yRUbe7DzPVgIukzUEzV7wC1ton4BVefJHpFcQo1bkA7KdNVA3zBOggMTUa3P5WCYhAKfjOQSbOQZNwhbgNUJZepicLNYFPXg0HLdMbjNvApCmmwWSzu7spCRXa1pEEXaGxomgzv5wUMoehakcNp9pCDl+omYFA5KTDnLmXJGxjJHjgKbi1rEuY+WNyYLoTKpaswQJ4a2B6d8REwwtjYdOiwGVSc0tWrOeg4hJM5OTqphrj0LhyJBbVkf1eVOWJMfZB4HTaBOVVYoKZ0LT9nLgeY6cE3TFGoQIwOVdfJWqvE/E60dqUxUeAiwqI+mXMnATzvxqN2NOfP9uKazydKjW07ZfFYGNXZCzITt5sMNzlkWBo41nY6B4Xm1iPIUe6HOCQrY8CRXY+/M3JaKmTHaOakaieFUn2knuRLYF3iiaDkhVidnaOZlD6NKD1ZIQky0TqYNAwXD0dUEODLJNCBYg7bjM3E5LmaH6Tvd2tghqLMcueBAD7aOb7JSiohV9LR5+0sHauYTRTlDE+dg7GFciF3CJacCMh7gJJkCgA2imG2KunN1MmvYDdS2xdCYuQ9Ve2sSdP5fkAdLjihIPUUDNYqhN4l9QKlgjr5ZzWaSd2uVlw+0dwxdwMDxl1TVLUGxSRw9+EMks8qTRABxVRSYex6QetTJiDkAlF2BeY+YmZsBacY5T9hFDVKNRzK3K+OZAWoTog2aXA4/6qQUcK+JgftTrP2F0HKsaFKBg+SaBOI6gs+XmRxiWAHiMTC5SzKXF8ugAtiQTkulK76kF8tgUG240dyoqttoxkOmQadDmH5gbVDjEQO0b+5n2veWVChHkebnC67QeUg4K324s81HOkaxCZnvOhN/D9VxZAV1hpi2byeeVx6+avaE2cUbr8P57uu8jnv34s2wf+OHzuzf+5mzJRkxsxdvmT30YNrP/9ST9v995oI98MCwy5fNvvps2G/+72+fBM6Tjff1jb8OsmLcTfvdX/xUfs/PXbnw/j/zXrMz0rjVFQ0KVhNkqGJkOCs8FoLSNaAjZM9SBpeD2A7UHzUY4pbohat/kCKMO+QSTdOx2dPB9Q7z77YZ+AKFboEMjhGtjStefW1JiEulNTjcUPk7tpG55sa6JSrAgP6rsxsesHKpoT3gwaMQN0DjXtMY7Coa5iQqDdioLksa+YT251Dh5uBpd0RLdqbw/po+SQlbd+Xvk2WHsMMiQh3nKo1O5AgE1V1AoxV1jGqmSbB66do5Gwm8hhk2oUvKbhoGpggL80qoNVtPPlKX6KxAHXZR7rsE0UsMFV8rqaXuyx4QzIYDadRjOnHx1vcgiSgVlOBnBtphGsab50+MrWM4H354F7WUn0YMdN50XH5QDXNXD48gH7P0jXq9/AuIvcpcVc+czVHu+xqDPiirgf4oprjZVTpem9H8XWAU8WAOGC02eFlStXUEw5U3pkK84m64i+dOSXUnfUqIqc6ng39c+ZZUNsmDrphd2YKx4Ve3LTnPx/w6wQ9nu1PVYOD5ITuuYzSMVPh5SODgl+EIegnzs0ar0JkyH9xyrvbZjCVcT/ghq4iAX2Qp00iHNNktqYHaxgK6gnR2r1mIUt0v6q5Yzff7DNdHX6nRaOamTrXkXlIkBRui17wzW8sHUvxU2bc3cAwpB4tFIAcREAbHHElQy+GoAwY5FvTRAO2n8piokIznP99179H0Iq8hx6E/AfgTrEJRvAxFNDrmWKuPYOCvxK2SLbEoJ3hZl1EK2MmaX4gh7c8RhE/6SVO9OuEkALyPDC8nOxA7tcYDh7LmTVwTrrSe1YHCgWK4bM69FFqOPE1WNBNjPxDQkVdFa+O5+k287rzkduHSsP/kP75n3/1dCzLC13PPm/3JP7XbBz+4H80ju3LF7M4ds3/1yav25BOX7NFH73/DSq1HgXT/bLfHH/vjdv3azW2M+3ZiV3M6RLAB5/LIR37Ias7YFaxFH92SwRQrE7mF9tpAUlPDjtN6U98W+OvqEFrYF3UaMDJD4mGF3I3XQG43eG14UDXwi1lyDSwD34U3JrzuBrIpNleqcgROsuCGAnpRbvauFXpRULclJFHIa9Qim+At5VN5iMY0tawIU0QSqE0F1z3TQvYhNI4kyqqyDZpg0ak/KZBAHH0wJoGyyZOUhQnvEj96KlVQP20othuAtYF5BJi3sMTaMFTJw5wUo5SMMmb9OEsNzKqatgWXDyLUpP26ZjgQJIIMvKCoI+7/pNyOZdNi/pqhE0Sz5u716GR9eQr0mG+5LfIF5tYGqwW2poKJm5pP6rAn/RZwDdQLIVaLaAzSJDj0VNEwTGGWIq8oIlBb405rZgbaSAQ5252mkw/CjPqeIb8YJDRAiiGOI3Nm3U8vZZmVa6zxtLn/DrJwj6ysKwiwUjBPERHMB3vE1dzTKLcW/+hNh72SDp3K4DwCggqGb8lcYA0sWgwPnwmu0qk4pTNREuAOSRMU5d1NpMJXTXQ7DWiwf0J1d90zJg4scvE7aI8VFX/emB0FWA0sLhPzaKGyGDMM5ON+smsh2oMjdcxuHnk/jK5XUIMRfV0Z+PwzNoXFzkacI1LMQoOtaENBwy4QdCZTY4LUKEkOxDiV7JoA6FCLNkwPi5yoxYac15LaSNb7sWmvWG6hD1xSJqVG4DxrZPurdin2H3H8ppVJi7aOs7HU2Ia6FWsZ6uKd34n4YtV4Zw2DR0Olg2bK0jFpQq1jNjAW3sY326I5PELvu334p+/bH/9Os9/7xMuSEaZbN2/WhA3Wlz3yiNlf+aufsb/7d99rL93Z7eTkG7+S41Z/6g9/3649e/HsWy49Yna3NEdT4RVQ1WAzbvD+GLvfYCXJQ4TMeAMycuDmxWAcC8LKNr0zm+xoaCafXLSmM3dBCWLNznpkTPyUhzxbIAVm461jhRDR9eHKHGQyJtnp6K2yp41PhDmZOmVqTYA8phAr6YwB3DomZJsdhQRLoOQFE4oTelLZNmEgiRn3pCG49A+SKI6D7BLdtsUIKTvLbPwYFcmJYLhXrc5RDlbMiPNz0h2wP4mRafAKqztsO+5Qt11lR8Z0RqVuMt3UPmZwTArClZzBoCyuw1HYhGq7DEOInHqzbUTi4wQJOwrUkUriO6ySMCTBZeiqipU/02qNcxYgwXAEqohVY/YdigsZPWTIYIPEPIgxDSbKOLCmLpxDYZfyuMSheDQRMdGMTzUal5RdFp6Sm8NpWHWrRHRYSxhJ3SauBTMTiXENDnk3ocDIek2atabY1Kjc5t+GEEBpsrJ51xfBgXa63jotnjDxIK7CYFKh26ZcBG06rLxqZcdINQRcg+I9v9SJpLHbJShhQLpCRTr1VDqVOqZjfGpJU1WIxAoB1Vh3RuUs8L3TpbW0pGP1MIIMy8TH6/ElNq4GiURchWmKH9i+Yj7OjskcqB8kNRmVxbUhjeBancFDU3xjzfgRsmYLcXBCJHk2U8q/MsMKqJTYUVpSAHB2UOrkiHGvWFAAhwsNN6VVHEtKo8YbF6ym5XWDo5MnvLOeTcKWPwlqwmobYAQH3o4NSb8RwWhIafoR6RCpktaV+HDd45sp8YyMY1RRgDYTFwzT2aQiMp2zJEBYtfTIbZLgcs88VXbD7fsNvI5vfemW27UbZn/5J87sy1+uP3tdLnm3bpl9z/fctcffeWZf+tJlu/LQ6TeUGY1Zee72A9/3vfb2tz1rt2/fsct21ar1ToGDwCgW/AelpZhdeYn0zERBDZsJZBzthw0gbQ5h9MuhOBp2Th6pjc+S46dMphhlJWzj5yFTX6yvmCpxLGyQrrHB3Ij2VADssxiEospRVwg/slY+RRjNujykQjXwAZ57OPDxVZC7piKhu6ahk76VzMm4RSIWLxyOFys8az82vBoaixi+VxxF9QBPHl9MhHQAoQlFxmlNYw+lFKqz6ZKFXKXU24IWXgMgMCFqU5ANcDulIsBz2tU1mMowAxM6+MgDDRjIQAyYT4ArNkarB9VoT7EO6LiDEcJahjWmALIdy7vmQJhkQusAwGxACe0j5eGUCSpIZiY9cp1zh7DACgyjT9wMNEI2MtMJIjBlO2bYcL4W80gpHrMWHuxcimjACIQoBISbq5b2qCnEOcshMSvTgQuWBRzvfLdSK0VGP7Cgo9Vtjn925wQxKVS145TdAwsddKtmdJbvrHyjBMpQxaJWz7aAqPBAoHvScu+TB5SRiywR7Xo3DSWnA2Ff/rb8tkLFi4FdbXJbG5qLMpixcWQ52GJM5v3W14/xM1cvKunaOpt0leU5FYioOWDK4PppQ9F2Fixqn4Kvv4hfoIpQxs95oOW/wLCo0VMK2bphgmPQP6WLTGyfZBpfTDogVdAgkiBAqZXORbknXeXEuWfOO+/pjnOZDM9+fqPWHpcjmkEm+THun87bOjvXvXAkx70UyTyaa2fwVNEAOnWzlk/EJ87aiqhzxZ+kBoqzPe9EmSiPMpghWsdnTgTwleFy8GThbIifTEFwtFKuGWW1YwoCK4/Z3jf5mmHxzO3Hf/y+fce3mz3xpGEe5HW87t0zu3Hd7E//wFfspdt3LPyW2Tfwa+wvWOYt+/4PPGRve/ulvHv3IIwcMsszaZtlM3FK+nAenccg3JRYQoM86HKWDqUSfdz1s9cR53oUwvZQvdfJTtDWGIJlwwhGQ1VkLMRHyydgfUxNxBS8QBwO64d17JJTombSJQ9YOorRzNU8ymNRBH9AFWPRW0BK3XgC87QaQWF/24Fv0v7FFwGw5rC710m3JOWwaa+3jBWX56Yix5GxPw1d+OiPuxgwUwV6KEzomRjXvihUOFnDpMqGiif7nQllInUp6LMFvJafDwMgI65OFn41YTop4sBGTGRTnwSSoDROVTGiJjRHCFBZg2KCIO1A9QxjpTDlaUBDPEWkyklTdU4iU57TYYaiNT+46gg5OWJi8TmHKhoGcT5PhMtjVHZQNbsVXchl0XnPhUWWSLXhmWOShwCRS0AfnFNpRkr2fk3txkg6MyY/P7ZLVEoVlQqsuYimKIBq+rr+KXOZVL1OGFUFXdxMAAaJK6iLyXjugtdkqKjJElCtEuhSdLg+jnWoLa4phfD7YiSjHApMpZCNtMBdqLA57+mc+SwVT9y/jWUwLhq0bmEJ82dkaSsNpEcuqqVzzzes3+QYjfO65PNNdxT4WLFERgkjuws+LHLW4BQYlinfgYStguSZy1HqYajVEk03i74lZHNWqjsaGKCHEidjLFMpKfOF0NABY0C4BpbQWoTIBulhADE3JnNFVAOH0deQjYpPb24c8kG6MTi6w7NIsmswJ0Nq10SOng/Qbdp5Ycn1bTShX7ytdJsTpgkJ4atJxKrdE677in4bCIgxq/rJ9awBzgUR8W/s1/Ezb7/kdu3BtJ/8S6f21a92evS6kJHjWg6Xvh/9kZv22599m93ZH7Krl85ez7eee22Hjs1Lu336HV+zhy/d86v3rqj9DyX0kvMlCTg5KVtHSjCckDpnKiJZvsgoLqtlD1tc7wNaMIprNYissCBrk2TuZOBJIrfGbTr96OFtxDJX+CutaMx5iTGQ0DEj4CLMzGhlIH/fZsFQoJWd07muA7tqGe1rJTiGdtz+9htSE7hB1PpzSsu6zhJjhWnUWBao2YWCw9bFqdDpWqkOwgaqWe4iDit0e7h+TLYvkApSyBURssAhSQ5KVUntN1KrZIBGERSYY0PdaYFOjmGwa1r9N192flc4vA1RI5VJvu7E31LEGrVomDrR54HTrVx4zZBRc6bT1gF9qcVDBxUtV2ezZjEzToSNt3PaxTuPkDQxkDrXNEpOkLSvoxxyCMnJJHz9oj5Y14MRFiKV2esf+aB4xq6Qn0Yz+O7LA0WeSRtwRCE91k3Lbp+4XKit7DUBtatpwJtFFihXKxJ/7AHui1gcto2S8WhOFgoTxoFqVAMkzAUnj7A4+oN23CTNAZ/EO7rg+GH1Q3hebnO13pbQMHiz9IECc/G6M0XQAiDq/fHr8KOYItN36nkikQ9fVljgoZPCxuxRmS74I7zCziU0VII+k54fmbjNEGvLX92w3gag93ePN7lgDXPFLVdEvEPXr1mBYgELcZ4ZyihdkJ6yWbhM7OaJdU3iGz0ejC7cEskUS0Y/PWum5dDAnR6V3dPSlge6Rd28hL9lmNxzMGjZWNcUGZFdp6Z5Gwh0qeHamuWst1SN8WQbXtm2gV/vbAYHqVuBvm1t2Tescnb8kNMzs7t3Gha007Af//F7ExX59P9rdu1afe3rSkaON3nhltl73mX23e+9bb/6kYfsve++bWPZW0tF8KqvOdp72+zy8++27eHTTDs1xYFASxoBDMW/VPWWfSi+IclNGS1Qwm0vDjavES4g1S9hHrholDBpGdz8GGdbDkwGbgiLprwC2NPk/VqWAqe26kNSiltYHttGRnCHiRcXiCkb7c+HeOH41gXpG0pZNAPDco0pU4JVYzUCIvUf4PhKM9poTUhOukb9tKTFT3EVlThFK+sCtidmOPAVN6iWCHfsUrc+5IjSpt/EfuSj7AoDnyhczNUFgPei3EMwgEuDRy7wDecNpHBvh38Yl+G/mB+i8iwO3SBN1ER85AIl366KxxLzrNsmx1OVVy66C0h4e2WvYYw5cjox1pumxJmJjjGhXfPOlqGHahc7K3nuDMCGQvvP0blU1gdKEFf4IMo06FtDABxpJlLEFMLRFR3GS3TS8JA3pv3LQaC/X4knbBBM2n9Nr2G2pi5WXC8pRogwThY7en9eE9aNx+3r+ueax26OahtiuFp93DX1FjWnM5pgWmoCbbSZKJGEvqrMn7mhjax2XNAAGdP1tGP08a/EoztVHf+4ntvegSkJeIK1koZ8OGC2xIvrVif7hSYJMOjNyQoAU931MWKZ9sLa3JfdJDbHUp5AaJ93LczOrVXrK0c+Yh1W1n2AYUXZYFTtOO8ZicmGhMqQbg4FVTV2odlde0MyOA2yOIefapBdoBeqNpe4DNjoCg/GhoyvCYXpU+SCAvHaz61JtoWV33hZQBkfksmxYI42esy21VKNt8CFmWCkJIgz9xJKjUvUdLB9RVy+3uu4jftudve221vfWt9w+yWzd37Lmf27Hz61Z77cYcFebzLCxf7CC2Y/8cEn7RNffMieeuGKXbtc6MjxA69fPrULW77mpM12zFzdMnvq9Iu2nb5gV06uWek0Th8yIzuuhEQSfCIuV8ccRI0YUL5w4Gyb/tJSvfQcRTiIdWPzQZKCggIODClANAVxspFInmPN+IknxBAxoOvDyXznU0KoQjQUL4lFdNeTkCKXFmHIY025vREB6qxAdZCvG9CRFXcHnPgBpJdakLCmKBqGSQ23qBJhJ8bzXO2J3TNGT4LgRtH+pckJKACM5hFpSizcGAS73evWm8E5U0O2tzyCA+GYKDo2plOcqP47MlVZdMYGyXeoASRLeGhmgGJO00ueS+zVg2LHtgD4Q5DJ6w4hkKsMsHnIUAM3x5kIjEqGQ09YpF64Vul2SywXYeSgLg3FOeNdbnq8HgB5iCubkg4zVNJ1isp1NQirZRqHMrlNTUUSW2Fm7W3OZt7s4mQoTLbiWYEmtL9lj9Z5OeS1KquBUggexsLK4CYb2Z/8XLCSxDJ5PwANsFFV8kDJwkVgLo14Lm8WCANG/9Ea3/r7zpm8D2tD4rlpz2OJONEj7FkdX9ZnsMO1eMe4X8xhB2anCSvZ7g+I0879NZJQvQBmYGrJFmBXkjN3HE6PAbgGHQPmGFBOnrqdrLNFQx5I0cMSSX3ONi/8+eAtSD29lZRHVAEHcyqxHRiZESJRaryMiQsgwatiKz+CtRaGy7HdIUHn0NAHMVYs6xV4siFMkuWLAg2PExCleH2qFiZ4TAU/nTVNLeXJM5asV1RApoxmJrNF/AU+O8hZw7n4DktrKhiwBU6YNgV50YaEzWG1FeRwMCvDGqbLwwmutIfOBqv6kuTx09fMEV72OvKC2y+E/Y2fvWd/7d/f7amnpouEXbuedulSDcl8Q8nI8T03nzd79NFhf+uvfto+9bkH7IHLu126YPbSfmK/9rvvtNv3cyYkr/oeB7nuyma/9b/8n/bBH7th7/k3//Sh6jaf7U7hm+QBXEfgvkSaZFYq1hsCGyavRnMZnHy5ALcrsis7oQziPo5CQgbGQyExiWOiVI5KGc2JYBqXyuAoCYUssSiFsdLnhnDDwu1fWNJVrda4DqbsAWtSXroLjGqCEpwEEXTZKw7DYn4xPaQkNsQtnBh1B2GuoRFcX8F+YmmBnl/dIYzfGi+/MyAS2noMtO0m2YslZVSplkAoKm1yaAgMIrVNETmcVSisQCSq2fAYCmSnTJWeR3AcyMBm06AbKk+FoeWGdxTGvm8mDBX3eNAEEt1lvTWukH1hzKqGtWJVJowTQQtq6dYO3RA0xWFDwiVbmHXPpKw6JxwGEXb8ZNCjnOyqVCzH6lVFmybtAh6jSmHJ81yoF/pXJZ+aeK7HGEA6Z/Nj8EGhmc1jNUQnwQjyktkk39OXncy/ZCUIxJMo4JZjKUTmsbFjkW5KQBa2GJk9y3dQz2f5pH1dYlmo5eNqyvIbSPsNeYY4iKEjqY+BTARiX0zuYPbsRGKZJQaYQJCfOLd+iDFL/sKVO5Gp1M0RDARVy29bB1FK9Yuy4w44WIsYYXgHsXHpNFXvuCesCkLjBmrWAd5qKBdhUE5OV2Xf8q0OgzHYNZYuHgB0LVDZDXMgFyUHaVsGWvDGrm8lQIEYNpBWlq1uDl5Vg0zeYc7ok0TsqgqtqGozkYEzUiaHqYvHzh0gaq2TPu7kGsOSY4c5BwaOZCRScnPyKMWHBUPWOehreb5rwKaUW29fMeYneI8DBUo+g23CC3ZZ2ejXgUaO7zwSkUffvtvf/Lkzu3K5wurhD373bkmIHL9fp4VfPzJi9c03XzR728VTe/hbn5v38cTNrtww+78/9x574iuX7PKVV0+ejodz/6Xd/sRP/Al77H337d7z9+zk4mVNfpRbeKKuCib0AzNPLh2NsJYArpEI+GM5CJtdLjSpUfISLD9yCWoHaZ+sYZ48tFfBxAF6D0Y+P3kWE+PHLJqSi1j3m8uulnmv1RB5d/GVNrRLv/BbznY5USc3ThVKw6AA7mQYdE4XkmUo8ZE0AAAgAElEQVQyoGEGmohYJf2jsXxJQPRO3nguCYIQsZ1QtEEwtfvfzvGR+e27tfx1MmCIuCIxA5yGqKeIGCS1SkZla1hKgdEzyoWK69jALW5X++EyUukrAIUUrCrtKMI9y7Fiq45MA1e4/xXUXFGZ91YMuVmSbARhbDTOZFjf2aDAOSRUGYL3MlZak6AZsNwRgc8afjKei+CmQUCGHydpxsdn5epeoqwNcOzTGy7nBxvQ9GxKDkAP4cfEIdiD4rNoOjQhPm26Ja+h3xQ6ooS0RXagCFW7jEe3MhYFC+LvYxZ41QdwGlbSYScoOFNDDPIBpwzYBlpRlwbtw0CqhxYtL085KVlOLkyU8QWdxGOfdGJVSeI6CSRvDCYDufETwp6Zi2qOiRKRIQTD2EGZMKiwQ63WJNiKBjDdLzYdwt0CVussudCVdekDU/OcqN9MnNqlnmgSZ+hTu8yoclBCaVIb8rKGouV3Muc1qAGr30uMuJ+6Mghwas61/HRnhIMI4cSnr8KKXWlufyXeasTHWgrKPLClpEhNpbQ2UFKxHeAfgYWUQtyJsuMDC1yh7DJ5JpGMoSAA0kILMS50GgkJxVtmmyFW6TckHgtKrB0e6K0i/PVfAx2jn/xL9+36NbPPf6H+bLZD91emdbyhZMRAi7t1r8Z9j+TkEEZ73wNm73v8tn3u3tvsykO3zmU762vegLhvj3/oPXZ9+3KePnlm28XJHcyWjeL+rtATRj5GmhoBSaHRJYKZlIEYDBxgZ6/GZVCi3ofqD8ta0lGELkCaBmi8AYtcfEloUGooftBXDG5OXGQQhXMdHxRo0NsznI1ZCqjFmz0e7lw+lZ/ghIWYxBzG4dtEWQ6DSoVgmFDsBta+wB34vu6bmvQcjEX2ZH9hP1aPjCQBDBTmkoWTcbLAMxvanSRQqo/ADnfloyQJevuMQfuOYGV9zVrmJ3oKUhXs93WdISOXGjzYA0d/sEpAEHST0GWaPBdRqiRkY6LEH6D6SJSIxy1Xp/bcVCwfUvQcU8k82j+CMcPhOGNB6g2k+A/W3dwHvCuahpSIlRCP7PVmWGdLqW809UyMNi96gXxkrNCW5KYRcewwdEE5aiAsLjnGzC9cXjSV9+62QEwfJUIU8ZEE9j5aVvSF64M3nfbBviQzye6RaeoDmp1lLsTYD7GyHJCFI6pOvTUU6jmUN3jzTHNZ78SimJqQvutYRtD0qFcuFJBzJ13fcrEjeSvXtUTUi8GEexRpKAfccnkG0vGY2WdQ9AsPROJyQ9VYeDSHJ1tzyM+fy4KUcP/qp5zr1y8zcIJRRQqtuWcDe8oF9pWJI4kRXJbBQkY9oz5EWQYpka+JIiiIsGRjD9BlhoWv51iB+ipJ6E64XXLWHrcV0n9k0PBoGU3QNy3ApFYeb3bRgNL65MOYN3+gAunoXgAQ0SF6uFOLK01HAi2wKfCa5FcvSRub2A6yy0BYd1B98jA1mUftxVE6aTni/u3bdU38/1d75WnY2x8f9hf/wrCnni5jjVfLC/h6w8nIy1/H+x8J/Q889gX77U8/andfMLuw7V3eLa95W+4OO332ru03TnfbLuPrpoMSn1rHAG35dOn3UyEXHHxso2CHUo1IcZhZmDH/ZtP4oEaSAOW9hJOoNVa7KoaXM6SSChOqKgWEUkm2eW48oZh3UJ1SdShNcrjNELh8UMUsCLiWd9FE8+HeCZyjgXiOwqRxloTmnPQ1EHP3aA1uREWB2w3rNHqgHItGZZJ8A1IymmKLk6KVUZhlVaK4LAX9azCusmQssoi6mepZKklc4zLi+KAqbZeNZL3rNHWACTwK+ZPxhAa4bFD+YUZDOKzjG982lUMY5qY3tKEGTBd7sFjHRn2MgAgK0iRDm0mEFNCmquNTxkObzkjDiBmV4FLpgi1nHX+uyEgcep3lvawRHSx+Y5GbNIEzTlO0+uRSYDNJnjYsM1IFnWb1rQN4oLkp/hJVBIqd3PbUWYPlKfxCs7qUyeb+SLYxyWqCeml04N975Jrd+YQbrOEgsqCHKzvmNQ7DiTLDjTEpmkRVyQcRotJWSP+xiBYRkXlAmmuhZQHr3I042KkdD0NbrGZlewsnLFPOMnz+OFRgUUPvbUD/daord1qmOWhtgBI9Dg8lK1cr8tuSgF/qJsCWrvEcEDI0e5UaaWbicq4vqu26QJXwkJOinkMPvT6v06aS0QxHezAcUH0uuFPUPl/GFsA+wT6WIJTAxVExukdj+uERs2MzsdThKNhHaiuRi+raBkdsC8Qik5ggJiTYFkC3PsaWSrRYDYTpFBTaw/jl5YKYVVhldGKoznuWO3JDRyjUk4mVyc/Qm1ILDxR60rh4mw5+7lx/28OPmH3tSbMHHnr1nOC4BbeeM/srP33fHnrQ7OZzZhcvvnYeYW9GMnJ8pufumr3/3ffsj93+A/vNjz5s73783itmQWenw+7fHfZdf/GixeXNbp8MuzQNXbLRT2KBRg9W8apxcJBSlhRhCdVLakyYqltbuZd4LmRo4eQN+roqIs/kfHDYVU+aJ8+QRqwh4e0ODXImYNYtGKUWEMbWnHJYIAW4zK60tcAFZAFIPlodQ1atCshxkKZl+uQlSRaQ8tIkS8LSxGrUZMbERRpCd0lJgMuci6WeDioh48r9cgFrFjZlc0dMB5pDcRWtaDi/EJGn0hZrEzPJxTqJPoUYTA8wNr9aOqRmXKWOx7Z3QAUuyTThYe4F2xDzaSaSJxl/S2NfIEgJZ0MRAzEeLceBg5fI9App0+m/koVYnx0C1/R2O6gVGMsFRC+IBuaISMRmKaOGEs6MHJ0gIJWnRE6Wews/j+mzMU3G8pqt0SXLFT4Nt7CCYoLoJJnaVsqZbDcSeOPMvpHii33jNYVfymXd9N4XjTEQKRDfq42fQ92d5uHoQFQvkiGXuqamXuOifGjG8Upj48Zw/2wZrM+tp0FFCm12GJ40XbCRUvQ2Ua9gUS0IUkN4UhCuyWJ5QRScZ5ptZYwXSUIAvjHFARPcjqQsoYFFX50Bv+rSO2ezipko4Lha/2g5dImuggl43cwGIKcQgpyBVqwzWL6M5qrHGmVSeTg3dN9AynryU0ImE9wbpI8OJ6vbkuhf4wPZgtiEVDo1cFDM0WpGsj6cmb6Z0U+53g9gZJLLqo0soNVWxryFmvikFCPDAT7NyzCIoi3IJAH4FA31GMXjtiKW5UQMBVn2E1JWBgraokwvOhwrgWCBMwMCJjJ3YsGRgTGaF19Ke/RRj//sP93thS+Z+YV7dm7dL69jCb74gtmDN3b74hNmN2688te9/PVNJyOGM/r+mdmHfvBZ+43fuGi//0m3q1c1E6LXMdp7707aZ//VC/7428/8wrWLmN3nc2hyZaMgCcVq74WOWpiiHVi6o4IVxi26goAgdwnalfTkLIQH1De5ofnzkeqCAzsMtlSax8ElA/6mdmJ6p5JNCd01oTXg3GpFqis7dWQhvYs1bgXgUopuCU8lmCXU6dLTI6wfjIZOmabCFI3z+ROhkDaJ0xszE5dGfbcsG2jnvYR1rugcyKUG78IskSI1+FEvsmZXYMSdhuVVdgYrKk+xvLpM8628EYYt0wSE5B3Oh0OuNfwEam4HcxdhxCSIEUA2HRsZ4nI5nbjhr4rstJZQC1yTgMRx34QVc8zCNX1kJ8eGMvt4pts8ewc7b4Nq55Rs0bmtPU9ujUJ0JRjInfZUR9nIHSSGnhjRUecFQtTJ4j9F1zWmmrrRmoKhw0no/hraeOV0PIVEQiF3gam5kmYCpcdLhS62qGiyYMXvCwKFBQCW+sGY8jCIxemiR9XmCwzWiflQ49sxLYLHAKK/HGiQgRtMFxt1G4GEeqdbaz3y2Op2wWt8IiSVtPkoLMwpKIqyoPwama7zgFKN3UzmYwAwo23Nipk4fCEaG0iSQNwG1jfOk3P1H1sgKSl1wAuO2mocCvZFN/VGYAO974Q1U61XxCazpdHUUL8A1VzWV48+kZ9UEY/NpPIkqDnwQRFAq1vg5Go2AocRQ6z4bXJcoPsWACRKQoTzxJiuq4QspkstNitLz4AV01wlex3bdKFzHOJjxrOpLeUQ3FON6F3cCWPYJ4gs9VVmdrg+WOTCaxcfWloxYyTrrkZVNC6ccKqiV0aAWyorhRwsJpTwwBkecMfoQbDae3UeoomVRUHEwZq+xVQHz4pWduWSj/v3w/6nX3L74h+YXX7gRMtMOiKoaZ6/6fbhf/vUfvjP2UxGXu/rTUlGjgt69mtm731f2s/93Ffs1//RVbtxncqQtrCC0vI07f/62Efzex5/1/j+H/5TNu7gSB1JkUYEvc2XKLyk8FS5PJ48V0M6MPFR4bWcIpKds0K1VpL7cDqrBKFUwKoD3bzEcBlTmWyKx/H+7FLPUMemw1y7R8AKPtLQsUh5zIKqB/QfEAIdhjbsR3RWzQGWWqIVcQPqN0PG/8plSN4bYmFRnGkoV5rfGjr7l4wjKAg+z0m8ZVECgZVA7tmJXlZF3t5ANMLYUeREfeFYwhfKyhAeCrphQ5IpyTkeuVOxxAW01NDTMdZ2/ADfhWmR0+Gzy5n4mKZ+ulANOAVUYVo1K/11kNgGu8+bsKHAhFddX2EtKTu2wXuTKjbxocleb8ZmDZOIkIqxfs0UkLKGa27UnjmU7yVhgUS3WQPIAxC45xSwqIaYzmKb0+i9XB3utflV59KktZRDSkKvUd214hIybx6udwN9izMYFHNZp0rUxmAujYl+OWKW2QmczQV9egnO1u/3aUVfQ2WYvCJjoDW72BmYbBGY/CGpKAWUmVaqX4Ca37k+Fs6gUSUiQh0KYoL84T367pUYz9QWPs1MSMnGHFGoWTDaTKqws7vWjnzq2aqJU+/v5HctOPB84KU+vhcaT/UcagaPwDk96JHiJLmwjyPYhxiVNv8iY46x8vkWG+0wESkjSQ2aig1Lx0RcV2MfQIgcS/YSoYX9FfslLpybkElL46HznixUAk1XpgyDrRN1gkoNPjntihBP+rYmJPvGKHd0xPsjRS3COXgb0ujIAHt71ypXM0dhkCu10uPoOpAdZu/4DkiY5wKIZCxFu6nn3IEoqOvShqQI2PMiyE88HXPQuPtkx0YA/+W8cByjuHF6NuwffiTs7k37o6mDWlJu20na2x4ZdveeaVLs9bzelGSEr68+a/bnf/jUPviDzy+Ibn3Sq1frwi4eB94Fs3/y3KN284XNblwAHdpFQiNJh0m4D6Tn9WTHIOTsHEHCw51Y06zgB/l0RRannGOC7EiRitmxS+LmxwmKXqaRcRDCuiZeim7mMvYJTa25fOMY+vbRAhYLgFb9OAjzjlHDbkhnJBRcC3KocVv+HxBKMNEujz49PZdIdfDB7SS1jaQTSiVViFoDM2FgUANAKGd3nZWE0DsZCLrANJOwuu/dOyf/tuBOzGTXRsW4CPgHc8R/On8ZZXoSgRhnwoIBzK8ZRQzo0eJclFrQUsCPJ0BeUX8Q9oxGR0yjFNOggXklWS1cAFV1salQRGqKKBD1E5ZQvLpB/FTZAVcAqYIOljE6P4x4CBU46aqVD0yJ8gxOV/uciSJ6lAJgHQUdVyXQBPzYiSgceyiqHIWc8cw0izXgrHtVYoUinyhGhJaUW2RwwBTlLG99rWfXVkFXPuSGOsjr5IgxCcWWot0PX9yE1N2U0QvJ4LD8baI7FapM6Vwd/6I3j0HyX4+NeSX2NVqCI2eO/yLBX+a1U5gO82hxIFjrMHtwkQ+IrGO5z49Q6kVxCG0j9DeoAu9Q508w9OpI+Ri0NTBcHlX1BvHklU87ytKlaGIjZBpqEGAB4qpwfRgfDS8XBBQjXrsQiyTqHge7bTzotDF1pRUo20AbxIsK6lJRDQf+LMoz8EhXNG+ubGJU/YBIYql1kg1cxHSnZykGpolDF3w5pGTPRt3A1HOSC6LIW2tlsCeT/ChGeFt4q3Eeno2puv6IkG/rOZMRNl+8Gee8d6GTwQjvspzhRB6f2Dq/SJb+pFolGPk+SIbr+SFwqyh1WOG6tuEsX2P+U4on1e23/X3flvbM581uvKXGgA7Duw//5fv2539kn+f/QXp94Fra1Stmzz77xvKHNy0ZmSSIUUImDzxQfaLjv4+L+urXzH75Vy/MT3n7VtrNm7t950+dbN/9fre8P7N45N8ohCBbEykx7OP0Dho9qJow8sDnHd3UYoDJd1XvuU8JqeKK4PC1EFGn4iSm/4scXXSQCAiDkaDPLQVpBOCZh+bvmNSAzdYjdL45mUIL1X+2+meYHjje2QlkWhUQsQGTdhKLBNbiNpUwdXcVJ2TiKCuY0g2D8k/di62NYeYN3nPKpu87iA3i3shrqT40YqvOayZiAVfHLJ5HbEil3NubrtRfktgP9QCGyXZJZxvaJk6xSVw5evs+goxDxz0yqLgONCZo0Ft88Glsi2GROpdnbKqBivSlvSKquuQAOABazf9RlXpuoogJJ5/XuyMYbKIlYHFhCmT0og10Z6XEbmyUlDeTwzDCZRWADkXCrbXuUXGX2ecaUfy8LcVDdCWRGAAfPe7kvdLYpiEJnGarZTMCLhSOqvn5wxjOBwm1IaeNrXbf/PZtEe+ZFKc4Ar9sPdArrcxp0IoHnuwSfqrBpen3ZqW/z0hTULzrZJ6raVs00JdzeGY/E9GPhBcc50y4hIofMYk3UQsqcG5hB84+j5symFSvEeoYR/q4NTPMZDVwXD8mj7damWiHQA4ztyz3tKzwlHWCbnBirNQCIAJbpFTpGaLuAzLt4hdfvUPBb7Dqkao1w3YW3FSfdQDak22zVTAc83FHONn6FVwqWs8G6kH842h04LDcO9iRItkyY4aBd0zvJQ8RzTSDIjorF7XbJdsI2ahmJqp3VbXHBjc8s44PxiYMeL9ze+6J0W5Wwyl8bPdmEB07YyN4d7x/AP0aRDInCrGxCqD7nNoj0As0aj3DHDZJk6rIqvapy4sC/KMMmBMBeoSFsnNADOrCJjdqzohVEDlOq9p97T8wltZXSrvTWXXV4Tn2AmFefMH29zzu+d//vd0+8dtmp3mnlpq7fef7c9rFvO3RmrA9O1umbalD+jpebyoywhB4/77Z6WklIy8dQ6ph9n3ftU/VtZdumf2d/yLtwp+0+KEfM7t9F9p95dYzDRfqNnE6cea1zqNScwM0+zLwHbzckqogCXTjmv2TmyGuGyv16jYXmQpUWB7hPpxd50rEqyimxDX55YOECxTepZPTLiAlrxTTgGqzHa2jwPWZq1ts1VVA1BoYeXVMXZEzquMdlBRndj1KoJFwZnqAnLZ4XWgZpzfzb3Ija4sHjHE1LTIjO4L0AIGTwygAwuEFCriVHFQWyfVnsxpP0UIlhhbV1ySJrMp5RJPpoe88qh0SmaO0QDCHgCI9SjMrqHtE89/Y6s60wUXu0MCLmq2dUAGUD+bH3VFXBUf+1XVOoF91PkGBwo2OVGWaT2X2Yu7heY0+uVw+FalsjiFkZfujxV694EWLAq2tYTLEjQOOh2zbcYyuxBsUZSChDkRRN1KAQQOfs8ZV9owjxDrmL0Zr82G2OXKwRzTQqgjKxiPzhtWLJ1m5Dt0pUi0Lp6lTljCbQ5ck+CHFzqNuF0wxCxUXGbIoSuBcZDfg2AxwdMC7SdWEmhBASjyI/f9kWwgZ9kECdyh55lazmTGob9FaeF77x2AaFZgFqTII9s9D9z6l4j/AHHSmEkDUOEuCSU0n50MdvAT72asXQklYaIYYe54k4W/qrmhiy8F25bSKptmIFAGpFz++0q1jrw0Jw9aE6fAuwzAReQBRQbxXagdaxQYxxRmsSKWeagYkEQk1aD0WhPtIjc0PIk5FftvSdRaQ8wXC4WhjZUkozVP32Blno7SioDUAIl2sRqnl31dMdfRoeX+iUAoby94il2b+TexZiIMLzEWrtHR1k8zIEDkSS30w8mD9Fho51QqC8RXlnFEWoVhWHIWbjfpS6kplZBx6nrzJ8um04LRXuaDUsTNmQnbcotP7ZpcuDf/+70t74Smz26dm9+6a3bmbM/H42k1T/qhd+AZfb2oysr4SeNsZ/PT+2HcMu37d7FvfZfbhnzT7H34v9qefHnb9woa0O8nXG3DskRsJLCWglgDku5WSpC/IApSdEQ5DqtkCQ9BAO5QN1wRnwI27iwmwhN/pp183uoBXEvXgV6G8Gp2zwv7RRtWkzMCmnBkBeoI6boa6dguzKVnaOYZXEyRJo+roUKIGMmw2cMR9i5q4dtdAEOeJDvCTulVd/FVfjIRUwpeYgGGHAQMf7amB5YjHE0Ux4TPCMEyF3+L8O/aGvpcZPJpFAwArYXAFbappI5AS6TYWCOzkOtmM6ZRtBJ6LJqsplurcqkoyAEGZ1HdFihdguuZ7hOdJxOb74/7OYCFOCbu8OBGkVtLfBIWLjbR5XJyGcsEl3loNQmqurTTeMqhr+5IwkjHyIfFOHlgso2cjARefq9A10RVWZMIPna4a4tV0yxVjhezdtdCoNQwGLNFZ7JkmTdVHJZJYB9SGxs/sXoRuKnt2OBmKLkCM0sN5VKfa6FwBDbtPbsomKBWxnMJDrIUgL19TMK0YTCSNM98QVHPuvqME8xqc6r629hGH9JpVvcwBi9KUze5S1xATVEOGJpxsYu/P1IRlGythdNN+mSBTBsCVUNpZW57LKM9v+4R8MhfQzIW3esIAQbpZhcRIiowZa3ceDVIWoICDUCzBKo+myOiO8W05vsUGNFYqu7C01mZPL7hEOcVPtZElRU5FFI7NhBoylGPKoaiQmBqejaKtBZDEbJoTUQDnArGCY+NGIj+ap1vXkkmFP/XzcKoUOiKvq6g+VwC9wugbAcFi0U8N4s2Iwq/kMsbRai5Z2rWHhj/95eE/89fDnvncMU1zyS5fNvv5//CenbxJWcTJAaXMNjXgFJJNXZGvWzB8jXFeTY3fx9fMprAPtgJv7ctfNvuVX7lmz3wp7D/4G++3d77rsr+437G8eB2jZ5MJMauw8MmKmhr89BOx5CxtIOmmFpRj5I8I2zwYw6QEwfMQi0i8pfp+lUHge2Ma09POsKej+gOlqY2scypFzLSTxq5lN5A8QKJI+sOrboGqBUoPJLXzlEfjaBSXenYCIKQzMJ0XODKPI3ErSX1MQoxOjNHYqc2x1U+GuwFkA9LJP50gEXoXHFnDVFsAbajla6SF1RFqaBZjByyc8VEW9TOwAm93hjCcYJTjOiqIqB2lGQ6Upxw7wXE92FNA3Vcd2wm7A6oec4yn/AdqMqUmcYLH8oQ/as1UGhiJwnEDR9nrZpceAT4iPTU7M5p1b86+z/xH5ADNH7HSmfFyq4mm6dlZTieVI25Es3RmzFYy9Wx1LpiazhRRhE4VKyrMN2D9C02ur3AMghi4zkY03mzHGEXU862yM0qr5ein4BbN9DAGYxoSPx3jw4ns78mmnYth6GxfH/0V4lWK/1DzLtB9rMCf6LxUzqzZ1eDIjHgobKpZEQbFxGHyMwDdqcUv3gIupHx/RlaXRVJno0p/on+YXDAWvNWyieo7HHVygVPAnIaY9JEs3cuyG33HdRTPmUSMDN+2nPO6Z+wxTKfxyOXUQ/+wmRHGu8On33+bXv2qURcV3rP2TG84gsqqgNGo1Cn4xGyfsG4lTaO5t9UvcC147M7k1C3sujYxlkCM1FYpqU8quPCb12FGsIqZ2RBygvR2zvgB4dhg3+v4AFF/zxpK+IrkYwoRTxKGcKqj+7JzYhPG8ewhcgROKdxeOHJi8JrJElcb3LNK8mapIpj5lroIenyggc2wU+fajM/GtC+qpHM0PQtoQ4lkA4LDRo5cPcqp/IOiVHMaNS6ExRgFt40lcskquciv1V3PcWIep8d/XzwZY7+f+dGPuj33zPH1F+wv/Nh9+5b3mD35Jcj05/m8wazzA0q/v5L4Gb/n5GinHP9x5UonGGsycfzZ0V65cKF+f2RBxw84WjHH749f7BPxldkJCy/w3e8y+/znLtnHPn7dfvCH3u/X3nHTTy6fzgcZI2t6LrqdW3Etkgg2lTSLVIguepV8g0ekU8ES27JShmP2wODpKaIjEphRAweUGQ/NCYv97UOjjzArx8kBjR6vexaI1iYJafLrKlmekPteeHKAYTgt6WkwUZsi5VoxN84OfCAVdeqf9BTyUWLnHL6T8naQ4wWCDMkLResCAooAEjAl5fYl6ruQ9UKUcDaeFyNJFDZFTQxx71RNM/9LCBCVI20IF68YnhBe8VBiQvlAJD8oCEJcfcXWhDHEHElTm6z4iIHaI+ES5eA+4Pqr8Rtg/pG8zwuzUjxHtjcGZDmbVVkEonRa2beEOgJ1dnBRdKGcAIHcijYz4kfJXha/kfIk4xxeZggfUcRlqOJy5IIzY1VbjRp5GUFObRlcy2atkJAB5ncgdS8OVM0FtPpfBdpoeQaC6G0j3D4BxQ4vyIycsN3gu4NZSZf+KSbCZz/B0XIsQ0Aj0Y4dx+re1FKU0kaSwHXOd9+1VYE9rs0ECNXE7ti/c4JMFtfsioa4u9BcTyi7oiXoldVxZgJHfl3ZXCtDmVhilJJzX3WG7kkyjqYeODfOLc9yFUMegcl8ZBcGInLVt2R1QIyInzlYMuhecO4MEl3sm6xCY0YNgOrDDqkX85nhUQdbs6IgD2EZXB9dx7O7YiUvU9+1FaeXTV5oJ2DYK+BonyIMHXNB6OOg78VQB2hkR5YLRIh2f8P73ktDDrSqhsGxVjTpWOP8cCia3ItQMwtmvywOQASuWB6DPVNZS6ak25Qa8nzjoAbxQsI5hpNxTkZnrrbugKrQd6dhQ72FEXKdHbbje/ZxDKEFeVWYga8r3Lxxb4cwwE5MIva0cebbgRC+/Z02k5E4Gfazf/3+bNEwR9B8wPI68oYjUB15xr53XrC++H0nTz/dhNMV5Wjzpko2LsPo5njz443v3atE5Pja4/dHMsLvOf7+K1+p3x9//tjbzG7fMTBe1ygAACAASURBVPvqS5tde+ie3X3Y4+J2TACRTwZhFgeOTL42jj7MizDgzfjiEb50RNbRwXOGSwbqNJQkFy0ksLGAjsTusVduAmX+oA/KoGEQoTH2Lua3bxixGovas44p/JeDlzII1po8+uurNkiazMSsmr+ugcBFv9HAGSGIEMWLqNllF1sFGk9KUst4A/PoA3cNxksp2apmFXBUsZDwUeJq3e8l7GF0V5h0Lum5LEcBcptg0cO9xQ6G1D7Wnw9PimBVAe2W9H0+ZE5QBWdY0JKXf7KqoNSMC5Ncjq8N0X1zUNbMiUguJE83qTiMDI2cqIgVXbGiJzIHaur2gkE9GxChG91kcIa30Y7huHDXCsLuoNsuuxSc6COLoO4oorhN780ae6j7UEwJVNQRGBQ4vrRCUY0lcv6Kz8i7nwe+NI7IIIkui9iMb0izpY0CNp2kR/EbDxolURCv21qAiHC7J5jN+oFcR/QW2bV1kyiGLymweovIPlQpcE8FJYlq0QGNOyqATSzjEqt191zOgHK3U7MhnTng4C0pxCqcKcgMRLuRJ5XyWK27zSEGW8anwbT3Ul8L4/7Fv8g1MpecKweQa4CN3BnADPP45svZRsUu3DDlpCYDB8HQ4JxII0np6mYGV3HQeIMze44gXTdtHNz25ORRaTUWSbpwJRq7cfiNU0Vsc8Xk6mzhUESUGpKhHAWeo9BD5VBOLtedC6DJtlWeD0l1tU3QFBvFn8PqVfow0qnkxNZmqBEHliHmG9kFIlJK6gCyVqY5oB0klx7SXxLHgjUqrXpiPqdhtFvttwo1GEFI7v3HvrbPluBaMzi3NmrVzbEGQO8pSbQZ20mqjy3P9nqPy5fMfudfbHbxz+52547ZtWvnyapCO04O6Xizmzeb0HpM1h6/jt8ff3b8vZEzsiIZ6xvx72yBW9bshkjKK2VE6/c/8hazX/r1G/apL161x95x157+tn2/eH3sD90ys4szIzmjwEUti5qPNSULDmXsHQf0zFp2SgvOZ78B7B1QZz4yu4HUsEI95BtlCLMjM+bOGnCPD9Q5OzmehWU4ga9jBPj4iz0IsMBrdsoa4gyCXn0Hbyehw6jVuzMD922hVIR2wc7evw7F8jGnIdMuaVMwQfHD6KmxFzXFQNhTvgzaZV0/MoYBSilwmvkw9t5RoHdDZ24YpEw1SUljsfrU+MQI9cCIWlQqcFzu1aMaMAudDqB4w/nAB22Lgd2n2tyO5g8Hnt1AqCnMCUDCHuL4AZsaRMbYqnayvwaIwEVrqIrlaHXXBt0WfS5yikpLgKYS7aSZVGut6/MlM5xPf1PQ2Iu+Bq60gyjdKuO7ohKGggIqdriWHZTDCF4fcH0sPPipzmBOSsacywAHa4eG6Qz2lUcVuzlnzPNdqErPHlVrvs4c0heqJ0ep8uEcJhiszgjmlIQgp3Art+SJgSc/2kuSOvRgvCxWCTDR3amYOJ/PkRyMveZY63DeTRfAxmwO5duGueEA9wZ4IFgyPvZK8iUqRSLyTO6mxttAsjZbbYVgJKx35g3dyQMt3KGoN9n6LDsObPaWq3FryGJmVoT9N6ls2AEDZXO142pLbJUB8xAHbLLPjRZST5K1A3bRTlEY8CjYNyn2bfoe1d8O6BJM3L4GjuYD3GHrxM2eVEOEyJGgwsAxHzU/QFXiMbvESYu+NM2214+r9V9dt4RsOprSEEyns+EBN5XluuJ5EjPmZAh6027U9p5kPSd3+ugrHXXLTEWODTO4PjEZIzZJAl+JvQRk0YIKnA9DRc8ZMyrvjVxoWK2mndpKqfg5O5cbMJEdga4aiTBeQzwxyPTDwsLwfFAKFHqyCz9hq6YGu9naHzgTZnxI0HoTmOgIE24ygaCJdOZ49qtuH/qA2c/+zTv29DMFOhxgxssRD+YQR77A/IB8xld7naz8kDfjdVzQgw+aXbxQF3LtAbMnnzb7xx+9YW+5dmbbadrDt80vnLmdutkFlOqZfiLcCZvzHOsnjVKo/LjJYc5kUxptfiegt8GupjYdCxKACNlQ444OnsTugNr54Kh4nXduO6TcgnzLOb87kvl5l9aJXC18mbMgaJOgY4xAmkt8eMDGa77vxkQJ/WoUgt1d552A+nBhL9RbgP7AbGSRwodhRfBw+A5UOEL9yDuoZqLvkykZFAPh11LQydbjpi4GNBXByLN8A40nu4WrrhyLMTzYFMQFRSHwvupekgRGJmcdAzX8yu4S7/Ii4eG1AbtXjhqb7eGeImINXe8/mI+6dXvGyHNYirSKMzNqzNDIIMxqGZ9stIppEntDR6Tt2LW4bJEGiFon2afjIV8JQJ7FESEJjF86k4bqDVauAokb39VXmd94MsvFjQAXRKhHiuUhljFmZQuSwBxHfX562xMLExMg0C8hkGOkUHAyJQZHvCW+qVYdkKaaa8tgAwDDSkNIFQQkEPwJCpCLXj8i2pOqktwZh3HlFGvh+ZBQJ+OuHo0ADa8efiKtj8rzCkWpOdmRoDl6Eb5qTJk1EAVJmWeVEsXMOdEbMOGcuiYvRTP2PIL765xxc6Ysn3DAODXeyWs3uuIaAY/Zh055mATIW9VKLj40p18zObIDpmXlsjX+EecCFGISr8uoapkYJ/Xg/u6rWQBmua9UhV9jL+Jda/TdOPOgUZkZXzR4y5oQPHQMkHkLoSASDBkJgKE2p8iaRTmSVt/DODUHsyWcH3GOpI+fneRfdcuTexISa3NBFLa7mh7V3pTiUBHzsHXK1IMsrmL1kmTJrlBzshHTqSyYPFh82alOGlDg/CtLBKvgv9+6Hfn2x9L+9i+Yfcd3pT35pNmLt6oz8vVM8HgHXyvXeFOnaY4LevRhs3/2zy/b7/w/D9hDN/YJx3z28yf2/FfcHrx6z+7fMbvxnPvJO+xkD7YcZ7UcVcFl2hmIf1jskhknsaOwkc0p5ZkqCtFRG5xwrxU/tAWpGXrc9hPQgdQcnE2XdJKNTlICOKwAqq6F5VaQuKfOgBM3n/+1cepEYRXZYelVJ1BiL8UA1ECGL3K3k2Rh2ZoTCwnettHQzsD5NP3Utiohp+4E0jHQpQA+1mj9hj9RP94xaBS5HzSbDRU7xV5sUdXC+T5QcjqprsHIWZ+OUxiKD8EIOdFSHJCQQaCMwTLTApgXxW24bSkNLQlOFx2kYsRWFUwWVibHT9iPZ2wD0FnNMiAOV7JlLPhxRgTQtqPgdnZmUpQA0glKnwHPJSa0UGEvjmZ3YWDgkHSKM+vZpPAvWTXumCmeO/sEFVDSXbT4FtS5nzL6FQf3wU4BqX/FRlb3Ek8e7TV0LuSPOMRbakOL6RZAnfRuh5LKY7jXwIXEog4t8Jq5KjtuHp0VSIvsF3OZ1o4+yOE1EbYZPj+0hV2dTaAkQx62sLXWhqvJl+z8NqhqlqMEiA/MZwA7LB63nIEZrye+Volfbr21R8lBrVram53gw081kGor+1bvtJP9gLMR3XmfWDgz1K0UPeb+x2xJBIt2o01COrwAjVoEhCs3Hu/qEJIvU9e1jUBWB53IwnwHx/83AltwiyM0ggNjbNi0A9W7lxckiRJT+x+ZLMdJuoFUK0qCQewK1acYmDoXPwZCZNP5oWD6iMnTr8yZLXaUL/O0GIX51P7aa+TP0ZMqTLdmzArXICa6KdUpDTknMwAvDSlajC3FikFfI0VeYAaJdnBiTI2aB3PXVtchON1TIIQwxiiEmMsNkD+UeOad32a6HctwlqHQ8471VpknMWJy5PH5sULqB6EZxnpqng4lvjkGW3JFVKyPeJwvM14f4e9w/b90MU9eeNHtN3/L7JF3mN16qc7869fMLlxsfujh5H/n7hsHOd60ZOS4kOOiXrjl9su/+oh9/gsX7caNfaIjly+lvfXhMzs7dfMLZvdjnxMfuHOQ6c05UKN4h8LWOaLLjqDqCmloaEChO3QEiWc/O0ggWtGEKjsl70CfMZL25ytI4aa03RgyWwddroYcmHRo6DB5OXJ0WY0svUWSBwaPnQ0NaWQPJP7eXDaD0AnWJVmDvTFGT5IjNFSBFoH1x41XzU18eYSRZ7BshYPsdOyYpMvqAaxTn8KJWoKCzbQYgkpMCIfOWn4jpxU55FdPVvcPGWWXw3jIdagPljFM6+rhBSGdDRBa0uUT1UFyRMe6bZ7LJ53zLuokGZgZREIguxqdCOOIhxyeJLpYvSAeD6bRdXVghPArNMbH4ielVqOu/QbO5JA+Ra/NdZyHbKGGezQQVIYs8P6pYLS3moa+O/iZl/jBHESBEJFTjbSu7hoEBvMyl5xptNJ/gnnMfeyor9UIGpynwP5J1d+kH5qUTtGxgZeJG/2i1LEsYIlOK7RLNaOLS5HTRimWzUoCTh+kt4L9SWJnDbUyed9rYs355DEbRxQXxT6F50UQ6aeLmcwaZHNCIAR1Ma1OJBAQIyeM8HwglUuKedIni1lVif3WSpfgrIHTPXMjKtWCMUyuOEPnXAKBxi4iG8vbetgow7W9qTVW6z3Aya34MMSWC44kM/46yaiGr6S1rxebGicFGzpJKGMIzxXjHvAAMKei6AzsdqzjUh1xXjlxiqF5dYR4yI0Z8Ub6iJGnO8+MEZjlZ7cRKcNMimqKYiPcqlQgeUq1sPBkCiyDUZmVrbLbbUuscaLGoyg42MOYSmp4tOfE+6dzBXYH8RzIPv/jDH+L+bdpPTD88pV9v3gh7b/+RbNf/bXLdnrf7ey+2S/8wj370J8b9pWvlgLr1WvFCaHw2et9vXnJiJm99eCG/IMrsy3zvvfeAiRYr/3Y9PMwHHb39AW7uN/3bbs2cebaK1CIg7jAxmlV7Eo6JAzRkR3qmrSTXlAIjs8NYzHY3VlNYIFsQKnmkerdr0kLx1qNXQ1CCATgSQxpXw6NgGeiuzoBFdCveJ6R7VEEpiURclsDF2tOo8wJVrVx4MspM9SJaMIUljduJjCyyK2rHDQnTJNUCCWQA2XInB8RcMeCQuQnIbtu0hQ2AeqNMKCAqA08CthU5Kn+h8OgSTQEIzmP4BZvCEU0CflUh4v9Nla1GmaUtHnNKSbxJaNnYfEdwIJly4rlEeXFQ/GSavP1nHjUYQAP434LJEmdG7Jnl6O7v6aTLzCUhZ93s0LkrFxiCqkQRA9SPkM1nuKCskTtBZXXOfjSIw5uymA3Nkidb3sAPg2jO+Q/nVIwGrpyCXDW+5RwGLvcBOF7UFITo8puyeOELx1g5RhNsyaXfB5ywOPqRpeVLdsQ6QurBVsXLTvh08YJsGQbI2EYwq2G8UeNsLazO5tjRd4NYVI8KOc+kjIbi9tcnola+RijCOi7kZYKLSOTuFzP+uI7NVSToefP46Z4VRAso/K4JlxQOS0SeCToDqatvTZ66SyD6UyrSRZqIdC6gIGuIgWVF2EOjJnNc3bek5HLDTpIUFS0UXLFWpSXO5BgzLfeENoRExy2A9A2SPp6V9Nmk22AqDQ+ae7nj+ReSGhVkDXleHbVFNqrP4/RpC5Y0OJlbYQtNvrO0YyJzhaYeTfBM8Y9AxvvosSMTtbN6IhBluMotawNiC+p/liI1tFEpPGlSyUAB/0t4W7AOGdqdXokGcfrqScxQ7Sb/Zf/1SX7H38p7f6p2Z3bbg+/Ne3v/Od37S0PFXryel9vWjJy41rNG3/snz5oD18veuQiO1y34GB+7mHX8oG4GGd5JOZGT49wRf2KOoAqF243w0pMDe5lJFbkdF+MhcKkvuQ6YKvLG7ZUXxAqwLNKJ+wfhqlAKITQm1ua/sQoqqxGksPa+1gWE/DyDYYNBiZSh2Q20s+REZziS4ZQXQs6BB+aki5VsqTOcFKy60+nPUNXwXI1ARRCvmAtT48lmab0pqjmHAoTk7SEQxDamYYknHRTqXd7tXSuF9aIDsADGEZ4avgmuPFY1STpVyBjGvEYJp/oeHIqtFHjPkiJzBgmoxPzBGwGBGOwhAxVWDVdeUFXB4rL7VzSYUa9C0J8xNWlRoZMm+t0fmdIfGxapDit0S01FCjBKTyCc032wa3gpUMTi6WFk2SPQ9uZwA9dt/HroE5VE/D71BINiW85Z0K9M3AhVmqNwZN1UckAF7uRqdCzYSS2fWnTybvImXBWg5Q61moKckUbrWyhRBVaN6b5m77e1P8vCRm3ihll11jbM3lgkrLomVDHmMrnYMQ7ASS37E8oLS3Dabwt5wRoNxVXKo3NNe8ghaIO7fmfZ0nRu7rWTUidceRn/qsUklKcuoG5vCLSUJ5lL4vJ5BxYkH6AsEFGgRAgHpuSwRXjN3sMNbP3HY/SAYoOMCoVMYikZanjoZWq/Z+SuXZBkZoQ4dNK1C3oIo5yHSi1CJzsiNi8P7y+Oe1DtdlyG2YwdLRLcdh7cJpYxZUPsTQnOT03fnxlOcHhncE2PRceuLpYxqWPV0t4QGYll3i2ds5ZrAo56Zw85R5Uw5da8tgS1si1vt/RnSoB7aKjH+fXRm7ItQc7z7971+yLnwut4xdubvYPP3LB/vbfOn1Dycgb8NR79ddxgUcW9H98/Jp97olLduM6SZJ+/hd38sVLk8OLDXnsneND+j6WhaToYKoksChgiYkGYhpHVOcDif5YDZkPU+W5GYdCaxliEr4wt2GUI8TaT1ZFwUUbnf7obMJUQ43HOOsLYqtSDyA7D/921EYJxURTSxD+uopes5UxavDbyDkhz6URVFnklduFcgqQa7lYnXvfjNN9g1Xw0PwmK+eAMMq8io1oEiIKyDOcGjEmejuiVeiE6nwocuml4XxsC2798iIFEN6QADdNH5LzbKKKpS5GY6l8QtyoS2pCAZH5FEbX5vUWQ3hCddSnhFzF8NEMRE0wZe99t7ajVQ6D/t1QldcYVq2xod9ymxiZEQ7sgJWhvtH1cYVwkMbJyAk+D2ST8OyRNpLi33mZEd/dIdtCd+z5lRBN0MG2JHasxzE8QYUS25mZd0bBgX3c2z6DJSTRrEoOd/fqUa3Wjf+5P3fTPIZw9gCVujgSqlEqiQ8obnh/lmTCHIoIxvtKxqSxlMQxG+iD1s1HVimrANAN6uCjUJg3fqczY67/xcW5TE+ceiE+PWJHJ+Q9VVE7KYgaWq/DtM4uNV7CCO58BpoH7Scx9by68Sio8GUJGz+Akw2Z6sRi0VcPDvkjw3R9PobEKJcZZ0opNNB11Nr684QcunXGdhS+S6nBnjLe38BB6RF79FkC92AknMka8dJ2Kw5BGQbJiND0nPCYjUYFVIAoX5MABSRrIkjwSNcRjfjgAWH9M/5XKUXrJ6JpLsIiC1JbhywR/zmzYJ3OLhVL8hGpgCBxsCi0hXJF6XxXfTBZFSPUSltC16WLlZxcu5Z2/Ua912/9081uPmd28eLrTCLeSDJyZIOHxsjxa+0DHRd347rZl542+9g/u2FveUvZPdor/UIEO2ZuD4OiwCEcTk0LbjMdjQaZ5d48JeHJFW/0qzNKY2N4U+TGVv/QFH+2jYMthEFlnGOqUmpp1voNzNv7FN9zwSR4qg7UakDlyfgguaj5+2AbQa2O3tQKJ/gOFB1zUwXbP+fRZxfjhHuxJFCHddDqrjOS4YH5Pzg0nfN55gQdKwq3pRSHWR5iZIXbkiE5Du1IghlF1ZssUlwYU4N+GHjKId8flaiMfbIYj/o9G5wZYCJgI1MDi8OfZ2jekUbPwGOoxXM55GrpbMLIcIvQLsZsMAUFGL1jgaPhsFbLL7XuVWU3BaLfn8iAaB/W10cQgUpKS/sp0cKZdhMmVLuuxbs91HGTls5L1TOoPTs6C+FosSnL1mwXbYmCA+W8/3Fusu1ckBtLImbtQq5EcbDvT/pTepd8oozx0eP6tlJ+qrkmatGSduckVTTFJcHHc/2/0/9tCJCuHuSAsUgDXrwceIWHaDO1f8ii0DesB02oIJE6kocgU7bSeAZR2FbbHqcstSu4H6YWDCAl8oXZyqosO/rAgSrbTIKWopxDV5OQyEPdG0kD1KE9OiAYyrOYi7nKk1DCXB9B1Af0GfQoZzkTLo6bgt7EZkhjC5exjOFTby2VoSjiiNYDSzS8+Vi01kD8gqE4dJoo24P8WjvRaZvFPwVYwTpv/sWw5jOpYNQMUVJjoC9USA+DAZMIBlTtHTgHCcFDe4XjdQhjnThkqdkQzeCNbolErUb9b/yRNrCMyrBGATf3XRFNMaC4iEBo/ZBf+XX8iEtX077w2bBPfNLt8Xe+frO8V01GVlDjSD4OYZNDIO2pp8xefLH+jH93CJ78xkcfsme+dNkeuZ52IcMu2Kv/euBO5MnuY0d8zqD6Bvq2oTWBO9aRuUs1xNEsDvq0LmUy0QRtUwobroohDePWyUeBhcxyj50NtlKZoYZhEyMuMScg4WxJEizVRlU3lgcny+mkOHJ0adjAjJN3BRhnSS640Qfcl0jRxGINVTXNoeFFiCvgQl616hk9e+GznsACz4LB6g4PiJiY+FipnnsfS6rQNLjQVTxP0w4/vF91PWPlqzLrb+sNVHY4rIj9I8pXjunLGzRnwTBIyb/PWL6MX4cpBtWX0RsxX3a9WmaobhMHL/PcSia5mAdaSE6Mzs+1MxmyO1otFYx3QPHWz+9Ays9XbM+S2XE6Vevw2Y3B1JUj6H2W/ZX46dWP10NUErIGj56loOABp567wUqWePO7GKyz679sX4Nyxl7m58CpYFOTnyk5/b1evy1yU57nn/Fyu8POnQzIZyCutSBPvt6nGopA86sr+ARjvBZEIa1GgJC9MsFQZmu9OmfL+HfL/Z97VBChG4W7UrltdoKsdx79eRJKNeGyFs1etM3/0kofXZxlwUtItpX8gM3RlTbad7yewSczmH/Cd2nNwpZSAAmuD+2vJPfZjAMBwVwom6ZircLOusW5BonU8U4Gkeg6uJfZB+XDnHnoolCD03jPzneZDM77F7ECJ8L2mYjHZr1mk+4mS9xITPIFRBwoLaz9i/2SujPn72B0AqSNudR8E7HZXKwQRsLRHSUzCeA3JLlTcDhQ14zY1232aq9DjfX4hv/u71+abRryTL7e61WTkVXO/fj/gxl7qKh97Wv1+6m46maPPWr2wvNmv/Mvr9rVB07tbB+TqPpav07zvmeeBVaQkjaom1Gmls5zlodvQxs09vAGYePjUKQXtS9dAHLpBqbzNC7CiqPsgVPjCo3NNLpCjR7C70uaygUgGDXABM8+uJRheG8WnXCpg1NJw4y4yBw20+dbylB+T3lb59T5xRrMZV7EVHr7oEFDK6TwNXun+3LCMFBBG1zPo890QAcsp3lAikzXFRZoY5Z9j0Pkkao6J4q+J/P1dYvZuY9CYolVI9dX1IFFPgNjoO/ruJh98eFbkiDt2AGaZS6VudGlDr5CTAKyYHRHjmy2HhL9M4b1/eP9rXu26dGwImNSpWVF2H5KtA8m3UYSv8tA2HVghtCgfu+SHhvFiFdmjyqN1a+VvF2aTv2aOdyRlENctd68ngGoR8pakmsAmV3lxhwZQ/8SKOgy8qMDnPdvKe3RximSQw5SyEyTGUiTat/uqT1X+4Xa3CDBHp9/H3r83bIyW7t7sV6Dd1JiOESSgX/lP8DoJCF3spy1PIS5ILSm62wJGs0njArQAuaRsFSho75oILDBxoCU4fp73t8l6da256NJubHU/mBuSeDUew2wgmaW02kD7pMy7S7xOKN0kMXH6PUoBLPTF2YVy/PqciBwwu4VX7V3Uz9vTaKQsCSTDd43Bgk+D2YAydYK43ed/aMPaiVNUKSZ1A+62Xn2LSL0xSXJYi41013OC+uhjwsq7T8KW0sNV+Ar49NqkaWYrfjc691HLrHEEFF47uFM62Opix6cp4o/NLbZWV/FjA8lHRAiFLzW69huV68P+4NPbfaRX9vsXY9/fR0SezUCKxMQs774I/Ae/R8G4GOM93d/75J9/L+9Zhf81O6/dGo3rtyvqaBX+WF+NszOho395kx1nBzwUSTEAdOySGULClXyHFrat5iQSXpgN0BbqwxyiDCBA2uMzXRwrkx0xFKdmP3BQRYGnBCP18YO/PlnqtRH1wenJkerueZ4p2lZ8YBaex1rbhRPbcjbV8VkDaQOWCuty3HJGpTehIIKjyNk5rW0ps5ecRfcYR9sLokqc9oJirZH2GVvqjukrmg2NkoEoD5/wGAZ4Az6PRnQn5+iUFhgqqENun/gCp5jJCNSHN5BFcknNEutWFZhx0AP+mKiarYJLeaoE6k/XIlpDsrzmHO7NS7uYmnSUL88FYMZEAim7IOP0qX0WsyjSaYuizAOnGA2pdRcvIwHUEgFSDC7sULG+p/eSQZdRV8mQRnhpFQapWrZ/c5aRRCxsEj6Ec2dMpie0OsUjo4SfoNdc8VL58fWqBiWSPiOm7lx5ZF0h2hPml6IexGReg/nNjX64/Wwj0PfspiOQQ8kjDGyqBwYBon6yak5EWYUlc0EvBqRiNAQvlingyOyNVgTGImlkCBDIXSNyJoCsY+c7Xoytf68gaHjvUafvBqNoeIvubj8ftRPhcPDlAk6wpgyd3hPTi5KCatiKHnQylkIwRw8YdcAsoFDHS4jCBW1/7nxegN6sWLk3DI0KMKRU5QCjroe9DTIidZ85BT6webfyIKC/hMIyLS/NFm1MVECbI37Q+Z1KiMpi0xHVDge8Y58gvt7/hueVw2xh5UeCY06SpVlShXCKYaC1BXDg2iPZa/YUbMUDiv+0TgT50DhujSdeOox8EDi6ICWPQtXZ9aOCc1ROrQqi1lPDtDpK96gdKJmLNH3uViOnIIa1c1hKL2fFFm9tM9rs01B4HLL2HGmnI5xWcnIqx3yeG2lsmK/8r9esB/9kX12Tw4/O3b6X+n1qtM0546+V/jB9++ZfcvjZ/bL9pg9Z9fs2z90285ngH/0deyaey+e2b9+/Kq968KdfPgM6TrsagMM0gHfJ1P9jVG/4LMuA/CFqoipN+b3CDfU+WH9SAWvkuzLwLMmUmcoqHDgDaNBuktNCOZ2TgAAIABJREFUiecoT4Ikeqp2hTxQSGlBO55BNDipUPmPl28ANerJtV1qCff1x5Lr2TMwbSFLnghKbtR6DImuNs7cJcHK1YtKnz1EYBBQDZ0G3iPUKMv7BuDTgQGFwFd7aEAllwcTQB5UxCOooUg+DLnKgmTYxPFz34/jC0x74cVNYSwxhuQuB30TR8rgCAaEOol7Vfq5V5gUqGY9AsUEZU6UBt19DdZJJs0aOz+8rDQxWhrHjKxVMO3YYKofrGzXM3bCJ+dzc3BDlqnZOWvLKQ8eKP3okW3v7GVxCnLG361a31HLYC/1Ng1DUbdTm0JFNQ8pUn/pb271Vq5OZdJut8vnHLyqpH3R6FPGMNZfYzTnTHyNhR9+qpdQzpQO666KN6oPoQDJpTW/2PurMVi7G7DaoC4XNa9IKNf8dEc6JxaoBMqgS6BDJSBaNBCuJvLUtGLGBEGu5RyJlMA5bpUAqZxq0jJ3k3AZ8Vyv2j/6ApOtDlussDk+KnXqlnQiclN5K3gJQ/MrzJC5U7nuBDzOQ9zh+e/aIiuIBcdsZkaByYEBrIzogFokbDQRG27ONLkxg1yvCPXzwOAfFALAhUKH3jGOT0ObysLLGCSoWGpTSRtZgeJNSl0IMRC93XBSDbuNBG6X0Lhgp57c/x6mL09YkfFTe0KhliZMeJw7ij4eaAgwdBrodZo5hpye5lgaEnzq6xmc+wZixh47VmgpDuvNXuuc599fuZH22X+92Ud+fbO/9jN7ufseOiQPmJ3eLw+7lX96smrHv5HXS3fM3vnYbj//73zBfvEffKvd+tKpbdtrv9GMRfd2+/h/8wn7wE89mO/+oUfKuRkUKWFSlW07bD2PxA5wkxMiYSpJgcKah8H2FZ9zyLXSGrBEiFPl2ALpCzS/1JuF7ZVrEHeUJSsQ1hGEcuo3AUalukI9Y57gvym3rDbhYBHo1aYBQm3MnE3wslHMvnWFCv9xWayuySPLInzzoPARLpiKyIkGwhzmHdR7Kfyu5g8pElRxaMjIn5cG4ZclNcC2LR4yNPgls7N0ZdYBCUaXNMhhl1RCVuVdqE3F5KSkMzIfxZ6E6uIy1afSVndloc6fCy9aPMJA8fyAFxVuC+hpzh5m/6hBzjW0xYertPPSi4AWHy8DCuupiTu0V9j6wAUCbIvswcduN6S05NUqZvJqpVyFaalFB0e1HT8hU+nGfTQegY1H58bQ0bWO8hBxMj7jUfIEKQVfXhdSe0wTS+IJyzEHHww5qkNGg0wFlE4Qj4S2Xp06sWCDcyseiigTPwhdhuuRlB3J/LNdglqey6mNm5yrJh1BRaSTCUwvRPMCFc6h7CdSeN8IZfM+9A3latDMeBgQGsdDkNSifkL1i7LGaWJk+iP8yzlzq0RhGGfaq7B2V/mgpJ/6SWTnsC0iK9dBL+q9sni1eZXKODse9fwS5lDFrZKvVo/6skIrDsaupZzkx1LsmEw4PIMUP0tkX3aPct0Mq8lABxpL+TATQ6tabqsfkLqjJZar1lcNV5QAPoonGmhXtoWRn5TeO6sCerwWIWrQKaIKA+aiYo1CPlXSkcuHaBkWfnhrjgHDKYAvetu3rbWtfh0G6Iq1D3bu1Heeo/TYXk2N//qvkzC7dDntl//ni/bJT+4TGbn1otu3f8ew/+jnD0rH+dzj5HDjPbKTN5qQHFf+/B2z9731lj3yzDP25FMX7ZFHzl6zN3QcCqd3hn3wA99mj7/lQt4+O7PLfsWNzNUoZGyDgjSPEByyPKuGDnk8JuCNpJokRnZZPgvyM5okkOqKHNMZL7DgyzC7jAxsOTtxLZS3rBnvVZG6zCRKA7CqDHYQUSkxDs5Jyfn3EB8ZtHswg5B9Gg3bsBCppkLKNx9YsADU8U8IWQel9/FRznQJS1uTcpWZxt0JOJEkh3vdP5bo56iOGlTtJaRAiLqUE9mscFJrdfgzvePzoe2iLd2c8mugsi2nNUVHyE4aeMCgP4M0IFrAEuae7VtGHhkwB4bcJEpJyKvC1o7KHvYuRtytHPHriMQsYdUoLIHbfJdOHwBqYCAYpbcsmM3aI9IZQnkwmBPaCQTFsfj8N5tifVSNTA10APD52T0SpK/GhqEBD5ift2f+swNm1cJ20/C8gK460mlJTzkw9F9wfmmpptZvKeAlrApx6oaKPK6WRiEB5sGQNvnYvXPKhJdHVbZN4A7yQSSOk+3JWjLh0IBZK6R5xfRAWI5E6+cz1GP1Xt3G6IPcQE2Shd1O1oCZhGcZWurT0Kx7+JJG8oboyBNX3dnuimVtFRBGaT5MuhjuRTBRxaIbiFi+Nfzooo+T8gr3cd4RL886czjxQWuSsjn1I5MCh9RwK4vBwW8WUQ+QZNWkwZsFTiXqCO+uVuUxvDmtEkMtq5BGSjQ1sdarztiEbdjAEd1cQjy/EerlOuEoDEkEmlhj07PbglGlG6famYk+b29/h2GRVhcUgac1I9TVvGBwHIzGwGfaUW09SOiN1Fk/d3Awk4OYEVImbD4oasoQ2ni7Xvfr+ImXruTkmH78Y2zCuH3q980++GfP7IMfSPvMZ5ec4qGHzI6E5PUQTF7+unfX7OIDZv/WTz9vfiXt9nA7O7FX/bUf5nkX3L5657bduX/mJ5UFbVGVYRFm+75SGyjREORzFFexMFchVhVBnS9EFrHKQDfzZVykgX322Su7YUeikgKXTkN1FKifhvBbIqE4ebSdFSWIaPL/JPxF55CR5SlcFUOg+YosoJTKxW2K8kfl+6Eh7TvB3OPjoyOXOvyk+FKQgWbsjBXc0cWdpiBDrLUlAyOoB3wY1+KcQBxoBgFNggGDEoqDyRkYDsZt7wZYsoKq6ViwxdFnRSgvv7GwlmPR7Yfij56PqG2odRNdKfHKkrUC8pdUnrC84A8DJ/ZMTk872fWYMcYw7+El1QgYmv5OKoEeVAL7XEk989DZey6ki451WHsmrsSknFXsAq3VRFmSyLfeR1i1MrKBhJcLr43VzjIY7P1oKqJ7hoZOOkfC76v2rqEcOCxpweCACi77saRWFbzxVuiTEjxT8kv4In05fVUII/kIYVV140K9C2rAoX/sovI4mjwzHz60Fw9mEn4cH3UTIDHY6gvp+ZxokEPyHSWu0eCaoWcxfOW3DIAvDoV8QhhzA7eQF+5f7VzOdDihzLoj84g+iFyxrolOKFVoQkAR01sbfn6aprmy8ICuBSp9DDKlma7NdHpWy5POFK1M17RjVD6l8UX2Jx9fLnKEdcuCgghTPh3dgJjoWuUuM90d6R0/6xqxKkLFpRn9bEWcVVAb3FuScau8da8yUoM6hVh5C6jUrAzIpuGs2pydvqRfJ+65sIfK9su42Juv1JoiBul+8BONsRIfDocUAwOqMrk91BuAbMRiO1xTgMwrWOWQuaxww/PNvAE49n+cpnutE9FzZ6/3dZzpV65Ah+TBtBtvqUTj7/39S3Mq9+qVfqMYX4fn8Vqv42qPrOd7v/e+PfZY2ksvXbbLl07s4oULr/jrwskF27awxx9/2K4/cHWc3R9o8bM1XSV70q4sFbnrSQc2JVIA9LWheltZ7zroR5B0uKRI1OhQO4U5QnKQi3RJD1IASDiAc7jJMqJM3QdjROTQY8SfkgKy7g6kmFVmb9VJrminn2IN08fhiNOCzIEUg4JUiC8ynnCEQOmXUP71mPQPeeeyidkTQmgRU7KhFn8MSfLDO8F1BJQP3/Yyq3gPUxWLTTvY+tXGcqOBFT0pk0dSCD09ehqbePbGAkqDGFJLRogRE90Tph7TrY9HpMEQvjJY1RKJAqu7W6Qp169YaBGVMRNCIIzFIOgwrVX9UyUWize4dpuEczD/SiPhJmCzlmdek5pw7KAH/lu1fhKpXpj1ePp8Os0Zci7/NlmdHWP2feoR8T+Agg0yieCUUJsE+mEBwYMcRD426FqPLHtamOqMTiUKfiiOIIiE4Ic7NEuFJcwUQt787Ku5s7FVnafhrIqdsn/Ic6WXsTSUlgGU8jyjwSlZZRhhVTaN1M2JgAxgJSRggJxevosscTR6WsNwiW+SFhoiO0CzPvgtogcv69MFIdxKeJBNzYpooyLJAAWqz8Xazt2DC+wnscpNSWNS4ioEuho5s12jtVJCrdFgK6AEXIv6I1s2cnDBUE/I5iArOgQdUj3Cqjq4Hit+8fTjUsCbzeaGMUEbvG/A0I6dPrug9Q/HupM5crWq9Rf1zOf6HaSWu1YJdVUcbaCSQzd24Wbg99YqyOBY2nBofKtnWTaFhGcQKNdokzYA3gonUkdAMYJ1yDCiME55tNrrrk281FtHIAm6dBvjI5PmLl36Fufcg1ngndfGrm5j1Pkx1qLgG3lx0uYPP73Zr/+jzd65TNp80wqsRx/owonZj/7o83Z2dma37w4728/s9BV+7WOfnf9//i/+wJ544it29fJFJK3OLkmUGnLt0wE9XLQAQKIIbjqO7glbXIe+BqjQh9Or0y00SXOqQzFm+y7ZRFPkooR2CfrPZu04h6jg4JFOnp50E9TLJqmqfvLoHRMdWjAJUEBYCQ/iShmQIG0SrjLBOK4+NQ8v5LeSTsVxWCwyNZIIDhwRZKB7EkWsOsbIEdnrmXBuAy6rsw1hRAPQWfKpGBalG4YmF9qNbPd4dC1nxQyu4mTMJkeEtSa0S3VgjqjMNKyijBz4lGeCW9PqPM6TjO0MVF6hmUlH2whTGMZykS/XCVoxN42NFhEU2hnVgQrVHI50LpKRGrAxeNNBkUc9gSQGS+lEwgEsnHR+llU/iv8B6HQjjS2dAwDdrKvIBehjQt6D9kZD+rlY26VZJ/c1tT/hdhTwg/RFLC4B4SeoeAaiSzgGzNkOYvKDWSeUZXT1KqtG2caiQC/vsRrXh7RW0N5aYNORSuyAgLyw+aiwOpyiW9g/zAKgaKrUW+jCnOiZ6sKbzoIJ66N2kRGfEsbqFtJ1JAiYsFhNSIui8UTbmEabIIOPMBC4e5x94STEKBI5klvYxRAoJ+Wh1N1HKXzhguteZo+DbLbKlLPmVxY9PxSEBHeyt6D6d3yiDRK1Gmk9vmDH5OusqFT4OI8VEiDYbEqMo02z2oU0F5w4jN6ksPlHvIpIFDjIOF2EGQMqarr/hR4HLAvXcVkC1s6SSZ13CKkIQyFa15PUrjGE2s6AH6GxVlcTPEKCOB7U/IkGBu4rJ3lFAPv/WXvXWN2yrDpszrnPue9769V09cvd0BgwdDcQgokTkGICbkKMiFHsGNuKRfIniZzHL0f8SX5YsmTJUiRLURSJKBKyHMDBiowjt4JjsGUbEjCYGILb2N30w9A01fW6r7r3nrPXjPaaY4y5TtW91dXVfOpH1Tnn+769115rPsYcc8wQLLiSihiRGCJFHYHlfDJVLujUxSesucZZWlrsx647gQwORYPhv2hFwZapG9qRRQeypBhzGm8pmJ2djbf93zGjj93+t5/c7JVXzG7erKf5ezKb5pB9/b4/et8+/slH9n/+7RO79c4n1XwOTQOzO59+aO//wiU/vXpqD88FlLuKdwMsoI2QqHdcoPMAKMRwsoghM8wdpKCHfu/sY2T1DEO61MKQPN34lg3oyNw0mKOTrFsWThKYSp0X5BjxeCHEJZjMlljINTGggouuAbMv06nx4LuTSeYkcCkDqxJX7WwlNsL7a3WYSlYpegTriRsITUk8m+Unq167YA87C6fFpkzRrFSATObrRcfHudnQTFMl4vprDB4Co77yY7RS16B2RADhItbVya3saw602KcGi8s6WrcepnpEBFB7cyQbH5g8jSBqS8b6WGAd5agz6UObYjOZ+LXTV5MSTFQrW2Oyboxs0ASnoATT3aS4OTqGlMM0thuRbkpKHmihlfBGjbVC65DyL0v4Q45/ISoH/gyNJzs+lpQ5KXCPvylisoTFcs6nmwERencSU1jXaFDz1kKlCGfFqLvUYHWjU2WsQiCaGWWHaSRIMsV0MniIgYo+ioeLZAUjMTYosKWsVmWjhwoRLAcxx8R3HCZyPpyqhc7ccNYOi4hIaqKxIW0Ry6OX5K4b5HxxE615FfE/Zro8vGQRCJ+l9hXzmhYzc/m0IXKiidArSEY9RkayF9YvquKUQw48V/lEGqEGPkLnY17/CBxEDMXF/nHgQ8ZYisLPQuASB4BQVE3WC04MCUrEINaChXffhnX/KgsnAULYwOSfasxFE1cjLUXcK0044TdlPqd9MTVrE8HFyB1a6vRqZifZee8PWHTEB/sWqfHiZFwTSjS22KgIJzE1R8MO7AszCJIHCSGK58eO7kGwtAzb0aRU+CXkpPH3BNxxP8cteIOKw3wbs4A/RK47GU8/dcVeun5qN5++8mVhJONWDdv7W/+H2X/4Jx7NCsvJk3p+19dB7Tgu6EBBTh4TvlAU7Q9+87B/9Pev2LVtPLaX2MGeO7uRduny5djnMLmy4Rk8daEI3ugepnYCCSVy7OoI03RGgv2gOw9WJavIQ+YiOVjGlvGQ6oxPBY3l4NNROEF+coOq+ABNh6GYBsXvwrgxkdzUDGs1qVLgRSBgai2ipb5XNaIZU0GfYRFgEoFM38f8uvt6QEpDMwQruovPc9Z+SOMkHjIbRdN3pP0uqNAQ4xdWPwn1x83tbI9DcD2GDK1ycPJM60Y4qB2tlMhh4sKzh6lKoS2V03gUGjpQZQvUbnAyXbi7s3c4ahAjPTYGuoLdJ4forWI00WQShOKI5FWpqWbz0dI3aOuRQMwwCZkkWCWaK6JKjImHjY5+VG/hnoFPkH7MjhIi6exsGSSI8GnmJoN1rPEIzs/AoPSedgasKk1t847AIQFvYeRydLufmRwjvwSl0RrW0uPjcV6rcwvSm4x5VPKqkHbOvxjEm1Xnd+0Vg2AFR9bgYuYQvSAtjPt+7oc5KI61t3L0lE5w6I2MEnIC072GSlVR3zl4L4VpSBKJO3LCUtlD8Zz5U2CRZTpCtbFkvj+iI8pRdSYGtoT3WFelDcwKkUA7cIS6kFeZE6kLTBI/EcnDqDFrFdUVq8SPVnGEJWUFEj3ACF+qccw05DK1eYQMM2WB+IlDIIs37c22ZrcAGtGSsw4N34AbxvRrNG9dYFwQPWHpXBAGxVJyTR9Iz0Q0XbgSkchgEQryTYmRMk0MsonT1hcPZ0c/Az1fti5ahZCegIsOsVQRdp0xfW8HQFFqycJ5ZpMUzfNSTJtld7RWzxnVvYgXRBa1aqMdinVKpvMrNjNTtQioDNAiHf++i7tXU41ju//gLN777sunf/Y/+kb7iR+5bQ/T7dKlpS/3S3wdX/v8O9x+6m9et698/wv24Y88tJOj1/eLvY6/OUiuzz//eH7J8bNbT5s9/6zZc9dO7dqlcaF/uIOWtEfnw77vj33QvuIPPJ13Xnlgl+3aAE4bUmksHJg1yUmhCgQF+9IpE8UxqUq9Sdqhnsqiuj35VhVlCB4EP1n2vWpAmgjAJA4ZBMwFajc4mRIyJ0ZGQbSkdRlUvFmCgOz/YWlUOjMpYLaSkL2oXwMMa2bsCFYUahNtNSLnHOOrDHfavKmnSRrSNFno4yrOSYbJaRkYavCP0aZ+Yuvkl+6erPSzBIFYHql0NSRS24n3wFyyooGAcJqF0laWM0hzZQjK6aRe7PTDoVTaUSEiCV8Fm1FsqBPLNu4M6ZBk9FNxbh5jL+yUhHAS2boQzybl+nxiB4aOisN5IQRxtOfk4QAlCm6km0AbAIpfiQZ0x+R9FsTBdyVLsERhl/4jcFGwHQd20OD8+RkxU4CldtAA3rJJnRXUfJcJP+SS0YdebUn8BJZ0BshL1BDEBg9+3A6TDJGzIvtS7B9yeFFkiUoqBil+hg6LKjg4ApqEA2HoiAnFNbWZkrTdKmwMcqLUsPfJkSOv7GhaHLU+OHXS8CmwZ0zE6djk1RHhLEqhfJEgBDJbr9KOaLtwkjpZyF7JXaxjXOXfDfc5WKNTMFaXtISwi1o5BV4PjugoNTbIE6oI7Ah7QcpjsShhqqZE3oAayQaK22CyXfzU6hk+FBljLQSZWu5IzWMjE9EtyqkZCwLOt063Wk90TE1D2/j8VcwFAjQ3xF7t4sHiJbMNmatoVrc8QEUjoB7WsP8KRMStSUC8FRASWbW2siqEVKI61s7WAkMKf4eZh/ueYzLYycT4gPOLPdnVmCX6oxCumiqXGBF6StM4YDx2I/w1DJVTQlyHVz1fWPm92pkIv0uF+NAdmM2QhYaAG0JY3Ac6mgt1O/zrdmnbH9x/OH7+5z9rn3vhnp1evWTxGsPGtx+QvPDCqf3TXz2x7/l3H9rJMXPmi70O6ffnnqvazuOClyMRvnnF7PLTp/YtHw27ea3rKRf+Lt3uvTrsP/gvXrPfPL0xPvt5s6tPs+OcfBpi5SCodi28Hvtc1w0nk5qOhpy5GI5MUgEOeoOUS88AdUgHKPXEIKsIDXWepZ/E1C7VxvuYrT7553OzbyY1EdGOYJdgkmp/dbo6MltEZ5CCyIzApbAMAwmEDwKXc7wqzF0kcyPsbFKxy4ehQORqv8MWJTjcqa4wAhBXkHTqAPX8wOCgEGl9CjhWSju5YYHOtVEmrhqLK4gYDL5bjDCFTZTBCNZYiRQYIbECn6a7oXaoyhtGvgWscqVByWICvG0BPymhSHO28MHH7OVejlaj1l+DIExBy9iQobG4oqDNzPfww15DlMlWMbau4HHaarP1e7WUeKDAlcJh1jHBPbklBwSaxIGv5zNRKsi7zsnPlO+bCzlCsUtZ0BFkI2izDzYwpi8/rjxxYuF1sWM9GZ1RHo95y/Ru0p3Or4DQKfKBWHV4zz8xdiSDwJwmB72ZojFUSku07yIXlOQXKDiUppsvFajF86CAuLYcKCAGXbWcfmDIq7v0UJKBB2fS0wGxs9todzQQb6hhx6jvPJQBFOzBdt9kIO492NNY26w5c9gsCR4pN3395eAVzcCwIUCazDG7apJw23qK0Ls65OY07iHXUIfkJ32kUXIS1+eMTtUR1Y5BgXQx2JwVP10oSD0M5itrhE756mDSNahXDzaWbgBru0UQYQXOmIfoSME+BwvIjLx1yTKZxZ6pnRJOAZLAxw0M4qgtt+FS6Z+4J5TfuzwTASi0fMlMSHJhXk6wklj3UUSdWLRi5gcNVIQz2IlQ2YZXP4APkoRMMlBeYtmVPB3B1W5XT8IfPtzzZ3720/bSb9+zy9fObejK3/7r8KAf++m0T3zq1E4eFzS8/jV1plGmOQKT17+uXzb7jU+f2o/8o6+zR1cu2bWTc0V4fB3rfnJyQChn9lN33mdPX3s0rsd5uajSwtm92rvnTtsO3RtoxviORxia9lbqDrMDvk7whXkBNErUKps2N6pHLjF0RbBYJdJhphwZWFlxNKRNnQmSgndHQ6nSpAJfDZPs/Q4UdCaWFZKaLZtuyn3PRr852ZOAPqjvUxIg6YTAqY/iBCKrHODqTiR21t5j1S4quXwMtzyWVzxPL7p+TvHkamJC3aPQkDlUYSLJwiYrqd2UnsfMlhKC0bYFdTdRZC71aWb7BOFJ2l8tE8M4aBHMFdsJpMwgvqpgBD1IUgTKmeDwTnYGCJn186FwjQS4onnwwRuInfPKN5Szl9acijkHqxsjRV3PtlZjn2FvbNOkL52cjRZ4196Jv8KTsH9sUhjAzo8SwUdwM5M6z96VMFtjClxytiiEYwYYrscbtopFbJwjMd2mhTrBOZlja2iqyR5hk8dxoRs7V2al0JA6i0ppS/eHVdOoAaZC2g/a7XEnZWGHhjsfV75VhDMt0nzLVN8RmyVZehzlKGdZRdEQ1AOribZk5mJut6gKIdVfQAWttoAikRQ7vk0phusECNpFqREOl4mieVX/caqjctMEH2AeX9tYqIL7qpQqSrYOnHxIKqnidBy0ethbcCuynDnn+c+FpVghC33FUJ2FyMzcMdqsIKsAX2Cw1msFjEZBHM7gqFoRvVunxZKs/G1E7RJo4wv9VStHyaDParShUD53XwAYkCpgIiZxlVM8RINgixoJYzpq6DFIzEBgYBkd0sPEj909iFSnwiGMS05w5Y/dNzB6CZ01qNpimerUMUcxTudQYkQ6LvgcU0K6USmTPr5oMtF6lXO7eskOwzsIwq7AcOj+gnQPXDCp9kFxNRadqr9oQNaPx07Jlsl1pCYYG3VsjdTy1osMlgmmB4Keccwi4On5vvvppRP72q951j5+52W7+cyVLzsQMcQWDx6Y/dw/2H5vCKw3r5v94m+c2j/7pw/tuZt37fZjApyDa3L7jk8Z2F//5Y/bd/3xW/6HP/peO3sovgLlPYJlUxbAp5Fg6QQyAWUrEVmDwZYYvJsh6lhidwTj4oUui89n/Q/xCDmPQb4HlXUwRMYgP4Sp3Zl7ZUw4GVuFGy3pOqjHE1XDpaFlEa83L4VuMARhqfgZh85BlxI2HH+XNa4Cwj6mLBYLWdiNaSolaB3GVHtUOAdvrzOKJQqmEAU7QcEKw13q5B45OagxGjOcJAge17SNyjCHk6cSsj2tgNy6B7YHTk/n28S6kK2XUw/4lGS3RqddTCMI7yfr+QbN9BK9KF5EjSbx7Cbxytnn897LpniUblInWPX8qErusWytihLLoqWSIVm/ajc82ChHNyLwY0rRk9GIO1729Eht2Ulx3JxpU4XIwzlBpgwZkVs2IpRLFpLuoOgMdArHjlnO0nJlC1oB60TbEY9gDEqRc0Pm3Qjgp28bIKHdUflLEZJrGpeXt1imymAFuxexcOfN2I5SRWzae5QQiDAnfRwOEgh8JHHDXkuzHrXNpI5XtF7NoCpRsi13zhICqydU6gEuEKhckpMDdX5RPeuk0ZHYEkOW560iS/IBb9CiZWY09wsbtyq8QwCErVG3lcz7EY0gqMChLBmj0cY5QsgAu5EYiQLKwzLFsIFuEPnDeUX1Lxug04GOJc3ju6DOBi7XYPcZuGiEB8T9IfiC5S++cBZH6viQzdQHlZw2Vf2PyVn2F0KVAAAgAElEQVQTZI4Ws6YI+8PZQAv7c2ioVd1dwo5pHN9ZCKoQSsI/1MnGpyBwHRCST04Xw0ELDjJA9+PgroOhD82c4EDK0YMluEEL8XSDZFDDf7CLpOclRQ2PhodQpxwgLdK3C1fjkqO2FrBfo/Irh9ALNQDmPnjtwdl+4x2X/Af/5Ifsr738oj0Ybpcvv33OyLIH7cUXw97zr53/3gQjL7xq9jXvuW//w3/6z1vs6nWvZ582+/V/bvbD/91m+Wi3/Xu+ej+5csnOH6KqN9XrjiKmncxetBxVPanTHSwdkCmfgiiQk7ka2tRCBQYegb9CnI6jU7R4S/nCfsSzW4RiGy66QqmJsvLjPeGkeHssNKBMESwwzjNOsYdkwSNrZB2nwwRSyrFy3BWJb9RwxwViCNlhvDH4JoqddiFFZTXx+P8NaHtmO1Na+kGy/5TWIkQe3Rw7Oyaqdw9LHhjkiSR+mmkK5oI5AQ0EH6yZV1JmLFkyShpQM61bcLYSHu8XN4BkewQSMzaiBL4xzKy6Gkuu8w738hi4tqbic/8cv5E7oIlFwwWrZWI8E3Nv74FBPOridejPVRQNTH+iyhCkRQsTBweYId90svBMVbbyl6WRkqGKH2+tEKdM0CjL7C3Ka4kuLKjIH3++uZaQZPqKTpnyUoXUIdEEOI/7n7RwIu04mKOASwhtoKHNOOgiKT6HxlWIw3uOagOPGIs/lyrmNAYlH1TfGBNySlFzKlpvxlaUY8siEofkV1kAhQlGm2uSpxyzdDENdjfa1tMLVm2YvbgAAVyu7xDKCScjQ5W2cshbGPUEDrNDKkewyyRZOjwezkyo2FuHxL6iP27KgFbWYCmCKn6OyWizxjXkO9ElguJp2TIgStRCRGISKGANWpm169d4PkOaF/Tl1EV3ju9WnRFdHAXvgmjbRBr1RLIbKMjc49tq/QP2fTh442jFqYIipiTIoal5AdYtMf/CMX6cAbiAiO4TmuczAIAToxnTjJGTLhKr61RofgN+zpWnbS1Ga/UYdfnVqaPdNe164AE2TmHMPfEGimZMasp4ziTs4DQFu/RQdF/t/4RUk5OEGUCWfQh03dANiPdfgPFxMo+VGKSVb3bp0qndv/sof+b/+k37V5+7Z5dvXLZ7rz2mTPIlvo4Zdw8fhv1n//krX34wMhv+91JZe8ezjye48vl8//eZ/eL/u9tP/piZn2672Ilq/ZprsjsGA0BuIerUEk9g6V3tUBWJZHTKQ30FkCTF5DoM0hhRKfvhAMegZ02gti5bhnNU1Rne1kHZ3ICkLJMBGERjOI4EKVlS5WZg3Z1okKNneXC/LB2+DkZtcgZOIoZSkWWG/ZjWggl8zizjWNEdgh6kjXVBG4gKIixKrteoMe5+xHWs99Q7j4zskG7RgdmJ/vkc76vDieAgARJWOst4nRBNBtMeY0sghSjg/jWzpr49afZduqtFidexVjQleC0pyj84Na0W08UCbsJBi3a5goZjQwY4wBMTlSiHquqgFcgWcSTFZP5qkCe5lTULwKteOsPAi6GqUUArdSSqluQg3DHZwlC3ojfNr+GUJiRgo4y5is01RIZNgQDnQUFNgsf0gGjsWZov0snoCPFdFkts/c7qEslzU8NQDcKj8ENxKXuSWxX12GbW0BBJDKD0DtMAht4Vo6lhrOjTdwy4e7I6mjJA0no/kvpWTIetFlG5T9Oi7Cl+rtS8CbWLDk3KtE4TGdSYNALcEBaDZ6FXWQwzkJY1Q8KRL0CyoFCvnVk7+N6FKWBIbe9/M5IPMF/SO/0BJNVaWIwoGdHNAnDu3TFTRwwt+Tj2xhUbVHCkcgJAT9R7ERwMgKEUjK4dEZC/n4yrgUqLc6TwADPq+P7Ni3HHEpiV2tm8u3omg/MI8HTnn8wrqmpNayFRBpGU1lpjKTpwuTnEFyaobj9Z22i0O1T+GUpl6gGjZaI2zEDDQU1RrCteZghJu5NTsYyYU8WfnJcOYp1CTCbQYxjlVEDxxwYnRoybcuOQDG5BAJaQa5uXdnq6xcMHY/zcz3/eXn7hvtmL+WRn/6W8Muz7vv+h/aF/Y//yg5EjEBmjOSVPeh2/e+/7zL7rO07sJ3/sdI5MqlRWgeMJXPC5Y24BlGIqhA5nt82QzUIDd4l/JTliuTRJYJkdPbXOlpPeHnhtrbFRpLvaLoEesCrk1e6YGT7xhoVZCPGj4lig8Dg7YEHV3ugAZioH4iw89GxHn/lgg5wG/seRJO+Y46kgGf/iY+CkNgVSgrO4I3jDiUAeX7t3lG+Nbzv7EOcRAscpXY2U1HuaZ3D4hnRnB/k/IOhgnPRTFHUqd1OKyiRIEZxTXVTLDXKWE7waCbGqSWgpcgRis6PtnWkO+D+QfyxNzdkeALlkV7m6unqQnA84ZKN/DoRMwfaWpnwVP6lbbpz3h/CFlnSwr99YRR9RuigG0dLMrZC2A+2nRRJJlHIHBUqX244qYMzqV5ZFZWmkqhrguOnhAHgd7R6BR2CRYGzqsyHkiQYodFuBYTl4SVIWnGluJAjXTQSFo9mPW43BwspeFClTWWZ9IvOhGuQkI1lyCcx3HpOkIBJ6sVfnsJ8CGsLb8tJllYcvguDBQBmDHTcX+EleOERiEKbxS6Ix/8LZdueZdsq5JBFaiT8UqgfofY5o71ZuYLqS3SndsaEIe6lnGctapA9aYjZ8WwE056rnYWlmLT8+Kod2dZQqPmdfdY2GrjGcTe6t/eMEBxSbGMV5yIlV3xI7VllWVVePKpZKi7h0BoyOxfOxhHKMNkm+JQpR2Y0IzdLBrd+Ooj+BA92xRK3mrhhhbsTKaKCM45O9RFgEhRVSeRnxOeAZw6DaQG15iC2l+VqYcZywdqbKfDFaTZ+PbYbHIDo7uw6PsVakYYPl7wD8wJmvg8QplkTd6nynK3ydx3DwuCkWYa/13CPdeDDIue36Xj3tCsGLlzfGMc12jLx02e2DX3XJPn77kHe3TlHfxuv4snv33G7dTPvoH9ntd37H7GQNbt4KmZWvzOKBHMHIzuFZb/K6dcvsH/+y2f/yI8/an/pTf8i+6sOvXHv1zm27uj2zqWO6jsMWe6pKosx8+jCCkAAjguq+miqI9qrCcdHnTuWJUkROxgvYSc5KftI/wJMyyWCRtf9vQFMRlsA53hbMFOpoO2N48lCMATqGEmM7e2cQyS2Npp4aRqcKoRS0Ra2keGDNbEeDsgbLuSA+mTXqkK89zYriNvTWX1QIEonL5VWwJoHqA6zbnKtLaYUeOwvPaSx0eEnfpjpYnZNANiajFfFt5aPVZWtKpRhtZunHQt90ZC4mgaMfMLc9pJEKS7hb21BoR9Pcwr+ItHRgEDiu0oaUNTdSLYm/FZ4w+6aJz6Z2Bmp95UtRp5sxFSyMBhE7YwqVhlg5KLE6zCxyxA9ONly1WaH0xowI5a8ArC9H1mX9rPMBREHooLPDjAIRVHGXCPph28YoBTCmUeTm4DglAwMm88QwEgUvnvHyZC7VXw05wAMmRBDkUk/nHAvvCkJXRnVAqKcp4ScSkaghGMlUbNCqfZ1WDd34jjL40N0wZoSRKv8nh+wYcRlHGzAD2pKfdXSVgZgFDSE8e2/cf6YwBQlspctDxz6XLACzZe84LKAUwObe2Fj/G5wqXPNkDN1ThTmwxKK6F+5KTTuqLwL1YXupS2QV7w/qFZQjp2hiQhjHlBewqr20o7MyJqPDKREpgptjFLYY/Qa6PStEdZ7CWx0FjUiYOIA5lmVtdrHw2LOkCTeAb+c/by0qxqWaYhK4h2GYXRLV3xDY0jv2QZlDSddglAif1pGCFyDSdCOycnmXrFViLTmESgReZN3kBLLIzOmRKvAiuIvZhWkcSmEXuIsYjlcUv6iej6nNa3fu7fHepzL+wl8Y9spvmdnpoy8pXnj967iWu3fdzs+HXTo1e+XVRfRM8Oxb/IIrV80e3Tf7X//qdbt9O+zKlTeHbA6dks98xu1Tn9jtP/mPX7F7z4zt3tlm166SnKAwfuoFbzxlM1BLDfOpjAvPgxyjRUlOPTKVyEj32HWT0fJhoLvNQpASQDavOQOIujSEpGGrbpoAuHBYtKX9il04Be/Dcanrx+Sc8E87O04aOCQxqpJXE3+OLgpefOFICtvrfIFsBHWxsRlM32yaMYmcF9fFyuUOM7dVUDi/65wSUqwL8+MGrL42eoGuTMdq2cPkE8AYHIXT2KaeSYpiob8CRS9rpF8GsZ5v/X7L3k2qcag1uGF8PgDKpWv3JstGFEZgAFpGfqqxElhnUtmFGmqDAuMJXR+DCZeR0VMqBCWJGKNLK9QWUE68kV7SWGbF0TG4BKKsTaQf0l+o2xKG3isGfIkISg3qotg21yMWheOiXlYQBS5OIdqBISWv+zyh9baIGFftQtchAGAQw9OVIXKuO0ydB8aaMMJMUknxSQr3mvZ9ha/Vb7TIkCxpJ8NeGG7SE/QD719V621ClMSDWbtwS1P7N+qBhmTc2ArCLilGZVt6fxWtGfeL48HgcQwoQdOeudwadrxhdcQVJZxZRGLPHptCINMo2Ye2SbhRpoKpiZKufrDjqzfETelK6hAUU47LWRQ7WopQRPSChUXxSO5CssK496SBOxGNoFlJhvIZXeD1DOqcC1RbiTETPhMDPKhgaQjGqZOZcEJuimWW52UYTzBQYglEH7lxyJ4+3xD3MzRwVuMKuCbEAijCdTbtUKVLiAEup9AJ3zi6YQbWDtA2lYApeIb93V13xjaiQWbIcng4y8t6G+YcgVKAzhGPXb48/NHDkX/1r7l9+uNmV268/aLKYdPv3XV717uH/ekf3O2ll8xOT81Ojqm9h294+NDmFD3IErzp63hm1y6Z/fbnTuzeyTW79vxe8wve5HXMxHv/h9J+/0ce2O/78D+2T177wNkrd7/K7OoMMzmDzeWwKQ8l09F2gcVeNoKVURioQkYfpn5TOQfucpyyscCkJsdmbUMQx5ShGmI5k68+I/YNaoe5CHrhMzmkJtvK0eNDxfGiOWbxqGwMNNAIEItLh1RvMJhxG9QVSYiDqjWVA9WXRlo4FS0LjQIvVk3KUSB0gkPFowFyr4v6PphCYehvVdTq/odERHpdCpkaGrUOp2OtiG3OMg+T0KZwyomCDHugOWRPhnPPIDnVsuODeRDn32wcibhcG4ODRb46kCMmyfTskA1XONL1AJMBXP0LAxFs8KPnygba96hUa+1cynEzCmDBBJ0UIuH2+rBZLwR1LRkRfcjyDApL7mtjYJfweYPI4ZCmhVAgOqLaI557hLP9jWlulyGMogbGKJCEDhCKmuDBbDdDhtGdUj/lwtD1VL+fTbKhgmTMJBYFDTAQYiFiOdWIDTX22RK8VVVrM0UHKBrovJHC17haLosrYhuy/aHvFl1R8SCCKOi2ln/HeCij8rBo2UoG9KOO7vQMJc8jxCcWuylWj3yaBt0gUWDvVBIaWyJ1dZKHsdSms8muGDWvcCP68n3J58qd54SisIfqphxUp1pmCRbipLSMtnNdDWy8WW+LIjVLfZoLxpEdiFH9QuhNhVtjI/vocEjGsnfwBdaaVsg4k7l6ceszRyOYzgenkhB3AMcFsMd9rEHf8j1LpEKERFEat8FShxWq5hotoV1KBnGH1Iz/fXB6Rq7BedVEJza0Hd7lxK5c2sb5I7ef/Zmwz3+m7Odbfx1fdg7JfF7ViX3/HxuTa3pUVmYwciilRs2gnujFwe34YmWXUyzuxz711fa777lpz9549Na4LGl2//aZfczeY0/Zg3HT79nYL21HScoddWYGJI45dUOOtap6XFwDrL3CIiqNsbScwrEiofrsmMmUTonGzh5x2DpGGTWEVrJfximZdR3o0zcSIpzfJwlSqGviiZOM4q7puiy82gWddhwWZ6ssWGsB539suD05TwY4nbHaZDzRmW17nNYNqKOTTGpDCiPs24heETZDFpRN3qb+lqWKuvKQ06FanAgGZjTHCJoirCN0Y9aN4vHoOGmM3ZQvo0RSYT7zv4QsEuGK1RfvuA+R5JBt1zPfPVu1XsiGkUE7Nc0gNmrsxDTCOA6qBQelAIVzCPOV4gvbh+jgDGTZQcZ9LewYrcY3GdIHjXvU6qNNxwC8sror+KMj6CWwZXw5JDKmfl5sxW2OohgTsY1slmk25oCCXq9/atgazx9RZWas1s5ytGIgoTwmF9XM4nN9B6e1IsgajEzm9+wKnENOIWVYvSJm0yBHa7TSCYjredJTsp5euebgnlY5kxn+4pCEwhEVq+sdOr/0E3MSsiH/rVZ4xSKrSzNMgOlqkvIt0KkUSSrrCLLgZEvr1p2CbBeStnTeIxVduWeJ77somI5nPmBKeT7AGcNqwqFR7zo6scId0cGp3iXBfOfXsnffQbqktrQ6jLD/FFiUdDQSoAHcl+Ib2cfWk7NBFKRLpqFptzy/2o6k6PsS+GWVxnZ2K4kPX7HFqMpN7V8qXqunCagUJnG6dkijNLrE0QYLoXL7L9zfctbK5vX6oJOhCrIM8FGfZ/mFOic8W+tzgn8yEle492ZqExCKxcgDdmce+Oezz+YMRm489VYcfr32cW4n24ldvXJzNgDcuRP2gQ88sj/+Aw/sxRf77044vpeIyBGpHKqsTwpI9mH2rneZ/dI/2ezv/Y3dLl99xV44edJgvIuv45b2R2kf//lP2Hf+2evxnd/1fnv4wPqwoDhsEl3PDnIXpMRHs+ebIOBtEOngSHREN6ljFgeMkoKYrlrjB8yQUE9EeWe23yn7k2NjUgO+waoEgmiVOnouHIcdGMtghcXQGnImTHztkB9v1saqtl9ytNW5kGTy8+YIiTQJrIERRtpEnRRp96BpoQ6aoMULCGP4EWyu8EVXtJUktb5sy1yTjNEzLflacBsYTkiHu6vKRrqlD0I3zPBxq5WJhSj90n6x8nqUHtFMRfpSZDOFuFBEfZ97crKQh+bScDnRqLtAnTASA+sbDt+0GSaBYbcNUDjIskWMvcdCbsTzGQwoFWR3OSEYiKmeTgpAMOkmgcrUNFDCMsjWTM5PEoK4fzosW/ZvG/eLQXUTqcV9MJr7pMgJdf+CQdLi4ZcNM1HwcQFZVvOjJ8t3vgQSpq3jLFUsSheK2vj9/NBB65I6Ka0rTIe7zvBZvL6QJux36jKSi9adOrj/0MxNTmqVZRMEmd0D2F+zNM8OzYUhiqdhn36BiGHkqjfoH2or0rWuwfKSyg+tZGrbXShBERFZlpdlfrI30ALcSkodaZTiCsUaKPDq3IuFgh0fvyem+EfH3ko6qFQiHnf7+IwuKwkmlQGAEQZvMDsequ8XKlZjTBz1nOBMnPQenloBGJnwFBQp+UUK0AyRcLTBOjnUONPmDcGmLrtS5xpdaXioMWX0ZYo6kFNwmoygo4v+TLrMgKTIdDkqdY4an43cz7ejWWBs4wJm9NZeafv5ub3vXe+35555h7328IG9fPmKffgbXrArV2/biy/1h1wo/BwXcZBSj4Dk/n0KyTaf5Pj3p26a/cYnN/vLf/kZO3nxBbv5FMojb+F1REXjtWH/3vd8wN79nmt270HaKR+ak2ABFc11ceHg6AMFSbFxFI3mbS5JwWKWFdSUVkwMvKTY7hojT4SEXrgPMDT2FKzItwtomNAN7EjJgtmaTWcogCkf45rzICiYUJmpdwV+F7yMIQK4R2hGOrDUSeMvbkbP76irDcy/k1JET62Dihly0Gx4ccWDOTAdhs3X7AXSH5qAzeCB9yUnoQF2piUREUIubBL6ODhVdACsCA2KIEz9m3Ic/q8c8UCB//VqISIs4yY5FC0JSUMAjTJva5BBp2qoWndfLA+L6xr4FaRiVqfIhWVRsMhnP5YhiwWV114pBSWOyHAynLQRGw0E8h+EX4tYbCNF2T76s4Lok0G7hQvLjbLwphjkiYzQfrFaiabcH5yInDERqV6zNebQ0c7Z97DuWeQL4AVnlx6ZzZvot3jsYz2zDj4S1KM58poz4Vr5wjr9RD9WBXkUsup9y606rJ0qW0YZBbJC0C9XYLa6CPT7Ou8AXj5N/WzepeKeTUO/H0sSMN+/uUGnqhFCODspNAHy0uTkCutsYaaKuSGwmFkVf6maLxXKlvpvYIcMogAuBKQicpSXsYk6DvRO1fFQ6GkV7/iSMA6WIToB2cizUzmWPqADTijXSZVsBuQD34NtOiBmoIxWkVUsq+LCg0qLb6gktRCVMFQIdqGanYjttI0cNCEl6FbFgU5NCJkBpZNbUvBGsA+2hxWD5huZwsu6zQvwbwV7XFnKzc5F26vV7uCLbBZEgcbuYt++ldfxeQ/PHtr1azfs1q2n5z8fSPeBtj54LWcV5mA5jP0xwYgtCMlRsjnm0Bw3vG11/UeQcuO62eWjTvOVX2GvveeKnV57o/T7k15HhPna7XO7/+98yPzdL+9578z8SlVPw8nmNSqMmXcLFXVZ0RUAj9B+V5tTjgrEfhJSDSjnSGo0LamGLCB0L4CYRZPw0YXglIXixk7qiJUSdTfkqaHFjL3yS3AjL2SyjbRnvCT25g3pPegTnGCSxiXMX0Ugey6GuZFBzrhhNrvAdbZJL01tXgqOj5KelSUze6sTbUPShBi2QMTM6GBILkhcmMpYlWZ0ccwRj5I8Culrqvwsi4NJ44p9Uz8XOMsavLSwmd9U5FdBUsi8Z7HZliCzeQIrKk5PyeeTgohS+ByT7t50/Y/MKt3WbMiazo/Wa0NJzvs2obGLFIdtx3193nZw6UigVbdlIr1XsDqD90hlREGi1lgcq5YXIZ+y89ZlSV7rct719hFJf9KRIxvm6/5ijHa0tl6zsjLXurEcOUx8LnUTCYhxdiRNUYx6nOVOg4/0QuLhKrf3urkJ8sfunP/Z6sSEmlh4NkzabqWapXkEff4Zxid2GNv2sgMB5ull/pzz+fHXCD2ibYj3ZkS+RRamsysqOT9OtWtGEzwzg094Kbl0kpTOrSlDtU6nYl8sbeSCVzBux2UPBIw41Ypl2w7CYJN7GarjaMw9ET2hZoOVWsJJu0ldNkh9MNPErDXK5fnmnydIutGxsiemgR9D9JcwWfRiysXzHhStU/kJVEEojWA0YyoO7wDVG9HvUaEcc8Od5oL/qgFgorMD4wN1CqgDpLbA5XDU99d3B/8YLMHgVL4Bd1UI+1RuiUBXqMU42bsF44u/jpbg8M2ee+YrKigaA0TyVPK5vh5LieUpOoIQZXZeJJO7980+/HVn9t/+uc/Yj/7083brxrnQxS/2KoMY9omf/lnL28/Yv/3R99h4YFVRqEE/8yGApT2o7tCyOa5IT6EIWPaSfgWbW1NVFyGfBsdToGMM7/HV7YSsRL98joYN6BgBs041RREgYFbJx++oOTrnCXsXgwRr9vahMVRyjx+UTnjKYBbeiseIzrfOceq9lQADFTaanyTzxTvFAKpwgey0dCIkEKOl1MJhCDRGWFXmXHpSHHLsFKVwMOyzsgkAsxCtpyGEdZlyHGIiaqU0KZ/neC9jkBAhrDJciYywjb6uYnSmINc6X/DFIDbH8uwRF5WDauIYfy+ARsOUU1ELp3skNC3Zeq1ug6EWwqIv5sq+Q4mrZgzV5PulBs+BPKnaISdJLyUHv1AnQMLTJTTZJcYzhKQ76sa+VMoHWcx2zPii4ZIoJ2rC3UgwJNFerCJYnWOWEsHnnx+52foFa3tXx5wL6tRmd8k10N44uTrhIkQ76Evg+KBTJHvEH3kmO24tSETgmcxljVAAHDXWVntiCWjpPBkTSn61inViR0MUgCAX/H8R0pOCiwuPgFQ3dPWCUCeKWBc7F35KAXjgM/XIuUKEERVAmMQYQrHzR5CQTFar3cNhirct74l9WkgD+15ksAl2CKzoz5acQ5nZABQvPMl1jsmXVwlEpSlfYvBihekIow7tKAtXXy5wwi7L8iqFC73OZusoNunX5mQDAqokDHQqIVZ0JUHI4nqqLzF616EEA8Yg6yjCuIQHUDPivwXBm1EzoNDhJU00d+690YEZ6V9sE3fEl7T2mRMttz323OzkyGSPsOQtxyJu9ujszJ596jm7fv2WPXr06Hj/m77lif052fZc/09+ye+8aPbN779n+zd/0l5+JezK1Qsp/5te4cEZ+apvTfu1a8/GS7c3e+rSqCHeB6RerVPIPmhfejOIcgMMtzZntKWnPB6YXUatPU5sgqdx49DPmmba9J8WXKwHI22acny9n40jrcFp6LLeLlVJhQkSYSP1HxZqbiAMDXGpEQG9YAYSRdLX/A3EDGzHg9EAKxdGS3iEQIFp8noaSybpbVQPpJkYxIMGdWtrenJXrlKnDuIFFfsNTJNR23/juCitru3TLEYZWYuTIRPLEcZ+CT72wHqL89XVe9I66wlSy50RSK13oJSbRgyVbw0VrSDnaoumhLpok5SjpA8xhTcQxnSWNvTvQTWsMZt+dpEvZpRbCFNFBIlaOXNzasYZlc0gJXLhmJUxCY5HY/txov2m4p5pk/EjoM0Efd3JJ0kcI3PaKgEPjHhMolJ0v9GTto78CYhbzyVxPZk0MagM9ehcMnRLDNEWBi3bK+Skc0iqzQux6QoZFNGrBR6kZgtFMcRCvO279gcNiBwt/4Wxf2YVedKJ+IRjcoN63vAcsjzxsl5GMXuFRZygivZbsCQ2SCZNsT9pl3hNv3ahmWLmwnbM5+dkGWFHFWITLoxFkrvS4A2mFcZVASF/kSIJDsRa7qamY7rsmw1UZMOHDsKgCKAacLKDBg81AFdLLLnIVUdMSqXMA8dJK0PxaU2ScHGgbIocQSD1mM3SeipOhF1DEGlDUCBCCzN5YMjIElkFatAcHwlBWycsLQgBJReM8yx8hIHJ7LyPOEbG5KGcRt2+eihoGSP8kADhCYPURl37LNiY0YFVMqqPLglKKbYGeLlx6Ktp7hMMmElJJY1GAsqegSN4SG1sFrFf0lz6LwJAHOXog7T61KS4QwMAACAASURBVK1nZmnmrbzeVrPwsRbXbpn9yv93y37ix2/aBz94pkDlzV77nnb/zm5/7r96vz39Lbf8xfOHlqdXJWLDzGIwwmRxsCjU3qYKFjTX/ImYIZlIdMGNdikldpqHJRmEYLGRpyGlKnJTBUfSP1RaPS7YLHwNDwFsTQglQ8qIfcSz2v5ThNEa1lkc5joU0v4FAQnAwJTD58ARIqN1Hkw1E9LLWQSHqdmL3hIL/NuhJ9Z2oC2HVacE9YC5tCRNm+S2YD9Jpp7SIrJ5RN0wE9Q6SGopiimViwwdKOSt+EJLwGnyfv7GVMm8u0c1+YHBiopqGFWMSAsnOZONPVhvp4QXCHMdFUGsn1uikRfnZq4hehS3WqxFUG4yosvxaRiOZYv/XCz6ghRyMUuXda8Hu7tncP8dYm0bymaJ6bnRzxmPkFYtWf4ZBnzpaH4NqViQ08Bd4pUyoKw2aHoXpQiUoRSrV7CYSr6mTb+gW9WfD5rr5q4ZejtiH2KH5I0YBwcgnqAqPncflebJZ4AhpXMPBE0K9pi6Z/acxqHSmAs74JaJGlmYUM5sMgc2WCyPrf1p1ihkr8mT7JiSFNXSaUG61cC/QElLFfygsHSdsIFsK0hViMU2liZPDoyXjoBuB5GQoWNtKtQyaWAsVCcmqVuC4R2VQc7NR2l6xzxPDvHtuDJBxHQu/VBOUbt74ITKNuQCOpDNTdHagNA7wXAMekOHd25RwbxkXLvGEkPTBdhyomadpXFJ8GFmaAAl99Ie8B0p+2ZGcpbpqGJWlBGZQNBO2K1TMES/hpDDQTFoDlby+13nFwcDJqxudpiAlIvTG1IWWWOV9Sl82KUyGiwJ72NOBH9LkMPxOgMqcu3qdXv48IGdnHzxUONtK5ccuiTf9m337cd/4hn77c9tduXKCmc/4QLPdzt/GPbKqx+yyw/uDL/6yNyu7hTVkCDF8EY3lBERU2DrCAvh+IthSBFcStFGppIgBHGl5qBxFIIG0Pw1XKQic2mMW7uYuYlakY2RdClTwzg7wbHEkQMA+DryqNq9Gg2gdzhKVVUS8ey2edP+lJJI9UGQ6bY0kCHyBzvOg/IrVHdiRhkh0b2q4wdU+Aws7SOsDmiZVoM/M4pW9VCUXAbM6aJXxgngyVQ8jvTNWMUfGO3F2gHGBM1/GZhiiu9wzCu2iUWOI2gnzqJQRCe0uepGtScHMZ6aeszTEaSu010n1AV7OI1bgDGhsiHim1GbuCcJkUjXRpQSpEzCMQhlyBB2Bx5FblPVsEWRnqXzutca75pV3FlG7qHXsLL5kcybmW5nC1AishdCByAM5yjFceB+rHUFg4ioDu2oyLwkQ3CCHbaK5H+cDB/cuabcUu+9jsw+JwICq2Tp3bGlMHEDa1a7AjrNGn6YilimZNuc+dYiwig3dk88BWrXfa2gp1nHnI3J3jzEDalN192s7LOxpXBkQD2xEtiT/XaMt5HUMEcIJoMthsBYq1w45VkTddGptIx6VS2XRxDSyRW7gIm30JVcorfcbCoBO/tVKVpqNFUOPWCWtb257a2UxNgD8p4xcQQcnIHSVAs8CtDumIc2xJIazsfMLJpp1048JhqOqezszeOy5HQ+y5RMo6IBR6wz37959pRyGWhubsJWx7fHnOvtnDTW9LDJqsMwJnKr2WueTVsjNFFco0k45SoCRtatuwDMygWsWSe0xMUFoSdoqp5dSBjp/9wp+cJi5vH1o+x/xWpzDIePs3tn5cvvPHn2y9iH+UnYU089M33IW3297WDkC18w+45vP7ePfu+r9uM/ccu+7mvPZzvwm70i9vnox81HJ36UZ4h0lQoMMH/U+RWkGasvtR9COjoaroU5eQvVfyb0avoQGNG+nlRDUWR9CToo/IRHUXMNYN5GF8ANwsIWMgUUkILCA26iIDzvQr5cMr4oWMav7IC5M2qfRaSidw/25iv3nuwDZ4wAFLmWlCaM44cT6ThGMESTykDFpDeoDn8kO5bigVEA0wAK9dlSXIhDIqJdXqDtmbTsvYY+jCl4MVM0X0o5jJaUjBcK7TWqB0PkKwmbSVSNG8/FeCkuUeWLGDOvNa15vqpqHekedeaIp6UoSfz8xUSXuZfeu+wB6YucjouKFnCCoA9jWZAci7jAsZR/aSEoKRHjPbwxbPeggBwTL9xgpfBNdCJWke3Nw63TOXRA9GgixjC09oN+E5tE0dx8+65ELdlqwQ1vyO6ZbMJF1nwzTdUwqLweQd4+nNVDAy82l702t0MsZ7zBTpTNcM3BHaZNDvMiI1COhuJ2JODg+URNEwa9ifjOZOZN/3bgI2PRWlw8w0wZNm6RumhNbr0wqITdVrYsRAupVoRMOYbCgTCghIRVbR5Mtz0cclWzlWU1g6N2CSbPNIbFDe59uDtAk8Kwkd/aF0vRJ5QxudCDdT6NBpw+sIa+uBBOQ5jiisVqYCcwuXDOssN3MyJbz7cDtaGimc8BWtUmzpGaDSo6tz8HlbM7K/Yk+IEAgAkka6kqd8I+pKtjUqvmnWI4q6DKKnS+e/gp4hytUmgPCcuAgP/ogjmolNDpEj2YUB8TMa6OUsIa05H9FB2jHzxU2Ruan3a0GnnE9XfesCsvXbWbT117vKc/zLmf25XTq3b55LKdnb/1yb5vOxg5bvDuXbM/84Ov2t/7h9fsCy+F3bz55lHQ+V46JffPwy4dBdLTMe+xMqSIoYFqQsxsIfLDoIV6GVCuMFPX56Lyp0CXGAE+JGUNpgcZKxFEuT1J3cbJzWqR84YwDI+3CiqE5BKkFRxuuq3mQaZIhOaqLUJ/WE5IEfhg4OUuw7/CyZwZaAJOWFwapJNmLsLg7QJJBxjEIMpVaEQKREaFpJourhMQFwWCF50tX0DyljGJWDnUOEbUSUWZdOh3yacsqJTAGee4dP6pVFNS/2wHFdxpJMsJxGnp6ZAhMKk8ErZNIOliZS5xYkVnA015apVICV+J+Ai3pkrNwhbNNSLm/mRezVDE3eWiXPN81PXzug4RlXPoKIj0rHFS9/jwBuFgxGvKJZVcmJMBHQjvHJHwRmbrHkMnonum1hOWfStK2bSpWtckJOLTtrVHRVGyT2NFGFPrNIDKmWy6oQSVPnPDhldYSc4Veb0aG+EsqtuE9r3Iq978cofcua2Wv3nktRQNUbQO4LqLO6jsaJ4dMot9WqmS2O4h8iP+SpRqyvauKENyIYyE22r8UPTEcJOLSjFUI+MNwV0aEyVud+1jXfGObR0YWY9SQ7GFq8yotis96yaEcQUZ0yuoJR0ZJGJq9K/73FHepopwj8zvRr/GOuRh2CQmS7DIRlxAZ6h6zQ5vcNRi6R4w7lKeK71dSJgTQpOtMjXIuKBmmi/BZTBpHHdvPVq+F1FY8WJzen8aCg3mq4vk1UXVsGAlHt19FFfffyW//Ye/w+Lv/ppdOdksHiO7PtuAT4a99iv37cGvPji6Zd/wN096ve1g5Li/z79g9k0fSvuTf+Ku/ZX/6Tl7+h2P2i4+5hWciPbM5ZGnryXFYqJi4cqRy/guzpOajP25NZyoulWqXomy8oUheYOescdicGIySpkyNrBkY4Cc5AxsUsZi0PojAs3VsSmCSZdaR3IOqixs0fQERwzhbLiGTFLRSE7FoXOWlrTySUBzdnkB/pD0WdkwQUNL0TU0/XRc9M6Yjor11QCNC9KXbcPQZq1OIZ451iMVzdiFI2nAH+fjG42Q0IXsarunetRgJs+2R5I6eazmQnRbdV12cyinIuogn9xEMlhIRFORPcnsgvAYx7ORLGjMd9Kat6jhHqDZOsAyV3Gc2bkw8TbkAzgH8SUl0sP68upPcw0FWYGkTneKfUO0md/u2tuuDrTDhwYmESTRlSXABnkXPxTDcN7ZXst4jEX2lNT62nKRFFAivV/AsvK/2jDRy7/k0NRygm3fVvl+1/YTNW+BIBTVYDBgENLr9qagwgtJwSbKy1GLnaxXPmjqs9AdKZACJ0TnA8cxu++yg77F3nPbj8QM7gV4YycL7MngdG0mV91lwhHAs2ls2cOkxa4+yhVsF/sdA6uTPUQiJznSP2sWA7USqXSqyRrJqt1yzxAGan83j1ywPREDblGHAwSM44J/ZtEC04wJlIVz13JZydsvj1ezn5YyH9CR5AAcg8o1wuzAINFkQ7jYvmK5l5TmzMbmYBaeCzzHJNjMxhcMj5x68EWAma33m+UmPQWq+gC/qpmBSmRmTYsZtEiq3eyQ4oetGB8YO7V+6QxsR7f0zOC4jxj2IgScKvcHTxm1HBwgyCbzRGpp3Ozk6qm99uDR+LW//s/sM7/0Sbt+4/JilNpOnOe5XfErduPOTfPLhO+fGBJceL39aTcILn73BbPv/e479lP/4Gm78/CS3bj25FqNPzoxe7Db7a/2cfV67pe/4OaXNOQ1axYbzCdY4hmoP7B5PheYy0iglsEayWlydSCnsMK+WPtgYzBQA01JMgXFJQ2UTv5ZfdfOZzaAXW6yTvJUzmoqBq0MSdybNIIx77zGpde4eS//XtVuBqYsbZQObnI8eXYJ/HAsKFGN4kBEQcZeJIqV8crMFGRTa//RMrPOwEK1V5SQ4JgEIAoeGcSfEJbMotZKK+T6KQlT2RoessL34PvhxNi2qOAeD3doJdmhhoIeE7NBoKjWb4JOm69pF8F5iJzRHbYCq6HkJ8n19kt1fd0bfdS8aCfCOnuaESK6hIgJSaSoiRcz+MQgOBObCbR8mNNKtoMRAnO0YHcTr3+O8lWbED2jhDoDO2GgI6Siw9JCR2lIOJaIKLwxXFeF+14wOiJvGHWknM4RY7qVYEbtYiqlpLuHMyun06UcuJpvuougYYWByl2gUlCQ8iB+4SmNjlRHV5JnkijRk75cf4y7CXo0xCyowlLvn5idVIoKy1sgU8xWCMZ0fLou2KFy9NRRGK6YH6GJejIxvYz1v9LwxwCoDbBPZ79zB7pIpgBXaqyhJNgBhhXfHatEM1C8snSqx9dyD86+RgkiAeCiflLa4UE1EC+tUs7KZC0nK7YQvJj921RtyJsgESVXjP1bwT+6hoSEIaZtLAbc9AIYcP9lqTuUYpboWP298l5VGuW7WbjFZqndrAQ32YjrmJs+D084D30z5AQLxuh4v7lIlK9g9BEcHc6ZTI2z9Xjh2o2pKiOSrvoMVKwDzkhscArJ06kg9jDyYZyFpEHEeqaLx7/M4Wu2nZz42Wtpn/n7n7EXP/2C3fE3oiLH359l2vve+V7z51tq462+vqxg5LipV++YffD9aR/+ytv2t378pr3w7Pnr4yW9xjEt72y3Rx//vMVHztMvXxWMeAzL5m4YRSuaaT/5xvXamUocG4OZVjvQwdMPva8CXZ1NdTY0Jn3mKFETvFVpODqvplirUxFWxE72DFsPbk8Wn2GIj7a83TTbDrH3GFAbDGW8WczrMkUgjB0iTRynPvgnzgymy/xCapB+Iy+pgnCIKrZ7h8OAng2X3IQlSYQx/I1JoJ5dc4XQq82BvOA09vc3xwKFZToUSggOUmZME5edPHSSbTm9nPDmKOjVWWAQmRhPoJDeQVvY9PwLO47iESqEtovdSSOZZ3NwnowqF2TWT8umx+XMEtgcSIxKRJGkBA2aS5FZSIAUChGde8GTlycJsKIO9IFplESLfGFUQoOafpw0HGpsqIM1GnACcY4172RGVLZnO7pwVIKyBWchJLeALkS46YjA+8m20bCAs7x84EvR9PF6DF2M6ab50Qq+qC/xjErbB7HsAedxcukkinhNC9YIp6rfFYDDDHEBKgCnNkqO2SfWelda+c53kiNHjLEq3yyOYjJ2redDiZfknlm1WMr1YjXw/ADhDyYyLh2sKXZ0XEHossnxalIV14Z8n8pyDrIuSCw7i5E5m6ng7ZbEtixvUBKZVF5EYxwVQNGmikKgFCAxqGmyFZd0/sOQgeiFvjxn6yhliSo7s1yqRRJdGwt7Fd2mvssrEIRwkC8o0zN1PXyZCIniFUPxZMbm4rjlItXS9UHdILNZinbzm8n5iNRXsP5Z9k1zLFTwpYFAu1IZhBlKoIGmqr9rU49p0xIlZBPloKUaEOetxjlTJkEteu7upTmLqZ6m2zuAE0leFmKZbpe3bVx95orZp80u3br8Bv/+6OyRPXf9lj33rnfY+X72JQUi9uUGI4ZuzDv3zf7Mv/+qnZ49mJojT9I2uXYt7bc+a/axv/Rz9t3/9Qe2f/N732OP7gLgx4IVHX5uo6DopGZCVAeDGE8gOAMCjlhc5HyV3ak2pwM7hLJnkY04GUBNoU6p02ANhlMMm89xZAHychXksLUB0suBfniZijDV+NmaLhA9SKFEapVS3potd4ctOc5c7iBsptiP9IAYyDXlLKBZPwOCSgxmpDJ4/fRumOnGCiF/H6WcAMZrg5jI8KPU6KCWDcOSzsMot8oB3w2+I3qKGp3dTIcgEDK914BPTTadNPQ8129zzirxWNTpBlCk2h7hqtduFGJUPs7QRiT9snJokYFGgLUQGjzpjsCEZroSj44LK0AuoY2AOEOLfZWxyB4eJJGHUZwgrq8DIdoxSETkkcpU5z17kIbfRDjUkAOod8lrEGEQawrNVKtcfrr6F4/hnM5h5CRBL3xwdNTA8aMgd3zRzmJjbUlnka0KEw7QfSQl5TukdlIOGUUFnzvjY4aig5Ff69C4+5ZTZwg6ZSA2HY9GZMCerGKjd11F3QzTGah074ao4dQPL0IrmnMoO2O8cPSzFEQRjPgEB9TzrYYLMmxR5Cg7xGAvjZrgPHMBAHCAtEbOSXL/JkgGM/UajgPEfRnVMA6SODGg1T4SHEYrTagvyZ26fJZkimB9okqv00j0/hrCa6MQBKllo7sXv0Unu1qdMba2pyNWhUoptYicg4kPz48pOB6sLkVwt6hpRKJxwMThykkQRTG4xyCwZsF+Qs4Xm1xjtlGgBgI33RJHTCiW/S12NruuHV2aOMQbdulIRO+pPab6UEW9h47PBvkWhtNeelyVCcxMbRhnO0ByhJLg5B1q+k51gcwKfxnIag4rdgTVSAQNVJvennuePTleQGh+dNA4uTpPhCUe/zrxfs5v+O/6Wn/3+p9/4UWzr/zKtB/+bx5MvfnX/w1Orp2emF26ZPbRP/rIfu1Xz+wP/8CJnd0txmWKgJNo0yVWyyjSBMazpTvYgdCzLWv9mJiwsO0dFyT2kMopol8yhzmABWzRrbKFAQPtY8luqryQdCq1i0P8ayR7HlP/AXM1GbggMQUtooRAxMCT8JAVQo9m0UWum5onLmFR3nfCNG/NlASBgOe5BoFU+oTQW8xYtAI2Ih4uUFTECYhvGcU3Ir0z2XTFVdDyjwHXgCg5KCciBHUcnsWlkaSo3hKtnIyLJPYzjrrbZgsaxJheQcxMCJVtUxAIhC/nxTK6CKWrFZztyBWKdID8R/C+5U7JSxglmST2KGivqkdRfnf2gDuBX7i3bA0EhuPo3umF175mkZiZO/CpZbgd4iM1sbDhlw9Bg9LQexl4vgCO2FbMPGk9P4PG21XKYllDG4N+vspLNMhBzwdzP6kM1koILoavQuFAlUa4O6p35/ApGM3D/eHoO51ZZeA2EtNOZ4fEYh/KmFGFtehNyc294F0Finuvv6MeM9sDR6Cox8BnLK18c7amIeVxCuGSpMi6RLGdW4awSc8jWKwaTmh1lmFdZRnat7mDo8oYDdcxmiTBf6iJCFVCpnWpKZIz7sKIe8MADDBElege6l0m/RLsNGB23Ee01VJ55f+wAouZYETMij8B0uxAoWMLlh+M3QCIoU0lD/lOZqdJPhXU1C6y2ub6A1Nvz9IjDsr+wyIGgAaJfx/gJkMOFk4L4UwCPrCNHZKkzfIa0I5xGJfhECkUsN7EsNFdUgQudGnDW3lUMhYuSZPIo/92L4A1hDzXwgXnfoFeEhemlLQW1wBkskH7EfN69iNfzPOTJ8EdZ/u53brxtN24dtPOzs++5EDkeFInR+eN+FlZ03pFRqLzxrY+fve49t3jd6+8anb7dg/Xe9yXXb5UAcm//q1m23tO8/5rhYkfaZmhaN3YASk5ptO1GDo4RWfbiyYv4eF0tMstBlBbqXIGuaammfmDpYTBxDlniu3MULVpawMLnjN9RyqiaiLhHHSGyhzmINR1UrI0XKeQOXd9JXKUIHOPAkWM2kMIH6NwNXwJ+g3Sk7B0UoKD2ge7F9XYUvdS/1f/u2FD7FwqpZ82uQozHUWQs24LCEXpoGl9yFFIjp5s0qSXLHcr9kBys9ubIfixkNExzlyO7/jWnTK4R63d21EKaTevdgoU/4FC0IQzA4WLoZtoJAvLnbSiOVQFaHSelr/wZjEZOBSEypdsBKC+9mHw9s4RVQrjHkP9q8DEwHoMOANmkyI44PfW48WNCtDS6jEMRVZcq8J+qESElI7eJTpodY6i509wuaWOxykOmmEAZQSnkPBKdJUeYLJCFSAsQRGCbdi2rdT27vYn5X04q/FF7xok0KCalFPHe7UQlipXkXVh5aR7ZC0fCM1RfWCQo5mLjSJLkSMVeo8mIzkSGrFVNZqACASCDpG4iKuo+t9AEj+BWNgU52IWAwQGUgpiSWozsEDCz024/xnUbQKvOFCDoCIxNgfCQb0sPsolYijCO9OeFHIsnE5yKKS94GYrCmY5wrSPjSAHY/9Ma67KqnAbczh0B6EsuRpTTMUM7KxKRhug5nLCQodjrLRwb6xGLwl+4b45ZBVrgLeN7pwpXJ2l7DTZR+00L/C/S0Ow0Ai1kqqVA3KhUQlpAiUxl/y0LV/qVNMHUCL7N8d0jsJixxb7PjO/Y8rMxTlUF/admT399LN26fSSPRj7Ben3fd/t2Wef9fv37+fdu3fVitG/P6omCEaO9x0iZgxEHvc6EI/jv6/7HK7xpLk8c82eqMQ6EIzce9Xsv/whs1/I3V9+2e2pSyWoGBj5g4qKBDWVSHC49QFYbJVQDMcgjAvKegVWkxTJ5eJ1Ksqub2hlckxgRUssxuX0IUUHWb2CSZPk6pyHGm62MxD6+XZnpXFDIYgjkRrputp5aA9sdqvWbsw2E6NEezUayh8aBIbppRNLzeHL7WfvQ1/aYEQz9SymSXD6a7UvuhgcFUzxPFQpFBDkMEboa7BorkBbuAQPLEMnVGeDAlvYTJK3KJVMZ/kYzmir0gcQAmfCJTMPOBjojLpkrdHKTkPmQKyihALXQRUXos84OTVKagDQcorCC/KYaAZxdFwFhWrlKOnUFyFFoie+7Na59cZYNAkooQlXABZsIRogPOby+Y1jiF9N41ii+qROjWCQKBQXb80hr52obC4JH2pDLEJARcfoeKTWCzdW/MVZVCnaIZU85nTQZj9s1WqIfJhPA2TvNjy+DVU/fHERTFWD4lzMlM/rfCTLArL1VR00DAv0rZMWFkFVXiiXWW2/8JCYkpypabhl6LYVdcA+DnSZqcZWJAEgWmmUAcnOD8TVsGXpjWOLIIBvq1FoULPBFxbsEAcycNCwFoGnWEMXqCcevUA+rn9Un4AUAtqBFhWkljaJugw1NQ3utbGQY5Jl7/rwMt0lIqnZ9xgXgINOuXrqKKN+0Rsk0UvD0jvucLsA0VDrWQ+L0VD5n5JfAQsM1mo5hdN+7975MWleSYI3+heqCCLGIEK4qMkJ3QLI7jPyvejLZpMnFDD7CUjGYKoPzCLrtOD1DKexGkk+Xja2woxhOEnhySYsZObbgKCu72Oce+yos22HAOv22G5Zfvj9+3fs2tVrM/jQ73wqt9qrr76aJaLma9I+X4c46xE3qEzTb+5/fn3g8aRA5dJplc5/+RNX7Oz8GDv8xojl0onZK3c3+5XfuG73X7lrv+/bc/+Wrz0ze3hiIRqBk6o/eSMUmiLjQsP0jnGAiZEpE9EOjpGdWfDkaU61slKntIxNl17Q9d6OHM+E49vKkI3SDtuL8zWqXZOA+3F9Ueyo4iSPZA2ACSNZFsqNfalX60kENnpNG23SPppeKqnu9jJTQSj3mscrAn1LWc06dYxi5o6+aXTjzbHXxzDoHEBgiQmnHHBm9XFq5tkovSBUsReGbFYCh9YU76Yn5L4VcR/wYfheMXfUI5zcg0k5G9Mnit9RU9QOXGA7lGeK9lJSouzoHMSnA1yx3dhyVWLXI/E1NARHA4KgT1Z5y0So9k3Fmr6tnik74e6akdkV1QE62158JWgr1xj6HfsvGLiqd7jStIE4bpZti1NByLoKVYAtyHJy5ebHVt9r/wC8n2/V4DwQ7Sk4Uza7mcLI/ZD3QB9xwNgReSOQbpL6FPY8n8/EqsHmmT/cAHONC4omCctY7x9Itp2Hmv4LLXOCn+twtq6wiTKO9yCSoZ9J8A+UaE+MCkncDKomA9TU1Cug3pxygy7Qc9beZwMeeYvFlYXVHQFbZOgTSlCsiA5NppaS9Ci+WDHBq/wcKETWvkMYHjRvM+fZa1VjK+sxSnN5vg0ndgzCWl7iu6WZoHj+6LeZ+uOjrN3clUe5YC74CExZGNRgZRZFM3m+Trubq7kJMKj5P3Wc6nUEZnxzfZMmgTGKcg4TdedwdE228S5qQIhrlP01Ds7FWXY0rcxpmCQPgpLnRYCs9S2rzth6UK1soLMA8PCq1665i1sQRmYD7EQBsVaMfSlB2TxAZ2d8qE+l+m8JbDo7LY2V/3DNzT6e1ABazV64rqkJBEFGPIkygzCKeWeWEEFw+hf5B7UIKSpBIIYaHUHaEuRBslA0zD3gH/bM88cXaY6hupu9/MpLdu3aTbty6Yqd7+eIIeodDx8+nH/jTwgiZjDyhM/+kl7P3TD7iV94t/2Pf+dr7dnrDx9LYD3O8Nm52e1X0z74Rz5gf+DrXvRx5675paeh2oEkY2ZNRzVZWoYsdjgHpI6DzVgTZkzDvohlQgSI/e0121+jjqhWAYpkkLTGyDwR7kegLWGQNxuumfZQZOWDDVGt67vK40wm4s/h9QAAIABJREFUItvFJd6QRUR3sPRnfUkMGXLIpu8fI5AAsyxq6O1NKBHEANuwyJdMBXnG3Dv6JygwRiXDh1NFfqdYL6qkXWStGmsxDSE41w4BxQHTP6EplKtr14m3VONc+ywHRuhVhjMNbqCLsMrpwemzRqxga5hStYo6xsmyj2msXoSa1gisMtXyIKOVnRpW0FuNpeAsHCqiBntJXd2+mjFS4En9WY+QGotfjSCANx9CQKyXaTb2Z7LaxIJfBQI7kV9QeJNQXHONHPUUzCapJNdVBSGKAS5L1xyYkBUKkdVvIEIvAFyR6qEuwDLj7Cil3mqqN5z4olBvEk4xgaPqDwOjf1hkYHwT5Aca+tAIzyd2n2ocMVpQDgBRMZVFvBKiXc9ySt+D7qTZzzoQhEa8VU1zaVDpdmOX4DkADaSr6HKbIT98W1FZijGdBJIEPplxrhIR82JIDNZMFoKtj/YIlSzIcWg8QNm8rYjShdOFmFrN08UcG5W51cyWRRYLpjUiSaLiiXkufKqOMiZBIqfcuQ92gRBIsra/UtGj+SJyI/CXHXlrGRDUtklx1SC8GjYLljpmSU+2Ee7fZ34DjWKAkfCotIkQ9NJQqtp+akGvbeVFITWV0DSMDGVCrOfQUWZ3DoVT4F9KtiEO+z9cI8wdiCa5vmxVMboVVZhGWwZAtOqBoAp8N2tWi7sOQUssDWNXvnTznVpvsE9Lj1D3GNXkjRnq1mpsfoD0Rnbrk15HWebR2UO7fecVu/bO95rtF5VXI8IWB/zY15cdjByIx4t33H7uN99jz7wj7Nnr/gZEha9j1a5tj+wPfvctey7u+4PPp129VDWLMDs/suHRsheMX/vhGZHgJCEL0Z5AjQIFvawR2tKCvaXt4EqAqNpODvwkxUfiUdqHUSDB5TZZj28BiIPDhliVKgd1RdO+kH/jVH5GoTXcZnK7BwjukDdQJzrmhxua5kNjLNgKpgKBCJIlVYTdUjJggfY5kpDYKVKdLW7Shse8G2i1Tp20XWP8gpTJHkENyOToJCujPRoOUTPfMi+toGEXUx0MfOnlInktW1xtiIdS7zZq7NYefdoMUDlvBS0EHB7FvJtd3Pz+6b/RuIx0ecYLxlxJgAmhTpDMKmzdF5dexPMxmCmyh6TiaVSsgA/gISFYokIGwyqTd8GuQ9I1kFQWoS+rRqKcWMVApV0cdIW3hQoMA3U2oDPigThpsFvR9NAdVJWZ6hYrjhsanHwsZmifpnaAG1itISA/pWpIM+oK1BxSCF0duSiSLQznCHJsSIAWXzQJTvP8FQLB8p93vCpVGMBLsfdYV/q8LiBpc04llPn9RU5GLJQaMWAsn/VYIcx2YHEJiWoHfaOMD01TyOhjn+418cQ0vaBKJ6pJF3twRjXosmrHax1PMS1Odrwg6h7VrlJ1f5coDyHdpGTYZO1GDYtFATgJGHJ/wiiwlzDbLTs1QhiuiJeGcKoQDfaQQ3BnM5SkJCwJuLkCT5RBDzeg9YG1ZZP2AqjN8q4VFpPEYMC4pnWEGGGXx4qAPXoQb5lTjjYwSKuQWYRJv0d5UcXsDhWQmCzSrmq98coZAs2HGrFr8mfV8IAHwnnqicH9h/0OFtLIsgaw11L4qJnTG5lEbvkoihcpAW3v7iiiw2JshXTWdj/IIQd0bnsN5pofs4WdstPn8c7dTk5P7c6dV+2pm8/Y5ctX7Pz87M1Chze8vuxg5CCkfu6ltK+/9kv2jbc0eOtJ12sPr5r9W5//J/Zbpx/aH5x8m12t0Liqp4Fh9SM1V81JTcVkghItGxPKHfBhJFiigcNJyrfeImxQY35Ktk5VMqiH4I5e4gKvs5pI6+GiZ0zluOmVGE4ibpk5G2bYJuGAWaNgUwtm3E5CBy2HMozjB2yw3FEQ9TrwuUhFONqdm0urkxjJYOj4SdWykBGwNXRSqseEajsep3MU+FFPYVYriRde4FLVDt+Y9XfF1fGxY+9uDreG2AMTtzPV7pl9iKkfW1n+qJmzlFgw63BjSh3k5CBS4wNQaaA6JcEvUFCltuvkAk1ENYopoESNdTKsMpY4Wv92ojszziwfBVdKscSoQb2YvkcjKvEWCDE4xQqOjAHh9UDdBpWVimscGIspnlbpYmLZbNas5z/Dk50ubVSLd/011Kuk7Y+uvmCz6uAU1PZyg+nmwIgm5H9iMVTIE/h8kUExcNnQL0ho2qxmug7XyRvdpYGAgGGYj1lBohbz8vzJNa93lxLR8e3BtqRBXdlSJB4zxyNGARHPGVdzQzCvqfNB+BsYDvs4kReRHmLpZEVUU30iggxeLVSrfAvJChUfNcgQZVMfIQcAsKWlPDAB4GReYORe7JJstQy5KqOrDNDSSaIHjUhiudX+qiHcnBkt6EJY/rQPErpnjdxU0GltVA3i6PU11j1g8ipoyBJMWcj+Fa+gvJPLgG2StEnm60aFYhbW3qrbblCURQ11hkEKB+VPwhAM5bMb3Xw5373/BWIsuA0aTGbFZ0d1sVRXYL1NSBpzaQ15gaegQ+KgCmAzIvZPwrChAMoQOp1ii9Sgwfp5syzQpu1rw6DiVVF11S02Bcf5gBebMBONmHtwZ/Q6doxANn9imcYWdOTVOy/bu66+903+8vGvLzsYiROzFz7/Prt893l76uZ9e7OLPV6n107tF3/yBbv9dQ/jQ995VtXrOWF90hI5PRSbhKWvgJ4GkmfukK0wqhhlWCnn0eg1G7aY9apmDB70riDhAvrCHoeAImIztbi3IPptlJ83WtHG3EZUJRhpSDAiqUA6kDXNTxwkizmLhvp+IltqQ2toNWD9aKl76cUBV+lGAIgh48QpEQ6cZOKiBh9OmcE+jLYE2U75bFL1+Tlkygd1BGyifqoBsNAl3UOfMiNiGeD5R0kuKmfhg1w4fdFPrLTbq20uaywr6gVTAiSXdQJ8UytQPOIQ4TBB1PRCjAF2ymIz+a2w78J+MUZ8rggYEw44t7nbokVnXUVeUYPcBZTM508SybC2i6xEQWZRAQfkSuqvNgwdbidOOUydnyjlqKjYFDUOPux5i1E9xixySC6SGyKWTZdrl1INHSVFGQlrIQ99Jxv2t3WuYJz5huczktROE2qI86lSQpEfFH3oR8tA3fIWnuQGE+rmOEgSRMFOBOgBHhCy7urlddagIZAorBVPZsFXMdB2yPW5Gtbqf9CDE7Y0FAfE8+pkT3JBYwHo+GJGRTWhdNgPMjsHyQOAfp14rs6Yg5Cd4IAB40TAfoy5bX4caI4VhVWzrPI8FXmMtJqLsDhF5aAtRkQAbN2kFIB1nS8V2e8ItakK2WcNh3FTaZfdvECG1LMqNbCaPsEChpG/55NcU53FFV1639GcNoRvLwR3UZY1YWVOvX4zQV3YFNKrHqD+sXFQmOpwqQmXIBpKc4GhHBIoYvwPgUEC/Bo9rd4MViUD9iMJtxnlhFk0K6IPLrfePzrxjrQTpOpFkzqfQMn2Ro++Pm6z09NLs1Rz4/otu371Otp839rrbQcjB2H2xo1DN+Sb7T3P/6g9/xW7bfHgzd90GLQzt0vfesl+Yf9Lfv/25+zy1fcf5oHVCjEqZ0cUEE6OlUXwSp04E0NUZWDVLuSCj//sK4PdKLQFwrIn5U5xCKI4+CPp65w9j0eEyEA14NFpgAIV2kF3qTSfPTWjux/FgfTFzZtgSJL2BL0aJyXURjyA4A1ip9mGRroqPDTSG6KvM6q3UNMDnXL0Dy5ZYbVnZPVFAjRC31/AFg32ABVxc2jUH2K/QSMyetweWjlCJIe9YqpipDrNNii3DCzxkAME4KEcFLCE5xyzmcRXyTTL9lQs79EuYkAP9lMQFNP+AVs3JsO0y8gS1mAaKFcD+0TLKSa/AoRkIY1sDFlSNCmq/wHw6wiwNUgOsu44qoRftsXZ4gRgyNkUUj+Kqr2zO8GrGjeow0QLXAgNdqzkNdR8mhS1DmWUtVWGE3HqkfdmyvgAkvnaJM2mVGFu1KfgziNERWTILnS3SeKEwlqEWPSR4NxQgo1cT+NQSxY96MDcxM0iFk+U4ODdRXSrSb9BLVFQY1dUoTXg8Ed62kI9TO3muLElK0gGZgHUxmdvnRrUurSHksPCTILILyzfDKB26OCpmm0EbU3yz+W4HEUihCG0xeLdE0ie9g8CSIDc+CwxhhgRJoaEz67iZbBlruY6i0Y95Qo5LZmrofaVBHWTCHgBw7HIL7owLQqM9v4iHEkoeO4hBAZlZCR30I+Y4XkuQoEwrNJs4j6DFAurRKpPDxo6aerZws8Q4qwJxuAVMObu0h7/Gn9TQjDIKAlpmxIBpi1L/ZBJNN2scUYDOgb1zOEeq24z9RvZqHnEvLvaeJ/0OtCRs7NH9urtl+z6tetczDePC/B6W8HIce3Xr5s9erjZ3/7YR+zs7O/a1Su/TZWoJ76O8PT+nYf2Qz/0p+0D2zvHJ1/8XbMbAW/A8NapILqcnuWUh7NeUcHE5HomDDP+BAnaoGuB/zmCm511F0GXQyNDs0NEFmeSoyfQkI3iL0UDGUezf7QVrlzNcK6OmIlMOwvQLW0mwWIl2ayKyoaI1GDq9S5pZ6YK7BWXWOHorFQle8GU9DylbEr2mgBxlIUM9RCcLCFIqsd6rf82CNxCVJsBwwBSYMqne446cyIAHCvq4PpayDUmVkm1F+qsd/CpI4hupXTNCIENpNT7zIKqil3MxIlXJo8Zg40104nXZX1B+gPpaI4JFYNCuUU6MKiKzkAHGqiom1NYifo4sCs6uj5kHABzlaNhK6iY9Ozw5tkc0rbV/uHkZwccLXyFeyLBaSKKwavQPB1CUoR8sN/Hije6SRMER4fRN4vrZpoWIFwt1znyCsRMiM98fiN1YEtXZZLs8HbW0k38PqFb1udHE+EwoGzsyaW16eqrPCvKCtuKSdYpZg5VAnVXUm6mEqGWNFeCELcF6Y6NVcinpfVhpg8rCm+VXaJ1hkweX8dxiYF4ujHoAl19bOFtQmndXwFYA+EVB1GJzQvKgTq1ageQ18dUUY0pF8uabcUgoeaFJI+lmIxeo3agXJSklc+1iGqrxH6LeXAwLm0DDPYAOZ4FKT0YkoeSbFBmNcser+Ukm4Zmj4aa1p3d+0FejwjBjGplRcuzm4bm5HpNzjAplvc3x1XALh3BKE0LDgxGSwVE75A4Tlhzq6YJCEK3+WKLdxsOsHfm+AGoXok5bMrJv0hccVz3ycmpPXh4CKA+mv98fv7m0/z5etvByLufN/uRH71h//1f+b/tne/+3839i3/U+dm5nT1Ie+7bHvrVr/1dv3bpBgODSd/NwEB+LDIfL6KVzgtQSxvOBu66LGez2Xre8PGzZWGrraoiYxEDUxgieMtSOVD/jqB9ATdsBOGOckLKTCs3mmZj5YnezdsGEZ1efGmiUc3pATRDttXZekNwhLD6ENkK6sUPcRjs+X87MjkefhL0NZOF+aYBtlQeY0x/XI2YVd4o4hlzVcE+mOcTYGexs0m9MchEijUotXxxDlSHKsAHDVKuo47PAkU91VmhlF7ME5gHhhVYSe/gdXReSrZdtyMicVN4HxqiwtUv+RfqrQmKMNIgCwOpjK90IQEflVvDkHbRwriTmYST7Iq/RLe4k+wKhz9Mz96izW49YxqzUR2acNW1QhsM/S4yHLZeCYwXQj0u/E6e4PgrtPALrOnoAzMLVFQT8Rmb1jcs0ajqdUXTWyzysPQLkCobVbAL1gwY0ioll21aonNOfbV15yzj07DI6rwI71ZslFGdXSd8OD0qUSIWRC4Xxg1vvOAGtkKoRMzNWbPfhE2FTjEcqks2ldvXrGVNccd99gKEhXax0v7pUi2DI2ChmFrtSPSyppM2IreOK1J6WMvY0/2WPcIgr1AnDMKZxJr5ia3+YRSLL/ICJ7jgefui9ztll9CqFj6gDYudzpaCWjeNgzLD8wP+LSiuHQa9BDcIoTjUscu6OgmINcHP2fenxmK6cKPcPUBB7GU8UB8d0HQ6ZsIbKZRbQwI58oSOKDHwiPDK8fuN/dFLN5lp/Tz0JLgTTbfilPLk0iAYC6cczaQQx5SqGkXvykP3+mRzf/NKjZE78uiR3bl3277i2Xe+ZSLrYyOIAKvo/PyNvzue3NO3zD71r8z+5j+8aU999QO7evOmMpE3e52eDTt5sNu/fPbz+b7t3vbU+Q01aCxEqFh8F52WYaClCl7CrsiImAa0h44NoMjHB216EISjnCNdtQn5XNkXQcPX3ijbyBOb2F3JBWubAxnTIIGAia9QmkV0cmGgcqOwRisuH+8PIU3KhvFPAE9z3Do7/KtRHGlURXkS4pS1JSjH5NHEjzIBi/RdaBBgRMGxZMWULNaxLS5Hyq+kpEPDcVTjmx4kCQo0LLlmV0iHmA+U3qnyjrkSg2U7pVa2TiTj6decG5cWh+B6lvdDECoBA1ejACfT1efDSsPszJ9RuQD7wVTGYOtfNpYGbhr9IgbCYQBZNrrC/NuLkCe6R/ZoNuJysjJcAi4HBuqZsRViQBq+Jp+zDGLM3xIxs/P8NNoJoQWUElcDR3xwgJXZpbCKSyiAwXyehcVKEZeCtvEs1D8wAZbz7zIa//mCXw5ITRXShCpcN6vY0i6riLyshZaNsI64m4k5xUbyDhVPGHzV8o9ee4FdhwPWQKzFfEwpDYV+4Cy7sul2/VTnSwJV1GZXoQiAq4FnnpyD1/sXKiAI633puasyTQnuzDXaEbVgFCR7pWRvGYYJzwG7inWCC+N6gWEWzdvGsq7Kp+jyvZ7jICHGtb9gAbzaA1UP4ZA3tLDTlxb5CbEXERJXI1E23CLEuJV2hRUiAEOjIC92SUGEUgghYRNg6ud0LASIRGmpQ6ijXL5rsoYYmVPStq5F4zmWEijLn8vAaO7HcjugBIC06OY9wbuUmFrNtQs3Zc/J/5k3uR0KdMAgJwdyv4CmvMlrO9ns9u2X7daNp6a+iHZ0pN2+fWqvvHLKyqhebwhGjvcdSqsHJ+TKlTcqqh4X/OxzZn/9f37aPvvrN+yrv+qhjQdvDWA5P99te5j2vs++w65eP8vz0107A/oFHGZRjNQjjYwAiS7l0JUOyHHIC1FGRzBkHchwSv3WrkHHNQdkCxGj40NSAiUH9DkWeq7PFstFTqfpWJCEutBo4p2cRSsPl2+qfA+y7yAjokV2chZidl00I1xOcW7kKaSFItSQ+UqN7eicSDl4B1xJqDwxFM5MJRyKCjkUMPWuoRHIjUDEclxhLijwGX3ogVPgUZBqV/daVwBP1zPecbsDBDDmQYStkzMP5aQ4iTmQXezQs6A5ZJltpWEoUU4kNWQnQFKhgke0KMKJiqDm5dgNM+FRBRa8bS6MGjEfjVzXhBy1EK5nvxAWa3oOYqElx8q1kmQ0nGheDmFHJGmK+8KORGDwCq8G5fJI9mUI3k+Yh0HBkqOwgE2pfLPS80BpvY0JxmLCCp6g2Xsv0TFi60Q7KnidcI1G043hISl80kaGpDTJ2OXBC2agcEar4z9E+ZZIqDcFymIsrEgFcykgG3avAQFovgMGPHq5r0J2hBxR/bc3XJIPtBZvWXbccKw4s9gVhblK+ynIlMmOa7fjKzG4z9icMUa20lKnzoJV5iXiOkXwgV1Nb5cJ2VAVxl1ZFUIQpHXIj7AzzBnHwr1LuFfBT5lgok5dMOv9g1akJUvoM7FpTE6Xtqs9RI9awUOgAze158igMDRM4b7mmQ/kNcS7CdMumc+SGiTmxy+m2xOaMkW3nZLTMzpPJebeqU7K09DL8b4TNUmTDRGEe0R3ORoD0+SNC/uH0Smfj2thyjFgBpOVLPa+f9E6DV5HAPLg4UO7fffViY6cnT+agcjv/M4Ve/e779k3fuOdCXas42UuRBHHdx5/cP9+ycMfgci110m8P/OM2a/+2qn9nY89b+97yu3So5O3hIocr20P80fD3nP7xM7GNm4XSOVdqDTvsoRBH3rxqMbFTPp7R9RS81+SKC/76um2jvOcTpc1mLszO43OcKRV5N3Cwvm+vI8Fk5EgVSW3BCeRS7W9YBiEFoQ6jlNQ+hBCYeshBIR6ueH0ujVR9oCGkIefSIUH2SqLGNaENzOsY51FX/VYP2prpGqWrNCAZCEpZULyx3xU6GZ2vgonxIRRTpFLK87uClaW/SFQ7RxiKGfL4jTxa5nYXISpFil6UVrklWZmGLlUAJJtkMXHha3DfamNkahZOM/rYvRCs+1ruYIc6ZBRcihwuHB5E1emi39ZlSzz7gQwxNEJe3c8/40RwpJYSh2nGt6do9PXM9MZ28Jsw02YL/6v+ExCEBmGyABzOfk0yK/C+khrQqlhu96mbpP0zMDHNRnbXbNiVe/B+YX+DqhDyUOVixKIAGyxh+Qg+mZz2XNqH6NDnzfXJ0+by5qLMpIIRYkHy9Or59eFUMm10iiRPwAhQYMGhTlnXc9nrCxbQTgrXZh6rG4b9zZDkaKoYxEYjAplGEikvbqnltNoSKD5WvJsV2wn/h3jgmLLonmJs2m4/jkY/osZ1A+UMR7LqgrNC43jDbR1qN+riFpdL2jFcWKkxS1qi0euDmX4Ac4aO4TWqvbFwSFQFzH5+PkS/jKWMo8IYwwF/cIaimC90IGN+JqWBbyoRUFQ6B98RfDzGQsiIKIcLWlENKJKogiE+CoZTTcCozTIE04ZFlSas9T+jnxmWBz2J0+3V16pe7v76lvx+af2W599yc4f3bR3v/uy/eZvXrGPfORl+/N//l/Oe3rhBW60+v+TAwnhf48g5OwMsX6Y3b1bgciBkPBnh478pz51Yt/wDa/ae9/7yM73vqjjb09Pza5dzV645XVs0Uf3d/uab/ox+/XT3+fj7JvMrlCG6hhvg4y+dPig2mUSsUnrjlTV9wM1dAal/rqvRTJBONCHNhHrIslOfDe2Yb5OLY51acYoTDSTG44pEg7bCAzEb3q2hjtZea4QzO3ckIDTNK2cVmXNdI1DN0p1BThIUpmoAxFZPkCjspy5/rinw9CtQD8nW/lTpxchIyQDR3Hcy2PHGBjpYEIEGt61JXlVIE/8hhWmhZeZhCJN6qcJLVW6Q3QrpewOoWJvsjP1FgwC0rTe5uwz6kAqWR9TPAWJ8qRdVuGq5tUsvfm8SUZfILjR9tQTSjLLWnugPr/BE4PkCeBqdvTBpY2lbVWQn8iESRSdRIFU74pzzuKCbDE2KQMWC+RW14NppaW+0fM/bEGzGkjSiRQLOS8EVavWblcraPgGJTCZIQ9dL+TWFYX5obrBQYOFRiNgCp0TtqMlxYKT9FhvV3FhjAmj2hb0I9VHnpMZgDiPFHhZPlRdLJV7u3aIcxFa5OiIPilOqwUjvpVqqKgJzxIu7eCcRK4OEbvoK4fnjKeznPLQ7x3zBkqVIAsVAAEUcBl5cKqrhRAjGVgl4lTFN8fMTGv+jEKiQV2PNI4AKlmYzCX6Mj5TljoKyGAXmzHCziArJTGMCF8bXXGTdghWGIlF9DgJad5wDqWrxVJiD/owcwYHtOUlLIR/GDpAyFzAOZKFyC4bg2yDg1o7MFjKWSYvM5HeI0XFB9K0pKKS/W1XRdPdMF1VjznPRshU7cwIrR8NcNXqhs/JXaU7Y34a9vXfYHYlza7d+uKk1MM2nZ8fqMYL9i9+4+vtI9/4kv3Fv/gv5u8+8Ym6uqMR5gA+jms6uXevfngEIUd5hlLux8+OwOMIUI5A5fLlQk0+9zmza9cf2Iv3dvvdj5foGV/H39+543a+m129Cl7a61972v/zq4/s9//AO+xbv+vE7BEmxU9hFVDeSziSJtIRWJLNIOV20/k/9DrhCxksDDGuEVUGYwgrXZkBkp5BepFZNj6bTQEuFqA68bx1x5lromPx/6ftbWN2za7ysLXW/Z45HzNnvmyPYxuwcbBVArR1IKZpGiQCKYSUiJSgQGjV/gi0P6oqyv8mUqWq6a/2R9UoapSSpgGJNAXaIhABiuOmjaB81WDkmJJg4w/smfF4Ps7MOee996r2Xtd1rf2OZ8YzAR4Ye3zO+z7P/dz33muvda1rXReaoOBRscNqZG4D0imfBo0UukveZmz1Cnd46SUSCEZmVQp/YWBTJ3SxkujGmnTbqHsQ3ehwmNuhaTpU9bw6kBb5qnW9K7ypfhGXY2s8aKhO42cEn0EvplUKuCzGMSBGDVNM5eyZDjEOJRpYwaQQ4/sla+xtcWzJaa5gVbAIvTLq7Tgm3YW2qaulVlvSwajJQF0H8xM60zf2RU6TbQGr7OyAsX3AhhdhrHDlaGcjMgWd01UrFWrl1j5I9sl2KOSjwsV5iBenIo4kUf7B6MCWBB7UC9/Syeop0jTFOUrWmSVDNQa81UMA14dq/w5gAj0zQjLGjqeJal7/6j2/3l+P2wyfz6TPdAzmspvi7zk6CI5KnoqvgfKUsjySn1C6kltgA0WF5ygmYbcR5JIgV51dshYlklzfaUjNLqVJjP6pERYoXr2RBKFQ2MdPSaKtm3UgKKWRcM1GBogS0Y00I0LEKQ30ooHzMYS6w9wV/a/Owvi4aYCm/VEGlOR8Ym4MkSqaZO1mW3LR3IU9r+J8dxWlTl5cFGTk7Gi9LEVT6nuqcc+i38oOAms/xd0lfOANo8b2PSUR4lTEupILEmDHNOHiFAZ+tGudK/VpFRPwJNVVm6Zp1BtkFEUt1VQEpEmpSyJHBG1fCG7xneQSIQaOQ3OOFWw1y2eGMmx6hJ2ZcXz+Obe3vf3y2n/5X9y35z9tNo67X3i2b6+ysKr84YUXnraf/Il/bt/+7Z9ZciAf+Uh3cud/TwBjJSMT/Ui0LUlc7WDafzaTlSefrA949JG07/7OeyxG9HrT42Yf+rDbf/7Xrnfd9IqvsCe+8ZrdenDYS/fDKJ9UoARNKTDHsst7UoHFU43dcu+sg1JT10xxjcLpTtYfA2EdX7F8r5bPypXwikSzOFVt7bUkyhJqQdN7z0deVJoddHpR5on4qLmNAAAgAElEQVQtSoic5950LqQKeUCCSWJZQ5Aq95MdKyuFlglPdST6A98Z2nsb1pCmJ9kEc2RbYPQpI4LCwAGp27OK7hDNJp2mK0RlUKKXaf1CtDjjmQQ9uW0TDqqBwwGHZGIMxcrQTiqKXiJPQL0LgliQS+ggZeFdVckAsMOqxhVP1oUGs4igBlZZcZP9vIZ8fa2Rcqo1IegVWZa7BEfW2fhaUvuDEkWaXq7bPJTQFM6UEKNmFdOqZmC7LqxVRyoBKzEScTtCMITmtlZWiygSzID561XoHdPrABapPFcw0YC1Ro4jz6rM9tsoEsYgsb+OMkHU6IX4kvp19i6dWiCwJgN7OXTQYPRa0rgs9pXMbTyk7CV+NdkrWhmPduOEU3IlJmTzdNxodHqwNlhkhFGcq3UjG+up2+wUI/ZyGixlI35+kHW/6UIcuO5TiC2PIBa9iaq4Tjm1claqH7gX2EsjOl103rqauQcamSK2VCwgmwZ4bbEgAK1Icn8r0L0oHHQGG8ri26CGBlVRc0+K+Io1o0CVnTNBl7xQdpLkd8dV5njKexwDvKOlJcWqwr1ii8q4DXRrSPTf0DYz6oWlUzvUy86zZPCXvQ3AGVodeLqwuIJbUiqXSa4S01qKmiYLyopgZDVWU6zGHAFKZOlmLSE1V2xiVcLuTE0grkVEheAS5oVXw9aZGmUxNRznQypfz3JaZNZa7pbUpHKabWH/crgJj6XefOQ41kgNQmbajZtp914447/6m4f91ofNbty+fuXsf/lr3oFnnnL77u++Z9/wJ0/7/u//5OKHfPKTBVrcRS7DhGTmFxfHF5/UKRh89C/O11d8ebVvrhBQLsz+8LvSPvThS/vZ/+PC3vLWL0xHZjB+4fm0GzfS7t+DTCdBg6aUrymNLVnzFJObS6Mk5pCx6Bje8Kaa8/VwGaETyMd0ZZQ4KKxmUUZ487hB67D9IFxrnfdskF+Az8ZYHedTTL1o9J6wbvHWtVeDa6AIApz0B+kqRxBrVR6MuTbuwVqgJ/hxAaeGpUNWNR87Zjj7uMXhj4ufQYLtkowYZMF1gwlFjLgVhxcQWdL2UEqO6o/HINB4Jc1HnghWVY460zensoYGUouPFBhWOqSjdRP0KmeEScNGlWvDpK3PR22t02hd32ScNaFA/XTbhonKIv2qwCeTD/AnTjEAAWjx/1s+tvJkKGWPXnoVMEpmunCjMLrGqGuG1Y1ww79ZN79wND06U8XNZMDLCXmF2XW/Lxq84+0Wl8OERwqIYWUnPKcU5b14EBqS135n8sIv4MyskOCwEbaxrQ0NbueAKep8wZ4EwZfRyz4QIZIplSx5SC4tmUqv1JOqFsFKM6LIr+vbDMINjjO97ivVrxwJGQ8yA3EqabGvRiBhFhK4BX/zUq2bB0vsxtljZkNPtsskbtK00vg7EqljIoJOTwObqelBQnFtmbM1Q3BJXZLJazlC7RHFwHm7TmqQ7oimoi+4PmyBbC1M2xJ4HQr96Jl0Do4RBiGas/AT7l+iTYH8fig5qTcOTrA5ddGBaWBdJ85adH+3/a+WHvkVXYNZc502WIIDfdIMohXuhqUQYjSOSQCxYiQQw0laKpW6le4eLh3ZvgMBdE1B7LjAOtlKQokzBvsgjqBrpVJBZWV983EM4HuepQNtFxcj751hH/yg22d/x2x/fK/8cvOLtPe+51zckAceqHzhtfKN160zso/hzDX93PNmd+9dJbfOv386zb7n3720P/etl/bWtzThka/5za7fMvu5Z2N89rNpj9+c4eg8ZzNvVsAoVgagSpaiwv6Lb+qaFVzVVxCFIqWdjU4Q0O3qIeeNkLuRo54Yi0VBWoVXYWhVicJl3dlQK+uagX+ViHufgjgt2PhrWW3VFZSFrdOnLowKxoxplW8MypvzIhiZRZmLoo5LF6nQTGcGR5N03MXuerJSYc+CuduofT/AomS1HSS7kHmNhiXErkmO4b4y+udLCZNJB1RcuUNJiChqoPXJt0k9KX9A7iduJvpNIwkTkO8vXkc20VaRWwSMoUTzSp3FtdvObe78kVyZqDhNSnswK5rS9rd26twxGs6YAvjjtdT9jxYmcx7hbsrZpL+S0NmhLIK4kso8hjMLT0ahQvHXMqshidz4J3oC5GRBEVeLkfwSMXt6Cs2FAfYz7cYGtxssjQe+loRvpd7EZUNaufxAWvdUg9RkvCZSFx4ILJ61+a4mSDIvluBF7m0rauJvjZmtzVM63ez7qgbauWpq7O5oV582Rol26AABSeDW9Nb8pnBoQuoOf39s2GNX9bhRkmuEbKu44PXDcWVNM3qAPg2xJ+OhvWzLGTeAxmLyDSJ5odxoa94tTGRwpjRGy03jKpwNITReBll/qzJSRWZG1IyEl23gJlzzbE4pQO8Tl/bU+F+09Km+IGf4A5d9miiy3FvkUA/uJp7UZFbVrL8mk5ldMfWiObsqTSVpWOOZWhJYsanxGhZFbO0T2WOqS800TOYztatPGRlyn+B6KyS89Xk4qtR0gvpR3JsDtoUDYDXLazef3Y+ZjDz48Mthhn7N67jznNv3f99d+/J3mX34N2rw5Yu9fs/eNPtrftOXXjJ785vMPvJRtx/4e9fsLW8dO0ndxmVND7zlGyPf+2Vp49Kgg+GZ5xRWUcd2S7udZwM7aleGCq2BERbeYqlVxGbziQMQRf5PNXkZI8gLgQ1tLImdpH12eb3WARguDgTzjm2BZGslscLsIg+eMVRC4n6KOqFAI+tIVms3ioJDBQjq/6H0lNBDWQJDxYmQ0xL5qjuGegPHRcvDxZzqXd/vaC03k6DpVjDwwpqjDOgAHNKNMK81nqhv8LcDLHPSCgEMKD1oG5SWyTaMGVawkBea0LKSzxAs1T2JblDA6MEY2JnMYnCRNAR+i0I2xDEVy453RKUw69uB9IHDT9UqBtgqAkX2o21MGbxYHic0+gbwR8uYyhXJx8nOCKppkUPQm9EmGPcABwXuQA1igIV/GqISF3BLB6uWS71rHzrMsWn6sWcdmZxmBBF3PaORkmISApUFH4HlxS8avY1WtVMRmFLJjc/RIggUVoZdpuAO59u5XQPYav0slK0IWyVPMlx3PbnqEZ9kcQgmR5BA82qQ1QpjwY3PZnzGV3ZDYS5UYkd21pgAnd94umWTSPGYqyxKLT5m8Ww0tUkRCfr6CO4Iu5LuSzq5h1RBow5VzOuqSkUA1JFkGcBUe8idf7B7ltyj5AoRXNfyV0guFWd4KzKZTgLmL0t3ELqR0wbfAeVQYCEkEF5oMmVHK0uBwYPtIR8Y5ev8QH47zIIM9jByLGD3ZhXQrcfs0CxKZmw0SqZisAKj8Px0+kJI81uNYusRImT0yQyU+btUAVhfsRCDuVGUgAioEHj6rSrK/BWpDYuTbl5Wc8pP3hJ/FUfc+afPfd7tibelfeM3DPv07zYP9Yu9fl+TEd6M89LsLW82+8DP4O2vbZvz/vz3e/YdXznGH33Q7cVn+4EjDpcUq8J/Y39ci8OQF88AFoJUkdix0MfNChxBqSJnPoOjIxr6ygdga2ePrXUKjgM7deAHqmFLeghzXQOY6rvGWSMTOhC2IsmLrbNWcmhZrA8oXcaVhdTuF3+NQAdc4AjFN7+QpvGNi5i0KpSRCK7yPhFL6tOHeFVCWkU2zbO5/Txji6TtTZAC2TUwCbBPJTE5X5tnlCyxo9/aZNppxsvJlCG8lAdeUvVHEFJXDXgWvtWmTGiV2Yzs+M9TXuMIydjVUxfetxchyQ+JZOth7EcQTOJgjwKOWhIengoZy05WOJYDvlEsLGXMAaCamQ2eJW9ZMZtrL9imNTKc1D4044QBUQ/HqSNg9D7iQ+ThTnV7gGWEPJz1p8idA4up2wklbYRttURN1WFh9juT/GVAhD9lTlq/Ppi8bsU/jxQg4gQHXPWJmgACDHX2Osl6Bk7fJkhoIo8yQ4Lheyq93oqh3UK2Z31rScM6kyZ7iC+B0yg7Gd2gNDkwITTtrF61zjr+1fKYTgNFxO5FLZovrP/ry51stDU6jSP4WFQikYUXdh5lbyCG4x7SrevA9S7Bap7ceDZbwUWttPME7BZAVoDjtZBXquUseMnQJEsNQJQEAwXnsb+suWVCL5DyUu2FB7iwToEtY3Omme8l5mtsfDLe9k3QCqXNHD9ZT35MsRtvHEmdKBXR2DhqknB0t1d7wyV9gXv3VYYWoP4lQ4pXIcErJYkF2pXc7Uzlu7wfrD0s6fjAvloFx0q2Fh9vBcgLql5F+MkJnj3f3l/kJv3Jf+u+PfGE2Sc/9co/90qv15mzvLHXZ58y+7r3pf2H33dvnU4Pv+W0h998rv9+6C3DjgeHHce03TnQg69Z6iP8CnBVVFNWoGhnaa468gy2Jkta/GiZYdz1oG2qEf8klE2rIV9EVIdzEBxeORXG1L0YcLMTR07FCmtjIV/YBpU/BRX5RvjoZQDIYr0LVS4jrYc8CyKHNlCWmCxtGOo3Ikswc6ye/8I6loE2zF0Dau1t9V19rEEvF0SDZHfSHYk/JJOOZXe+yYetvx+KSzwdOpHHnWKGD/rPJthJOfkV646KWIf1aKJ64c5cAeqAldXMjb6+Y2pons9kmPAnUWyq979YsYVRjNT1AZGimA+O/gWGOFgAK6kiQZ4rr/7eaZTPwFGzhck/hMtdsF8/skh863xyUYfDQQIg8DAyZEw29dGPw0TTyzZ8rSVylJu+2tJSTUCcCpJl1BJa7ELDlMFRo/lJwb1UPep6WvVBUEA6mj2Y3FWkT+3hyJ0ERHfi4bVjxskkztfzr2x29WCjTj1o8SOND1TD7B1Wn9bVdgxpy5kW5XD53VQIbxLvqplz739wHHf0P0SFDE+PQdu0rwE1uiz3oIA3Q0kY/xRUFtYo6xucpQptfcE9c7+Y8wmPMpS++q445cea/coWGapfrIbb/P2KMYSYiiZAJmdyeaD4DiakHIarNku7y4XkSJeR+uCFDEHHIpLUG8LuegYmgK37FOGgnjxBveUVtbN72McABdjB7tMqbGZGJqTnQcNETTho281pmEm21UR5IaGgDGPsMEqvjDRFdOWBjAoGqtUL7jhz2xV92YOMNRREdzsgvEkvkLWshyZtmiJHTvbau6Wbxmtc1iTqe3P9SgAEnDlslQENwVqqwVRw8gVz26MI3U5FZ58xOFD8rPUXDnmTer5rnmPFajRAK/Mo3bgZxps3+Yqv+Xd3XnB76OG0b/vW+/a5z72xvOH3HRkx3PXPPWP2p/7kaT/70w/Z/ftu16/X2jvvpX3u/mmUzl49xbWjIfo+7LKOXiP1KEW19BSngcYtojabScUr1ZQZwptMJry4syybBsj+UxxkNcoydVgDvi0awjZg3u4qWyvzZMsoeZYbnEtwXgPecCL7Y1Ghh1cPeraEEoMhhjFnl9TF1pmvuoLAi4q+psLBCIVtW2XEQIdwjYFyAWrX7DdAYcOGeh2Bf9GUcbLdiFGnkZPlhpn6lh5F/j5YKFRfrHAhiFYHiK7Q1Bgi0sM8gQz7Otujaw6ChwaNa7ctDaq6h7MlXg2MkvXcsBPqt/IcgVaowe+b8/+4I82sw+8Du+XEdiN56VTXw6nRVFzmQQeCJAo3+vzoW7EOQttlI46oEK6WzLGGHVrvasfOe4loXJP1d4BRP7aKCxQO+OkQk0goblSdtGCQwk1g+iLpYCAptO0l+3BLVcsrvzapM8XHnDHFAlecHyCJZi5yxKlSTGAU8+H1WM6auTKoo0Bvdmui4d749mfeqijt2da3f2vzVssMboQIKdRF3Oeg1QxLV57IxGNoYqFG/7iyirIqTZNtOH6/miGcSp5PwjbrMgcNCKhNlzjHB74bCROqq8VjmjU+mGHMRecjrYp7kIA9SsS48EkmFAPk6npXqZSsJ1XTcqOt2eaQHuC4YaTXqdhCxUfEaawRsWX3u0ZgkKt0HkPAc5BnxntjIs4MLAK6SbVxVS/IHu7VGFHl8EM96U1nYJ+3hGjcsk43kuXSSGSsMUFmAggUgna42lzbRrwvaqks1Qmjv/oGf1grJCVcOKwhsa4UIGSt5gJa5eLQmYpM7w1Vn47RuzyMliMnZ9KG2C99zs8Blpde6hRl3A/71j9/177iD5t99DenxMcrpgiv+PoDS0buvGR284bZY7ev2yc/cWG3b5x27YHT7t4f9l1//qvsbf/K7evPPvui3fAHczUbi6VVg6TcChzvcJh0Zs3+Vrv6PKqiPop8ZaNgkClVmcogNj2H7ijLjUXA37KtDELQdMc2yv4kHTeqpVcQOaHt9QjOGp8714wJw0md/X3OatagPjJMyjrFTi+zb9EyXD4tOBsHiPPe9Tv/Cot9GQKu6NcNT0dAT3AAohrtLY1RlNFimjlTpdTZhk6LU9ZoW+VFyh7EoaqpX+USBx7di5VAuiVYn044eJ3c55p3i+QOw5k5eCeIh3AqmSVxdrBIyl2s7wd8RXEdfQScL5iDPtaCOAp1LhiEwnECycjPGcYR3YL9QcFHOlfBPYg14zTnwLNpniUxO4R2gA6o+T7nxEB5h+oWB3ghYsuTpe/b5I3UORLPT8ouxEnQKUtQCTZaA0l3g9rUp5Pzh9VxaMDH2gzQu7XiMhDtDr+z77VxA3AFdThsUwDkR1VCsfmk1K8OfpvqTJx5xe/JFGwBh2P2KNAvVPzFiBIB/ODzqZRpUL3FOBRhMD8hshnFYadsixcXhyamAw5JMYpFYO1xVLHLBka8wxQ/ZvET9eMjyVMn57EcPynhPIwMthJbKzQYOkoZfmb7jhiQMNjIQG+IjKtBiFH1DbuV5cVR24HCa4FgM2p8yEm1U9vGR4mwcoWSggBKwsFcMDkgXSMiwq8zOyE80d8tAHmQKuNojY1xFmEYiw5zTjxai3wr9X1P9rVB5VvHxwLgyYyWtBAODxMo6aDtSFVCrSWq3ERRoaLTUYmOoGFXCPYa1wFvpbbcKQidsvY1qQ9C8PBWMyyvOqr2VZ030nkTVJYDXK7CYlC4PrZuGKlfsJBFTnmSXcVO0qYDhIx1PbnjWAFjLYHgbI3ZieR1JiK3b2dpkr1g9vgTp/2Zb71vTz61981f3+tfOhkhirZ/4P5n06jv4UfS3vPeS/v8s9fNL9xeeCHsgTjta9/31fbSm5+N5168b7duAoaoLHWumYNmVBDTdbosDSQK9O8MKk/WZ55gV69jDQrvYMahxkHoA9dxTh6tIFxndQ2oepAqAGV2KvoSwssialH3MSucYMCvhkFriseQXbjREQylNvqdM7qVCgPM9+FghtWq8XfNpwwRtgunJVXcIfi3OlhQxigNgcVBQ383avjcKmgis4oBnjbtUp3DShX9YgDxQE3HHL3L2zXls7pKY5uL96kwn1JHSqMTnjxfqr4u0h3F0AEkVOE0UIPUTIgjpeIEbI3iEiZIzAWhym7UiH72g2NyzUsvsGgtprMg/AHN171FPlqMPTlMCNTUWOxwyukcvnhiPIPn9zuTbvBAGxakhxUQaP8nUYjaQzL3dunMtgVuq6Cs6x+1CUaJkUcQgK/TCTe2pq0wpQqZnNlE8KI1O3zWqFke7ITBMqVSUpcDIG9qme5KJ7JEYTiMoZleEfb2o6IOrwOM8DNHq6VhbArw9tD6rwo5OI5k1cTA+nB2JVc+Po4aWwoAkSdYLGxRDGdjfR07MYrwPeB0U/VoecPW/RmUxSEAppkQboOQ33dS8b6I4DMUnYUwFZkyGFuCuIBytprhQ9+hxIuy59Ny4PQ+BoC6SJhh6FCpZUPXANj/0zZtG+4EbWZEgc7lpjYgP1kLfyye40Dq7bT2iVX9JbXBBlIbV2UAx1AuPNg7zJNzSiyhVccRufpb3NEB8CL4fNacSyDJgwDDwjPE9WXasE7mc6DRahK8dKHIRWBPRKjgME3lfRBU0vPlMI3kWMMpmgKJK2S/0lTqoaQAnjQC+TDFWUvgyWnU0zz27pNyZg5QaCH6iO7ohBM4B7GlYmb9TE2UJfjz2fGTArqs50h+Dv79gMwxeg/UXY5p+TF/FRd0eOt4vPhcncF/4hvu23/0l++t8d0pmvroY2kPPVidkVfhuL7q61WTERGe8pX/fsIzM5JOVVYRAyFHPf97Xthzz5l913c9ZX/hLzxjn/502H/937zZnn72sOfuX4Rd2hkXbPb5ZeUGdoSejlptRlrOsfL2trYO6BQMBNGeDuy7AHBOaSib/sh9PSmZCp5fyw6z9C+pHC/NHqKm9dyHsS20upq11NBOOphzAIEc9UdGJV9ojaFnAqibQ6S11gCnL6KSY5IC2wmaZcwAizO9TpQemUXKJQEP9szRjeDgpUDtiBY6tvbr36j7KKm5T419adBlgwKbU2ljzi8MA9haJSlDYT0ljEyQ5LJKDQ0tADAXgTCdIomxLUjiNEgUwzYTvo2dgbR2k2YVr4IWfVB/c3agNpF/dPzAQ0QoYocPjeCk2EMTIgmTaAuhqG+0hqscWjILE9m4bEl4Him0bq6+POo4jk1o+Fxfr85kPLJR7rkbd1IXyI6QkfjJQxOcw0PNdNVpbLUYPxHPz8CcRr8th+nKjfuTE4mpr4e7d1iSAuJDXxzthtbQQSbUyD7EycAL6Afs4uBmMoud9UY077xxwLaUAJBirEKwzPzAQmcLpQmmntaTQL14tRbqe+GZ6BQK+VCB9e7EN7VKaxGgSxNKlFMWV/solPOwoj50kuIJyD16C2pbpXGuPnyb9AixY7X/69cbJKlNTV41Oqv1vGkkiTVeImpaH9y60ckdDPYrqIbLlivY1u5BIKFv+CqcW0lqxHJNGpvi1IAt7URmus1J4dlQ7TsJzdDa2kSVW6gin1g7S6oPGZWhXzmD0gVjwb7askNW8vkNzLy7zjtudBGvpDOiYT4dZ5i6KInPSnvwhAmfI9z56BOEhZWL7q9RpuRU00VaXhYlMvK8fxHPPev2bd9q9i3fdtc+97TZe95zLnX2xx+rS533YKm2x9XcIeJqTvFKeUXsaAYTiWmON/+Z0MuUat1f/LkpIz/HeOebzoSEDnxTWW3++/zzmZDMC3300dP+2Nfet2/4xmfs6RfcPnNcxj3POOQzd67y5iBLep3s3SDj4RXedWttySSSrW56AHUwzcGHximkBJmOhYlwsXy+h3fxqb6g66kbTxQwxTDSt5EkgbAn5Z9nTRJkHXAtp3PEHjkSuFhYVxSWRE4OmFb9DIMuLGDOGBrUQwexezjV6JAHV8m/qV3LUj0EKKN5TnpEHUIj2FcEqSdeRgVwrfW5F9YVnNyvphoCuPYkUBXp7yBh3NmfbUrrYIRaoP0ADpNqFGFeVQO6bJYSI5Kl1WqdyDuq1m2QXghMY9EpAUOtDlKpXmGqas11UwSVYhAavcTBKRHsCP099aoxFpagtB0tqg9OSE3NFNUyiPKwfzglubI+oMxW0SNIpUc1ggUUMKqGbbx4CdSsej2xcwD2gbaaEiI/eUA5G0xgbTq5Qz0zgvtfo8QxuF4NYKUyWsdkxYAADtY3Qjd6lJFa+IypY/UjqwmnGcilflDlycBmW5J5CzxQUcv9g+7nCKIMoLMvkjuoletJnfgQytNU0yCQv5cy8+DiKrtFNEjBQoOyMMa8gFFQNDPljA9qL0/RMhoSFxzipsFtcTDFUiMIie0xH8tJlkKC3Zo1Vavc0ouLCqF50SqZR9A9WII5+AqGvYdwU92VytOH6FFRhAjc6hq9xvw61EHmv580oC6ia9IP7KjmCoCLRTbjBFJh1MM7XBcGwn51WW241jdbbQmqPZL9utOhFLC4zaOo3JjzIVRZAk4LMKkbvMwolV9CGW6tXZS7NRdE4NMW5lX9/Rq5P9D9H0qgOlYOpEfgqazWSrLDh6Xk1MMWESbYnM3u7+v4S5RmnjDEduaFaLYvzF/XECWLW6lu8dPPGlpqhGZFyKNGASamE2wsTUjyhbtht2+b/cffZ/Yf/Hunfcd3nEvI7BOfMHvhTnnZvfjiF7Zn5jOYCqszF5jiZzO3YF5xJWF5eTIyGf0zmTAoqr5S34fl3syAVmvsuNqy4X/PhGImLE8/vSxp7Ou/9kW7fWPYQ/f8fAClQcxHGPEADrkT0ICLIwKGaSklDfX9K6YW2/3wHmV2nIJyt0w2IgHlop0MJqVpPDDxmRxJdNYhxTsuYflM6TNA5Xqp6C/BNjBURqEpxY2H3a/nMbfRmQA7G4Z2uvJtLlq1jTBgXo3vAjXIQAelk2tzBskZv2Yfj3UOKG7BAmWaLtbG23g0OP2COhs4dsVvC8j/zTTDMb+CvlJKJT9RtLqSkpU3UaAKPWKECTAB8B8I+msORTVDNhQB/sM6BGITkCz2pyjEUVJs4EBiMh4TlvPGeEu5EeoMNKSdgkgRrEQxCqJxpiWLk9ENITRphsZr538fQfgbp/cg2aXub1SOwsnJ4gG7btGIUA+OLET2AtaXOzjNOzhBk0j66uClL1OvH27yOtICRWyzLYRJVOwOPiaWvoNDBSsviXIkT/CEC5tch94gmoLplMHstJW4AqoEUDojHwVAUq2fGijhiNemVQb6aHMQK80ccHpA3nSsqf4RItkQqYN/ZDiFUmvMiPIlwPWIjfOhBbuNDDar/YbWGvLBFH/JUJXup37RtFfIieotcT1I1nx7/pNdAC85jfkWf5/f/1jxqSRnWUOhepmffRCQAR+ccQHxuCEVAo4avdYgX7WZNJ8K2K/YEVKuTQjVEksA3uIBqfNCcKmbxn76ykO6sBPSgl21NrBMWGoCMPkJ1e+p+zdSvaDkt68WEzCLAdfVYMIr6Li7YfV8Z05XxGIOSRrH8AygSq5WS1mSllQ4A+iGWmCO71jtYd78jXkBMOxwShZydNtJh/QaJgXwCoxT2T9kDELKUiDJC0mu+DbnIEPNGWI1UhpH6Ta5M5ruSIw4RlQaBSSN/KD5pGMJLR2+/B7Mb94887NPuf34T5j95sHpG5QAACAASURBVG+Z/fqvm33+8+32T0CCb89/5kU880x1SmZOMROTmTPM3IDGvPZqbZr5TNiGoQz8rrTKRGP+2URIpvPeLvPKi5sfPv99oiVvf5vZb3/ipr10/8LsVto4NE0YddxMV5QKrVL+TMp3QyeM44VBsSUnBGgSUt2vER3IMVPeARMNYBBDEkgFwC6X/QJJjfJ7TiS4Ns1Qz6hkuslkRQILnjhR5y2HXe+PCo5pKRINdPAguFBNfoPUg1F5b1RjNyWPTU4KEO3Sh10rFkOWo4fN2TjkQYvGc9ZV6bwyOXvAYTfB6UOrrM5A6JkHywN+gZpohYYbiTqlFJfdShWdfDb7x06m4NzUIP9n09ye/3WxBHgwvwP+SRbBk36KGsVktScqYjdMlC4RQHcE2ZV8DJ7+pMaSyjn8MHYL2kCOPhWuVkKlkC4bMolceujUJRl1mwNYzzc2ZgWzCR1gyMbV9V8KXkhWo2qzAHAOjAYMTED/sJCOxGhX0JTOmdd7NHrHbFSCV4icQx4inBMBdRQdnmzz1HR59KxvfBiZR4zig8l0CMPd+lqVTNLrBf4LSZXMRJ8/kMaAqDK2FuymQ2xUPx6YX1qXY2To4L/KyYDoYId1Hdfsf623i007p57fkbK41eAHj0JinXXbxmx7JVVTQHk05aABgvGJkyeWBtJkxI1qtYaAxKigRbc/gsqtmIvKa9ST6Zmw0CbB/lsNKPKTaLmjnuA8leaWXQhQgKk2SHGo77/LsJltud260PDkzBF9KnSYo5NEaoKtB18C1wMlfOn+JhG0tTxOyNpjmnk45UXS26kLj5/OTvyEA6rZyXoxYEpcjtDWtwbRI3DsVHabiwBDczD14LJVcgmHdV6N5y+lnjLs4v5bD7Ebk9EJYz3KkkrWotJQYehYHFese5T14/2P6as+5K4SaefA+lvL9jD6UNludD8vdC7s5T52nBcXYQ8/nPa3/rbZnctr9r1/8b499XQlGAQw5vLYUY/r10twbf79U09V8jJ/fv75rVuWc9pmdlAyXyUZWX8BVGQmJbduLQ2EnBDM/MUJtewJyURI9oRkfvB055v/sO3zqU+b/diPPGoPXj/t4bg2fzhfWEmOY6AIjbElZDZv60GKPM/4cBae6GDW7R7wPzB2YDWDInSkpvBJAwIliA78jKBJbvxGMufMCHrNoF1zqJcy31mKwuIMlGgMRT965M2RYtTH0h/tpOgzvGO8Zi4O9MeTsCpb1+pfkrmgpifNdsCTBgcL47XkWrB7eXAqYTNSKJVLcAoOp+dMLXrkeoMUrk2RBIn8KksGZoOnNfLI3tUoyuA1COOcLqW9DdwxFixmJLucIgxQ2Ek4BaSSA+yXE/wMJg5oqgPToNC1LzoW9Y5G4PCrIwuiHFt2gJR0AFz3JZIHFX9NhsjfMVuiUBVoHVUlGgMPKobixLlenzV0/rnOV+MBT2RzbkhWCGjqEusb6BmylBKRzBGJbVNI04EDZYThLLzsyHpIOMkCHFFos4HrbIhxHBIw6kjqkS9KHI9+yFDmWn80TuL6TcoAbdyWPvRdxgNrcTgRJATmVBoyKLo1FipebA1pGi6jg0UgmEUKKSaOFdbcRfwkkrkRCN4T2T5sk6CsGmRwOmS41N0HtomGORmfgIcPyrczAhWNregDkZ1ZVwLlHKZP1BWDigNwzPCirA1wc12iMrjU1VGZgeCAj93o+MGS2kffv4DGh5ENA/O/c9FowVPt+MjMGX242nPOkTjXQksdkozU+PXDxBKNZb9JF2ff9kmuMWH2i/v+OHWZObIf4BoNfgb1a2t3SBaSwgOILIMIdLjWH+K6cQTBIDVLgoamk5LxmfufCBbaxOi50iR1kINWKQgyAYyOAu9RclnPF4dHEW9Zhzm4iYmhSxfQ1M5EB9hvw1uqAC6F1bUk5IxidF7N5exkov80L/E8xq0b9Rg/8IHDvuPb76/Wyzz3BwjvMz/YWzX37llO9IMoyYaK5Mwj5j8T0Jg//4rJCJMQckgG2hrz32fSQU7InpDMC5jJx/zjRx+dNsHX7Rd+4Zbdvn3a7WUb/IA989SFPfrgPYvnJ/N1eNSnE/xaix3wK6QATpcvm1PJOkl3W2ERTHH0GRh1SUmDNWmoXnYSp7e5WrQ8aRdi0ntf7zQCfwY5psIQK+9YXWcDea1GvbAsq6tUs1ryzcBJAZmdWD29YNtTuHTZo/OLDgiQemzHGgq4NY4i/h1hOZYosea3Bnx9Wn6oekUxDpiD5ebfD1rsmoNbzV7n0F6Aoz+oMuHlhoepDlNQsh6dLK4H1L25L00q7hThSLWIYhlWO00v6YzTAYFGClTprYFAWu3z7TE+hcYaA6aowf2TRrnsymvZARRMHcUqcJ21Gz8SLL5BQh1uAQ8HrsTBhMlMP9b2PaeQEhCa9uMquSadMRC5cbm+FUOUhKJuJQtay8rxl4Qe2zC4nZX0itcPZTfyeET25mruP7S0jbmba1xMhELwoYDYFJ0Z+aajbsCeYhaNcnf0bS8i0zwlj+aSz7SRkwYJWCUOqEsOqrhHVfzhMfuVcJUY6NvUGkQzrmZg1o9oBarwlloENdJtLE4NEDSg4JSiqRGdAR14HMCcWPWBmWGSt2uOc/WsIyiihB0wKuQxv4wqmzh64lSJ0AxK7Q/INF/p0bVULSVPcGQBeqvxouLosiApmQsczkOn2CYhinxSmgCVTtVDRJ7CdOuEnFqgdzp68UvsvRKFpQy3utgS0IBzJcBWwEVKOMtkO1exVooMPDpGGaukuqnbUdwUdxwCzlpTCZURDMf4ZBqJLwT0uHnK6NsRX8SN5lNQ+zzx+4OcxqEpRN7JQWMshgv2kY2N+cRoHII31j/JkQPYU66RXhQ00aK2o8myMqYhRjWb+4xfUDVB+Fin3KiNOs4YeZ6xqAZzYumsn/rYPz/sp3/msH//e0/72MdRD0XlDcwd9lyCXZaZP0ygY+YLK7ffjXZfKRlhPGSLhhDM/PeZyfB/78kLWzvz9cjDZj/7szftJ37iYXvo9v315zeupz32+Et2+WLa3/offiq//oE3+/v/1PvsfGmmH2dgBr36m2e0VWHQvsU6CwWOH5Lex3AsUVfbphbAf1KV7JQfF1m8RzrGxi9mcnCAyiVdDXJmwOrihAs+LNTuH3MIrzaWpnIZGOb+upTxHqZGdegeacR7xEJu4tSCMae+pdjiTQCo73fQKZNM2C2YFgmgwkAgZQPebuTFO08MDH3uZ9MSI1r/d6kESv+lIh5j7TjlWlPE1RTizAA0BXH7sHmiXFKpe763FKAEYyQydmLBPtoq2mwwwVoXcPJ0kHpSbrkL6kpWP8CBSVpjIsV2BcUpTh4apWIpIS2+82DysH8YgdhyB1PSgjME0axme1nRIR1KtUBoINBZDG3B8P3DyMDmOTtw8hgNzS3ykmmzfN1YcVdacuIuXRVpxlgTEAF0HrmoSXBY/3ZW4KTrrSEr0aEMwUh+fBBDBKg+NRmIcPLqoiXqJ/kuaHmC7uH6jCASdBLJJtearB4iUMqqu73HbVpkF4Z6zqZXZ5RrfHRyuXZr8LRg68fp4ritnnUPj0Ar1cnnHfpcp4nwPlUDHnsqnzxqLmL+7uE6fJOkp2AhXtdbJ0tYUKSsM2c1lFVBQw06mAhFsl4w5hEgcIhsmYyfBA1Wa+WMvp8FRjVU24u+5A8v0X4m0sjUCvdlDMx2YxtdMEHFz+YpW1rur6L3Am+FaK52G4VNEf4hx62To3KWE9/RO/7qQOH6Sspu0vCFWY9TKdx1EvU6DrbyNWnQ55ea6mixtX5wh5E6KE8JMlTPDkE4lpIq2jQVZXp/gyALInhyNqMJ4FVjLjrfWOyGxWA4bI3fnyEFwrUufviHH7Bv/qYX7R3vqPbLRDxmkrEjI3wm/IdckYmgvFwQ7TXl4F/+hmZXM5mX/+z854k3m33y02Y//2t37Lj9KYuHnrRrjzxp542n7Kk7n7fPXT5rH/mN37XPfOa5cePWNYCyJaIpgphTEvxgOl6PJgkFjkZvNyibdUwNy46uYrEOCevTDoRkdUdrp4NSSk+rKOKQHTWwOyKh0swWrJO3jV8ajGi1cELbHe0/riDsnG1c1dmT5wBHje+AeKpMATUJNhdtoomTrsP/FITtgMoHOPNM4a9WEbhNTmFjnsQctw2Znkw65dDkXdD9EiXv0H3TnBuxIzyX5hw4bPfr4D65Jw6+3wHb8FZScqg+GXoDpcODxARSNXAaxufh1hjpPwP1bKtMuVT27MpzKLFr0pybJpPGhEJER/R6+Mvi+dc6c/4Z5mei4K41PwY+R829sAoDMxapxZa1YMqMz0sCbYo1lWzWcwgw7wDw2yAp2ZjUmSar1swLeAiwRjBCjkmBbxxEflDal743kAYVAbrhmjoQh2RSWEHFkfA7csqXaD83BMYjAi4GK06cWm/sDixcDXNPh+08Ivy+s8E/1DasEz+4zHcddmwMqG4BV2TokRJDsG7pew9AEjyEhPa+Qeo9YYoy+tkNUmYaScPkhIlOZy3PrZojTrSfCZdy5XjHbLYTE/CR7cYa/XydDFMvsRUyIpPdRkeXlpuDsZnrY/UXTiam8sNSOC0xdut8GjGUXCoD9ds3Dw6nes+xMI/Y6f2QNeCoL3HfuaiGMQSTho0BHdZ6oFAPtmzxzFZa50l6v75fwj8Bo+idUEKekTUnQrMI8oYUlEgx5uEXUhJghIuQCt44Vf+Z3DoXE0jJYytGVZyPzW8Lcd8p3Qk4UhK4IUTUdC84IU8vDsa3clJZTJo5mDHZtbP4ojv9fE3X3qeeDPv7P3htaYpNgupTT1YbZk7YvJxjyter/fl8XYhD9Xt4LeTjhtnb3mZ2/57ZD/3QQ3bnmev2zredV0Z31k27n3brHYfdvn1j3L1739Kur5nHA0u1dIFC8lTqC1f5yQ62Yj8zXiWZdMmHR4h85yuN5ZMoYoOLMkEfJ5SP9O9QcQnz0SZu9MDAPk3rBPNAPiKtA4E6inC29t5JlEVj4zU351iWQyvWr8AiQsyjKY5UHsJ3XMkc+nji1EkMvZc8L5kVMBEf5uWpM5+GJpLilKk3Jl8qaFNQorJthatmnmE2SP1VLI7U5SAban2pdY6EUWap8zF991QNcji4xMNILoXsGgjCoNMxZhWxf4haygDHw4ztCUd7j66ZiSBrSgLQ0zsSqsvEgTmCyEBajCD6/m52roTQk37gmsa9ck76xoPaVgD1zYgEMIJxSY4ixWDEAKoiJfBIwW5thYDo5t5X3CMVT+YhGBn8kdEJEXMEEqzhTBh7k5svzffA78RLI3tINnsjUwI6KuAv3DiS2eo0DAZ8WsZvd9BWuTIqiNZrsZbRsKA9LlqeIvV8A3oOnIjaFu66KQeGc4i0Ml/baGOsQDnqif3PtTSS+qg5tGhwrBbjsEsTt9wDj1OzyqlhX3+Bkkhf03y759qq1r4+KaNgw/oNNCSMWBBkPbz6Axs4m70vx0Zyq2+aIjX15upQwS4hiaMg8LQ5ZnlHkVedPY+6BnrOxNS7t9uURoJLCftq5c2MiwRC5sNboqBEAn9Kf5/8glhHxps2YFe+CqZicQkp4/s76lMXsiqHAcmKuPdyMIPEJI86EpLFEyH+XJtP01u+QdlaQpUODd34mqSBIvOyW7BxUQnlackpLF8JybD/7cev2f/1T5d2vL3wnNs73zXsr/9nd9d7zcGVN/K6cDf7vSYkkyMymbJ/42/ctqeecvvoR2/Yl3/JwmF71YNAdffuaf/2N77b3vHuh/z5Z+/bA3G9q8jFuygGUfBAoI/iNoBANIS/ZYpEQMnIYhbRQhexAkvg6Zx0N0AhWv7YWEMHDuYB2X9KrgrORXyyRm3KYRcZlWZ/uPiHIhfpqH1VWDboagads9kI3EhM+nloTiw0m7mW9j/yF1boKajPiecH5W3ICQCUb1oPeKsB60ff3LZ0UhDedaPTUGOptA6Wm12m/hPVeLRkep4EYiBPwKkgtPilgwJdDS7Ycrsb1ZrCeJ/rBGcLjUxl6OSySlN72KGa5bKVIaMdLqB4hoUhxMA315CXAZIwuJ9hceBhcb1oqLXlbFARDrKFNuJIwc+23WmVJSyUca+0HtFbHRTxTUL7++Ymoy7Q4kieAHkoL3IkDr5lC4V3MydhPos719A/EyWMhWaj0buJIpA5BnAHO8+KhUWCKg4LQ4IY2jGDUzea1mfuBE5YUf9CNl+Eo72tUJACSdqotAUbeJIzEVIAR1M41Y9MzJsz3AyCRCMbIemkLSm6qoxAqjd7Kk5iwOY4iVx5JPG4JvAyjV6Xhfpqo78wDm1Q2tj+nioqg0CBAhYqLdXQ6+ZQhyMxC5t05GYGx/VZA5JVDAqw61RlQxeVMnOWHyRvoiOjlahNpKF9bAQjA4Y2eui+ce6LEjuphGmVC4MUpr7X+/3knwx2wZKfteWIVzLgBOYzxJzPHN0CBMqklh0lOjHEIRg29/M4OxQ0pwuXzOpufyUHPA2NGAO5hXWt4qsiCPV8KAsJOmtJtZ2FoQ1VVdf2kna2446LtE9/Cr3L0+zXP3RhH/wnl/ad33Ha//db9oZewYmXlyMYr/c1f+/hh81++Zdv2Y/+6KP24Q8/aI88Uho29+673bvsfy7HGhGyD33oSXvyyTvj+s21uo/a1gMDXz5qqnOoURGAEJKwM2YvpTnCtm90+kchiLCtlBaKWdshiKoux1dmtC6SP3oIJS3Iv+Yc9tj2Hg1ckZQMJsjeIx1r0jxoDgyJpVAiZBtTUQiLAWak65IuuChG9UcUN+/wiiAu7XZ60BPI5UZVECEbXkF4b3CFCRZX3NKO4O8sDeQrrHrOl4Qq7O6orbs/+GmGYtXRS/XNCZCRyFRFBbe+oGYrEZc9gtYfr4IzDoPHnvfzpFbH1hRoz5gtAdsqDAa49f+XhTeG08eiIKjVQWC3TpRSBLYtomn8D8+6yO9XJJLSOt/Cz0nR1+AY1IzAZKrui0nV+cKmLW/kcXft5boinC8BVzQlKN0WbCMufNbLiLqURvIUdI0xyVG6Ex5bxTP4K9y+CPQU/d4ydaFTshFodIg8p+iF5XT1onheccVF5XOdKKb1FNtx13upvNaMU5Voh+k70xcQ99S3jC+pGHc6gLN1DzyI/ooyGaDekO/g2wVUAoQuLxZENJNdU16NWDG0IYxqjzImrGIpTH7aiptsCzOF5hphu5Zdk2RimASXe2v4tv+2NRzs9BGM0P1NI9t5rn+pQys6V9tScXK7t8JUGw7G8cnDvhm3IY4P/juUXlPVui8/dTerMak2YH3rIRq+EmDTszOZGmt9X1lrBPZ4naO/hfFC+OFAygL+arQ4ciU9qZa8oijPJ7Zs8sRz3758F1VbIZTs5dXjSZCsSzM3l4aWgivBxX5Ok4w6XXofup12+7G6ph/9sWv29OfemEneejSTUHJx0W/+Rl+T0DpFzX7+5x+1t7/9sLe+9cKOuG7h1+3iuPpP+DWzvGbve99X2RNvfjzuvnSvNFS93bsJR42tHx4QWlKCL4cyzVuoF8Z7JVREvoiBaaZBNS8uH8HiaxPS1EaiWOjcegdgI/1SpCiId3JUI7paqc2ODZ44LCTwNZSPMzA2HwXvL2c4651MwFRQPFd6WC9Zpz14ubdvUAwdCV0bFLTHTYqPQxFGbo2ggl7MnsxUeGAwp96DChWDTJwCoYQkpprAaV3AcAb7pqQY7iVhHn0iFw3d27x0gogqcbyS77F1MPDfE8ZHQsNKHP8+v/UEKQ/9vJcBFt2M1ynTwtb1R8FQ2X1yqIAar68no/Oq4FY9Wh4MLud23nu8N5uLKjsZ2HMn9+qLEj3jM+F1gQSiJA5G9A0oji1dMwqeOd3TW/wv+UxCnIccnWzSOoYnCckFscMCinJMAjcdmCvJtggySGE2DoEU9UP9QQHkBjTGKQdw6P2skxKGelXyvksq0jlQ+0LMDqN1rm/3uX7nUCuWP7efERCbxsEKiTTYfTczTWdGDVRte4ANlmDbx/uZrZ86Oykt3m3oe9ZPHZj9DN1TfV55VNU63xLbLQ1QO4FoS/Jx9hLkHEsnOsC6yZ5j62Zdz8Hiw/u7OxBnq4lyWCIitkRzp3hSqP0FK4fBECFP5R1rVgwz29d/q5fxfFE/x7m54YQuey+sF2ccyU2xdk8ftzNJRWn0d9X6ZYHoun8iPRrFGzsJNJPpTnGSaI5FyS4lTIw1nBzbvgqGL6E8A5re6sSee5Hw8n/meXPr4bSP/4vDfuqnD3vrE28sp7jgfDCV0d5Iy+byNPvSLzX7lV857KMfTXvkkTuLKftqrzXKM8x+6Zf/mX3d+x6zt33ll9h51zl5EU5GOoMnGMIZnQSwoheRTzGdG+1Kb1PHpCkb7xXIraRyFFWDL+rsoTuZ+6/JjiU6XG3TUuZdVdfv8JoF5zKVVzvA92+BRd6/T05GHygeG/TNpUquKPoexUuoEEBjKfJTBiZSFBHJJsf34+H1Mhr4aoUM3WxXSLqyKtHiYfV8JSMnpH3I/FFg6t7f50YmjAljiboXrIhHqPJJtrG294x9Ssq2axid1LB8Ew4bLf+yhXMfW2XBinEG+IXISnpavZOrq8ylxqV7ufPrnQzY7VBOI7FF7Xj0H/Hf7DPlfl1YB6pdvNNc37J8QeOhddn3FZcV4JzmRsbc+6Bbiugkt+4Aksi3hJWb+8VDpn+2P9vBYQGhg7maULF6qy3hSNSBGUAwuv7o5Dn7mSkZx+HChE5PSxNUW2rk7fGn5yf0vfeBcQieCbyRxEBOBts+RbxWydDtUtuelTqW1Pkm6RxTNSoCgmqqTNUYg0Lvbw7SZrKQSHERbD/bUFfvHEO2q9jq6OI65TW0FykpVC3wGXuMS+0JLmzuZ2dyu0iYcx0fWku6Eu/7r0ye7bj9yzNGKbAyfoztBjkvWf/TvV1JiWYqLuI4ks6UPio2OWymptnrxKz0/fn9r9ZzXNT6rnqK4Izp/vBHXVtUz4y8Sd4G0EnwQ9zfppvCCZo6T44rZyPyIKgujDJywkUfaXHv2SKC3Hvu7pV6R+ulKmr78f952J/9puKSTpn41/O64L2Y1z5RDiYkr+f18G2zJ580+9t/95Y9++Jdu7h1Wt577UxmQtyf+OiT9u5nrtsD1y5W8oK5acSjRV5gMIKEBSFlF2RaMb07dr0QezzTWVkgoVGv1zqpEM1SUG8t2qW9XANkGqfb5ggVDBnuxO9TnzvV01/Xc/Dv8dAYtZzWw9ZjZEm4n4qspsOSkYLNS72NDlVssEEeCDcyd2jxBJwZk2NK7mAAybL/Hf0cE8IDtXhlPIP7x4AcoBKOLeHKxkWxyoPqDKmelCqlwGFD0y8tBw54+HYAcxNuLaEaCR7i+1KI8+XruQMoRt5UXQd6o0OEz9UhE2kLIkQYteyLzysHQJ1KYQnrAN8/nyTgMhZxQfp2NUmhYB7sAQENMwlhTZz692TrkvfQMPVlUBrz7ATYSqqkWTYz6TgWYDhGT26IFAsCUysRUAFZ/4OjmSqHHe2VHH249hghF2lqAqIm5xp9FM/WrNfP/gQHWuFGXdyAhDnH9A1D2wOj4Zj6sjJgNvXwu8itlmjt1eAyJy+I2Fo50OKg7VgAu3adg8M7UQtRjXu/1zDR3qxoXy1XpX9u6BdPTfw0k3LvA7sTxlGrwcudRO1Tnc495k6EVm/PhGVsiYqe0cZ52M91Fki8Gzz5RC3ZigIztZrUHoIoo3ujbUEDJizGnpg2tejTU5OIib1b8UvLfSuYGgdvLR8uJ6hNH5y27i+npmZu3oy7dp1vSTzea6B1E0wyU7eTobNNzLMTD8W2tHZ2ZCzjvWViIrGg3JKjjntc2MmCAcleccRYI3chtA9nTP9jEcrGUptdVzsJprffcdtu26P26JsebEuBl70mSPHZ567ZB/7fp+zP/vHn7dlnX/HHvuAlnREmJFPK9fUgJPPvp1PfD/z9B+3XfuURe+d771nmxStmS3xdXg67/9Kw/+Sv/Tl//OteiqeffMFuPfAwa5QrjcwSP0NvNUleFfmKLKDyy8AAqKMScQZmlD7yBGFE5F9y4xlNuajXe1ALC8XISntCULCF/L4b22VUcfUUOdEBjuLC9c8y/NO2dnq97KVKq93zvbW/gkba6KmWZMi6eWFB3kX2ssbCRkRc738sIXUMB9ekwhJzy+BNKto6d3SWFTq8r6JP+S42cL4W9J3b3U9OBJmpepijdoOQKVntclitCEKdFNHf9omlJtfU92Rf4CBV1pdcNCs+UJDU2ghKTXAeEalQDiavW5mfZHmV2bx3SrL/hCFzglTpUC5hgyI3XU7VON1AnA5W5C7ikVHxViur1yqlIuVdRJuggXZVUMeFBvCdLydZgnpbG34kR0tYYDs5eH1O5dZBv3Io1NseDQmhkEj9JM4S5K9OTsIYmzqpazuBXL3EM9eCCnBGlY6QmULxtaOqksGcC20wIjElLpZi7GIPYGMwma6cjV5s7TvHSr8oFwuOPRIJe6fExRQMFkp91OgsGVlKsA4rKtyQoaJKqM44sAbQpmkWaVk00Ke5UTCtv0G9cbbyaq1AGw5M3fWBwRMwrQvyqKShGOc+usIhDQpOzNWWGmgxH0VhX04bMSBNj7JoMKOZqiVwjc6SyHAhB7DEHGx9BYqek9kmbkU69daDNuUIKSPxbthWTrvlinscKPAhVI7VTuL8wOmitvEVEqlUrUFezmaopUA/VMoaruOCzwr69VeHqXVUOsayNpYlt4YFjDQpephm6aYMHETyaYur+wOSrvQPLQnJdcbosgXAUKyWd1eDBw3ZjXMu3bB7z13a9XffPL75b36H/fh/+3OWn79r126+skzZ3CbX71yzH/ylN9tXvP1X7EseO+3TryMhufJue0KSkG59tdckp3z2s2a/+ou37Eu/bNjtBzbS2au8Li/c7qfbo5fP23HOjsIZUAAAIABJREFU20W0YT2ZGNnndHSIN0oV9v5pkLbT12F0gyQ3TIE7WL72b0MTBzF15X4hUTOkRRwHqwrrbJ4AnD2L64ItvzxwOhmocw+m4MGTSlZrmQLvy8gllohRCH2v8ibQXu6ZiHzZVzUoV5PNf8K4xmHaje63cyhJxVdZYirIFDq+lYqY49HHsKFrEo0nBjFqpl0qgLjtrnwmOeo6f5JMuEE2DucTqB6Hqm8U7cOpDVg8grqXAywrCniI908SI2d0iGsya9JBXA9slkJxMspjlWDNtInNCtNYZPWMDeKJIdF9VVBcazhOcTbVWAnzy2TfB6dSQsFPO4GwoDXiyxJVEoDE7w36ujXGTgMU6GiF3GFpnj707x2SnB6vZjzIOQYh+AvvsyaXaC0CNV7vCxUKVUK+gxo02YV/PbKxIMezkCHvFkrSF3dJ35JeSGdeWCAgU0JZ4h6jE/DsMQ/MnSKtCFJaxUZjyk4ozXlHaSjYVkDBwxXVBQECMqQSUt8EnsZwDb4EW7jb/q9FDqVpo0PB8uTkX8KJRoVVDpFNOg/COPh8+0OaeSDTlSvDnhHqPxu6FSZnGOI2whmcogdMQU5I3d+RFDcCV7uy7qEDWnAKGFBGTBVVAWsLLomlds982wf2yEamQWZBD4+BfRpEbpyqKODtcGx7SrKAC7imVB3aVRAKLNucJI4kHk2KUQKdfYDS2hEEPYQ34y6PKuXg6YrMM7qZ56yKR8EVGWKHa9Q8DVZ5pZojR869l10LBj1iZaU6MZMQrKuEGfB77lfx65IAt4Icr2GQlTMr3nt5XrsZ4z1f/YjdvDHshd+9a/HAqxz0p9nj1+/bp166af/w199r3/m+37EH/Lkvlh58oQIrE5KpOT9frzQrPGP9m99k9o9+5sJ+46NpTzxxx559/jVglO11/+5p//1/90/ym/7qu89/48+80y5fKAMuF0xfCh+C2scVa26gw7SMVRaOXJj/yRDNoF4bbu7lM5u4tVXGy5lEyhEakm+Bj5KPR8Y5qLwKrGRlL6UyUCWQk+aSWGx1EC0zscFwydILOfZaeFKaaAWi3OMJ2UYezNIoCUGWOPoWiOSpLsRGBys5E3FpwERBVI0sWIZSjMjKgRCOrIFGsnpG39laPU78Cn37yvZwwDmXPM4vIDE89frC2eNFjyIltrMm4HUOqNSbdysohe9grHdPzwy5ZhJYBeas4b6KelLgbasGwLKIn97TqS7v5OVrs1xBAoEeccdNJNPKwpJeLEYgBcM6wVK/pCMW1hHs1ydNKJhOV1ziFiAQfbC9L9QljMqsDvB/pATN8fAD+4Fzm0lQHJZsHN40BHokAykpTWYhRQxIriiZcnGjclgmiTm42pv4I+KNltQzpfmyl54pL677Nh3Ck4hJYl3tJNHKBJCgYEsnxOQK9oMHX6MltbqVReCbaNASafTSKcWXWd95yHolyUAQ5TG11hLzwjzNcIvK864l3AWb0xyrU15rPLJGujpKJObRmtbLcz8CCP5IxgQu8cQD7gQBbaukRZM3Cb07CN0oFQptCjHr4MeKL3/CBCkySDYvMhiKDrgY2hrvzo0YTLIu4IccuHdNqagWYbCfY8zIgBAF965rzwvoI42POiBq46ioFYrUKSAxXNfgMcCqnWwm7aeBwLrmRJ2mu1doSLCHRXzcgG0ZTDD+JWFGzVTg23rSiq8eIEm02DS+aMjOiAfH4nq+BwNi/XOqesN282GXFzcyXnrR/rVP/LD9pa/+Tbv3ldfteFX9dqxoT3vmxev2uy9dt3c/9Jydd17751/VKG++ZkJCS+B9QmLKvX/ms2Y/9CO37biZdhlXM65Xe01d+8s0e/+/8x574l2PxN0X7tlhN5xoFVwXwhsLwdmT4nTMIxtKnbBvwCS/02nIiGayFzMweedKPyu4aWUrKACeGQl42HSwi1EvbMSsQzVlZQJafcUFQFcTCDfuEYnqMhsV2IPhTMjXd5zPHuV3uMdtmRc/em19XFm5mlCihBjrUVEHLCxIj5Ub+qh4IKlEM43HVCTCAVLqZ2bENNCBohw6Z4jZbydwjFBZpv4cgwr1UnFwj34OtC+3hb1reKZsIwb0QCp6sQXA6gvnu+v5I8FdVxDbKQwiCux3OAYkMIT97J7gziqvfZBeQrQuJS4qYuEI5sTozbKMQoPcNQYN66v6ipzK4eQLRmtJWXFw5Qz6VoiO/DGGZSoFgHw1aKeiwWjU4uhebfY668MG0jmk0ERc5nMNjtYPiXqzSdQMVjxOeCpLLrJIw4UAjlRWR898qm+g380rWKvPzoYcnSWgSHcJXAu2qAISpQirG0y5PRJs5um43uLkuIFvDXyDGZkUsJS7a6HCmSV5Q6FTAxmUJq3hiKnuG+lJWOhKSwqUCAlaiWNN9M/2QQ8gqqDNDI1O62zcZEqK8KAUynWSs9UpjkNUMehd84OOgwMxqftXFdBSblQXaxnpx2q5rM02oCvaR6faLknpWYO5lzRj2K2ae3V0bqTvvOTOz+Qq7lDMpKua9kwzNsqwI/UerH5W/D6zJFm9LM/ViSegpydYXvvZBF1TOWU0w26dpqBVwRjAcSgtTu1eafaVV1DVfvRvB0Lm3SVb8RuGk6pZ1GgG/zZMVp3qyPD8wKGDZbRpopk4P+wIUSagup+1TG49eMSzTw/7n37gE/aZTzxvN27f2VvVr/gCnm7PPHvY+b7D/shXnl9gJbO/XtObZr4mG3b/3/N1+2GzH/oHD9onP3bD3vXOy2Vh/nqykXNyRk63P/5Vb/drjw+/c/e+PXjtOiVIlYppOlSpKLrksZY4hmjl6LBB7ysPTdcEg+JKqpLc0VIWwqh+IWFGtgKtMthMgJZR/QcV66imSf6HKUXe6h5hrQzgymhaXbMiPl6iR2woZwfpXNQ2BF5hs801H9JITRpcG3riVFARyYq1NBL+Zvl2yUzqt6ijth3TfqVJsfGLGc6ALpMu2+GD8xh6HnulIA3IVB8uWV2v8xxgJ3w4a2JbXh65ay/ysNuGg/AslEAB1TRaw6dso1xRwcD64wBfrSixc2M7sxLtGm5GfYnuzJRH+vr5niBLaT47D1DKC+zudXWEReMClAvLpMSRZGasIQJBe3LmRXrU7THrKr9rKNqi9PIcUvd+2TKFv+MA5CPuirOdnowl6uATVHbmVNkASFf6NBTF/1QFSklXbhu2NMQcL/QH8UGwHZtmUj4XugMogfYP20QS5x+KkZtjex7byCZvKdwJS7jAqCw02n1h/4ZVgg3ICxjfcvmxlYPA9NOvXtFM5qCpCIFFrepte1Xrd73xvimgBF25S6ZyU6PNeAMvTfzEsIsNBbRkJcjZg/S2OzFK3Q4fCI6VmbqPQKM7lYSipkG1AvVf5jakaoZRAkiaespO1HIpsojiq2n/AnGDVoOj05OLWLyRsPEYiGaw76OHRFFt0nFYIGQvETT9tH8xl59OaIeTUzjoukUCMGor0vqpUmdGj8aZTLAeWm8OU7TcDhdVVUyix/5ItWDJyzEiJMjISzcQw0qX980vbvv41//NW/b0x82O675tvNd+3b1n9sQTBW681oDMawIteQUKqkT28cfNfvlXrtlP/fRj9qbH0+7f/yJYzfa6PIed57AXXngkHrr/3HFx7axbkksFf9RYWUG+K1klmXoglo0iHM0/P6PiShyO5nKFDLUtnWC7qRsfLPRIkBC7r00SC1CmXPR6GMGjl1GOGyHJa8Dg3WAD1WHsiRXEmo4+FmONUyXkik2KhsibsP6b08Q6lUebc7gEkn3YpMl53LpPUDepZjlniZCei5U98HyjiDXJRW3Zh1TLkS4iREIvpSbhA5dfu3mI4cag4YEftir5iAbN2392iihKL+4s5NfR5qnmpZUn2PJ0XejVkbRPdXne1jNdFV4gzZcSyRgjQ+qjw+RTCv9STkwnKr9Y7R+ps2VfIfgAnWHuJTfHU9HSZmpGquI2/Zcs9gKhrwIILN6UJMiHQF0f5d+gpYTDj8ezx0ujbhP6QEjRmFuOFfch9Y4Wo7UHNm19O2kzox3n3roY0q9X8Cx1rwFEmSJ1dfogRQp20Lj9QpOKHNEe1TEcSK96pMB1K9ETkMh4Jy6sx5E0lZy5UNHN873Ji3XIJB15yzn9CmKPfsYikPX6ITXtqm9ypWChZojOE6WlJ5391+UWh3XJkaAoKf02BxdrG6TFglo++rNNtNTnNaWmE2uAqM0KBo3XZEEzjO3EKOHSlF3kyhuoTg4LWagviJuQMHrE/YtC6uhifVQ7xpBPoQfBgZklu1KWZKyi2IaSZ9fenLYmedaXGwxHGgwp8laA07lA4PlLp7INrQ9DoZCgsVVyghRjaMOVcTBFNpDlZhTmQ1EyUa/qDADCD2N3AMPrfIpOsrug0tKeN2lRVwwttOarLGIckr3Or4FnCeSYP5Rs8tQaIaw9ELbIvNnKjtS1BMmPA+eTcxOMZUacS08s7fLusJ/8SbOPfcTsxkOv/9yfu/vJz4a9//337Xv+4qX99sde+ee+6Du+PIuZ47+/+IsP2nOfu2lf8pUv2f378Wq/+gWv+37acYY9cfvmyAdezJf4dOgMm9TKbNqHGIW4nPWMDl6c2t54Na+aZgz9Y2v2LymcUG6ikEall4Tj4FTJJzd649AX5xlyGyzkdVIL04yUAiBtmGSLrBWEUWwjw5GoYfJiKbtXKs1RgbnJ74XCcmSnvvnWGV6x4vBgCwO+CWM/MRGgUuPolIEilc6yvB9R0TIW17oO7+3NoSJcBlGDACENnEyiiDq+dbxscIggBA/dHkPWjwQIqRscnoYaHqmmhQG3LsRjyUSebjTMK/mxjfLe9TNlbQ3C/Jxq6DzAUG84KCt8bgaP2aI5VvZyAMhNk1Mm1FM5I6B9Az2qKXWYSB9yO3lZmMfCfLG4qvuXZJ+iv1ZW+0Kwx5VQ3LSF7DSZPynPO6qzgHVdj+Ygh6LclMNJWVmVphNlc6XSoca3hnGa5XUFnczihzI0ck7qKgLc5GNXkqGUjDkGIUoh2Mwr/FTaRyMqJ3HJpalRkUXFcPV8RrQGhyrW7sEIVeicrXBxB3l8dKIGK4H1/QITD2CMDrKAGQJsG5UVQgD6MITzOLBRuZ2CgIBPqeYZBPbW1qbP0HzLo+xunPRdPj9nSkn1cMKM3m/PB9pVu/hVfD69SCqRCTJMQKgh+XwiKLj+6M04QsGK5IXhwQjXRSd3yEqINHdgUnJIPGPN0Yzkso3ev00t21adxGJqpZPAgsx6JSAjmVyTuNgT0Zx5yuLQFieS82JLGNFZCGvgDU0vtvJ7X+Om57ZvTeFBJZTBRBxpnpGUNOSkzQPdOdjGWQLOEGdHujhXv/CoSYeLazlrkfFzH3D7zEomDntjL7eP/LMH7Fv+9KW96fGiecTLUofXn97gNXVFvv79L9j/+Y9v2qc+ecduP3QpqOiLvc4z7d6dS/v4R3813/Suh85rb/ky6H7OeaVYu2ZutwUJ5jFC7hCCN/gcglXXvJNRjG/jKSeAARQLzkUuB5MYClrV1tSD8mTXA65o2IgloWA12JlgC2D2ZWW/2OSLtVIxrAYTdVxBUyPVJznBpnbic2R/WRXJi8tQk4ZD0uIOT+7RCZLm9qppvBn5ljECuyDbaSB4vYjDIIwumZFsHrondR0VCbeUbFVmBaN4NemiEGWGVJzbRR5xjWLibsAdcxxRFZRYu8kNnHQBU/CrXcVG6SBazIyIUVC5FJnm88OYKFk36qntBFhtVeDBE5ZtapxbNIt3rXNQETawor758E6dWxqY5wSVo5Hwpaz6BGTg6/LAlaMf8uAhEqmMiQ3cNExQbE0vHtf4A2rcIp3yzj/kTcFzDzAfaltBAqPNoepjOXiPXhVbWV5jIkNrBQleYZV6oJrlaJLIicpMJzhNntXLFHjIJYqMCITsdMJaQJz2biy/jJd5LmlJYF4puyQLa/Fau0GgPhE6XCNla8NrrZsCRa5oB6KisDkjQv0JMxiO5y9G05khtjhRxdXwIfF6MwQks/3c2K5DGNZ+vFIjbO2fwSM+J/izrqnIAQRSE3bDAmgNJCfmqi4SkUc/XdR7zh5hbsLaNPAZaVoRSAiLsQuIq1wuUSsNLt41plP8dIMqaUVOWK54Sxs368zYbL0KFDA6Deygal3xgzZZSoqYip9X2xBgYyq+YN+h5cpsggsRP+3ELjOUO4nHa3Q7phy8iD8T9HKJ1R14EqpASRgaKYPg3AJXEtARCUQIbfXTgoQhRcfuczove/XWIlGXR+aU85jJyEOPvAyl+GIvT3v+mbB/+CPX7K/+lft2/9LswVtm9+4TcN0UWGNT+36t13PPmX3VV923v/S9T9kP/uAfspu30o7j9V/YeSvtH/3sJ+yPvuvN/vVf/i67vIO1OPJyPutjzcIlp43UtyDYCCIwZRXqB4rLKJ1wZ83NPG+Qno8Tq6lxZhqzBi9C5HehHVYdfhLE0kjEdDa/GQRhc682PxsrgzLNm3iG2hMYwwvwTgE72iYuUuUoxxZhMIztU1IIuTYHRciT2EHTLzfWpk5xjOugeyLOFOJZgXWmWY6DVHwl7j2nLEyjLl5tfY7V0OcFnMYgvCTCim5IFwqwJx2KqaVAYMS+adULnS4nIzd5zHSWD0tKJv+ho5CfrngEWSM/pALK9j3A2OKIuQoM7FJqh9QtLO0Q9nTBEj14+DkFudC0Q38GKEZx4DyEGGfxe4Kcx0Itqr0cgzAdxqmcTydsv/VDI0ql3zBITcGA1Mp0QkrFuCzxe7hgfcsh+oeTsJSOK068EEvklHAgUWH/xFjHnvSAwTbnMEwZpS2SekgT39nh7DcmGoFzsYgB1heSquTZZG9mKY9fciDDNplhjM6qTAbVxIki4RkNHFYgMJZB3AhNgCW6GryzSGyDO7UWSXKicDB2Ee/n7kqvbSiQHbtoVDTchv8F3hRnmp2wkNCgrIq2OFgw82hjUDwgZXRCrES+Qc9DQDH/o6t1VfNXICKTAhf7xL4FRMo9cWAdjyU57cPclLVP4phXKK8YGyR/z/h6qBjrkkrxn1Evsj8fQpsrXxlFTl0cgeCqoceBpssKlwbbhlCoM0IalBOGuUZAoZ6WUxZpWfxtek1VMdT/j7k/ZYsBABF5PERxnKqh7tJsYylxZnXtvVRgOKFmnJRM8u9ck8h8JB55392PpdE47NobSkC217yQG7eG/a//+4X91r9we/GO21vfmvZX/tN7Nv3xXnzR7OKRR8w//nHLqS3Sj+vVX/P7f/zjZt/8zcPe/8f+ut2584csjtcnsbYOq3Fhl1MS3v+Off7zT9uDF2+Fgxx5SzVVkGdygMq7NyjfwkKpUxPBJ4de9DmYYanU3puUbt1eg0IHy2d6SZEpw7OLwbzgB/XhKkMgPdOVYzOJieTJuigQq0xDsbtvPNOULcbUIDRBbODoTKz2OpWMuN93F2/BdVs5xJqyqjZiq2R0RcP3o/qYpZzYOYeCOCB46Ikgsxlsorgy7zpwVrvocPCz6vsN3CBE4KFcybmFg4qtlE+SJBhG+rqyII1MxMrWlEcADMCniBVJoV+W1ZwrsLq0pe7j5G5maw04M7kmsyncI7ACcOcgoJK0OrghrVlKoMx6LWFKwXc+F7cn4b7HHtKaQUl4qmmL1hyYdYSmXQskTQBSbKbi3t8IGDbYJ87Jh7mJnLYWmpjADW1NSuRlfA740+T9rQ4BD7IFTg6yWUgkkpMCTZhXKaGETGfXYDOFJ2ElAaRacZwbzIZFMAyQjJIbfLSwp5iyzf3xIIwQNQSygD4tIyENowoS2Q7V32dyOKL2F9gBBwLWYDhblI8cY0T3LpkPisOUSIfrkAKjqY489mFO9KCR0owu5HlAMwEngOlKxw1gsPIDMKa4mQrPAJZJKgJMSyAlPLrQW8+79jO19aETyYZpG2YL18bkIUEcZc1VdymLgS5v0aAWYoljeVK+qsWde6gzZQVEGtXPiE7QNNOGqRFnH6c+UNPCqL1ww4iM0VnK4Tmi4BNo/gH0rtXq9OBwUbo0f64FPmSdFGeFKXYp+UAoICF2jKmAq3eonl9BqlEAGjr8JE0SFxSdZEhO0TUR4Gwgm7hsZZlZ033HgI3Lok4zAr6+Zohe84IfuGFLcf3n/++L9QYfMrd/9WtO+97vOe23f9vs4tlnLSdMMkduXk8yMg+Q2fP56Z9x+7kP/o9248YDFvEa6mgve917cdgTb3vE3v4tL/iNB942b8lZLB2L4LAqEHVG2W0Wom0esPlEZzik/UX0nV0Mtgt766reM4g7YfZXiwCFPZe8N8TNA0Z0os6EERIJjpfRAgkaRqqzq4+EXbfgIJRWC5bGHlihfRC3ze2yBdCYyaOzuJK84Apz5XtUVK3kIbizDXX/cLjQ/4LMBBI8N/RToCUOE+wu1nIp2M+0iZzMEw+JBvAgk7QdImeCga4vjHiOcZXOI3mfqSuiAZDNqI8JXtmftp7WZpGlzC1JqtzvXwNbQQUEnZdg8anptVX8nM4CPLDJ1QoDJnWTEzXletjE3za+AoGZxOLNpGSbh2Gi3SNjaSRJFTTvPP4ajsEXDfZLpLPALKIEtXD6HqyimNmrFcSl1vuVqPbgUDhgkWFq6oQ0XWaiPjGeIaix8+PGMjX/jMNEiKUUy7axB1TEIiMsUjGmv8b25JOYANfDRkoUvIfnF6vryLEvTY2sj4Njnsp56ds0SG59bWQ/M54KeOn45LipOCWYGrbjLHQGQYsJ6KcPUdUILu4YFf9TbB3yc9qfjZuObEo2xoAbYLyAKA3OcRU9wXrEdPCSqMbzjt0CLgv26NgztaHFBZSlnuxYwoxg4ySPaCXsGkFRecB0EZuoJ2BB08vBUNxwte1boiekWmXb5YVHYnEKyPbqQ7V8PmEX5Y/smfr2TAY3HpIeZ4JJKg+SXbYKeVlNK2HtvOUHGUDVTFU3rm//ObLfcH1rGZ3gCWjguuE+HgO/h9fMHSbndJJh5xO595Lb3/m7D9gv/D+nvXTX7OLOnTLJez3JyHyct2+bPf+C29/74TfZ73zsn9qDD9/bNAZe+3VennbvJbNv/8tfHw+95dZyOR6z311csWElP0SpIO9ogfU6d97BQVV5V9RuGdpoS/h4m1hw6g1E0SqMGW1x/gkN972W8Fh2SqpxFKufdSg9DC6vwQqUJU9uVUHWDOosv3DQ1hz6iJKarCqIgcgNVf2o6VzIqybBYedMIlzSUWooAgW3EUm0yVOya+UIqRlSbRgVLmy4vHWgeCuaZkgS36DJNZno3vXk0gRZfq4nNwJ1VQataJkLbgk/MrYAwy9RBjkpnWQFU8LQdc/45TqTInOuRhOY6qjtsHUXMBJOeyzarCQeS2hExY9Ei6gySZLkcqCveLBaNOLMPRHsazi9KvJ1eKhZgdqV3jhsSnIOxSHtzjYJ+lJntqXX6DTAKO3lmjrg2KXzCOhBXWcSy7DXCKNTnJZzjzpsCnTwbPjlpIwf7meAGsHgV8yiYkoTe6zT2wMKkjoCXT6O3swLHlA73ztdJWBiZosdU86aIqVkYkQaCLY6OJPJ41UZ6ZWuX5bhSVCWUUqfOHaGErnGoXgWO6avqYak9VrJ0aBKclMOV/Q5mKvyISIxGEhHovqYfnKTD9cJhXrJhnKJUU+wgk+R0UrYw0hiXz3UyZLxq5mwUZwpsdnZTxE025Xd2E/Eiq8ccKcInGl/GrvGRLzGDhepqCfhBDHX2Fd3IuXsgUFmrYG9ik5FMkWbMTfcJtw27fXCBtFq5zsEPUqks4i8pjkYiFij0yvjLS0BoiHznEyWtUmjV0xR1f2kYI+Yx/WsWhYVdR6xRtuU2ModRPh4LA1PnXtJP84wJZFrQcwjd0BAf93UyoomQjxTkmNh1xO3OY/ybzh6OJjh41/yNS/t+s1cvjUf/EBRVy+O47Vl3/fX/PzHHzH74R972D77uUftvX/kZgn0vM7XTEamN83XfO2fsFuP/LbdvfuS3bp1q6hJvmDiepDpJp0qNkK8TF168nRZUNXfA7TEHqRXobaEA10hxVxKRvWQlt5NquqlEkT9dgwER82eiMuxDrrAfIZOQDVL6pwuUzqsgTAdrbV8j4JxCTLGjk6g94HAw7JwbrCBAkX7I5m29RgmfaQ4QRwoXbhvMigXPIu+gSCVrcqwkarWLxyMs7hP8v1h3IBuRAR4Dv37FGMj2D5w/5eI1lB7pzcW/Fac0nQiD6rUsyvlRPHBKaSFuUTcuSTz01wK6oQ2CIRrZ+EpLq3EyonUVdp756J60LGfrEv4KRmSrlJF4vcKxZXy4au43l4UQKqQuEl6pfkv9diPEg0NpGISpGvoinCAD6MzkpwniO6wC7dwye3uTG41KmjEZOLhm5cxpErMIVMIHwceT6ruCOjQiCBR5lrYWRPapDEiyh+C5hi7g2e01gbWgHNmhV8Wc8jNPzK2OhEFgkmoJUTJN19EoD91h2p9rpQ5BnsZBFUahkto4B1M/3wLTpzYMuqcC1VjugjqRRv5uGPCxg3i/IJsmP7g+seiqUTtD37DTQivEyET9MM0rC6GzQa3UE+i7mBs1GAGmdLqpJYbQFuQnrqEpRxp08hiGwRPzs57nmMkJ1WyLBKtsh3RTUoOxRH/RTxpeo8khpY7UQ38BtbelqsyLavv1wBIJ8ng2c//cYiYV3ZCeNbUQh5M9YCLjuVPoPwFIpDYOwetCpTC+74GiPKKaAq9fSLGK6yOaIDFbWOcN+5TnwIyLsvlQcKbxu7lW8HegxnfEAXBqPkBMnEGAOiL0yyOuv5YJ8/vMQvZXuM0u3VzesvUe76haZqHHrTV2/nHH7xpt288b/funG/owy/vn3Z5d8IzT9oDl3fj4rixwvV8dNuu6dKGxqHz0KfDZAU7THus3yIVIgNIxUA2GK530xaFyjk6OuBqWE+vkq4hnV/c/bGVkixXnTBd4b9/s5hIAAAgAElEQVQIxEnuJgydao+Fs9ctRj2db84CbZZTD8kvatvPkaIpOljWdhvX0jD+bxLqFCmQk8qMu7g5WzeygYBk81J6V2ovLmWnoGXgIMmZilfo6hr1L007ZPB2Ky+DugfoaHn0d0jiO8RT0CEQ9Us9MLyvI9NhUlnkNQfzBxA4dTBw5dFxXBV2d7qq1T9huiC/cRAIw3wCq2QGEwIRpvhE+Qe2ZLS4UOBG4cs61sWvCXIF1Su3/Y3LplHHDap06FaV0IsU9Kk/DRXGJnYKnObnD4puLlmsYA3MZYCqPBNyyEbCncbL1wuFweBBWXelO2lemicD3Cw4pBEVKIkr6NZVoIYzJqbZOtP0nfFay/6cBNE1cyxLN0vW9KpEwADKGm7px487scRgV9e9uD4D5WUfsutsI68Kna1WgsHkMi3cxGTClctRC2oVKR9uiXImTkqUWZzMN/ES1noebLKdyI83SgjfmFmYEn+p8OGj6jwaaYJxfMPiS+WKk0XaO1YeTiYtfpVAqHrGIojx/rbWbROF6f0D5QWy1ji9xWFxJFlKipGW1KhlmRJ1QBDCUeSy8tlQQ0swjaZJ/AobQ7VlsttKKCt1Q9TgCQLE6F4MUJVQbtQSpzQyA8Q2XFNRtBMFtsGkgVuSd2FsCpsJrlHpiGZAt9fS1FwiJlPfl3kIC5I9XeTgEAFTBWwyk+HkvXwP48ooUBmvjKDewR/I63UnI/PLPXzD7AO/9ag9eetN9o53vfSGk6SLy7ESmCe/5N44bpznYy+VH0ZNC5R2PtMQtQ9mCHOIng66u/FJplG54RA/R0Lbfahyt1QMP1Y23BocjjGrFYoWgwMGY+sB1jFbNWyhNYdGDS2lf+O0rEJi5R23SRgdmMCodxxosneOMwbEvXgqU94wm1IGKD2qwKyxCMzRr/NrAG5Zk7bpmwmmLSV+B7vGWqabTCdaIESA4z0UZtFWBiIB+HKgl75i5fyYEzIv4Qp0lR6M1hkdhQQ7YGHI00NgjB8AOtzwPrBJZoDWW0AwrvpbI0qqxkeTwmhKvCLawfgcHQcMEG61y+Z3OpF+HmxGLFg7hHMC6G8OMM+3USNE6rIhoBFvpT/MudoqsTzBALChkmaHysAw5OSPYXwSyHCsUf/1TEODMOpR+0C5K+F0I6rtSKqKTBGlsgDCUGAFkGEKcuuVL+Hs0jU1Aj02nPXYD8s/ekI3cBDUCYJzgbkWBMWwqHWagbjpmmDOkoEnNRLHRgArFDqIg2B0Dwb6oJWLQTODSb44Q4rrpV6+3FVzT1vJWAbmNyBjjn4ZyWI9NFHjsswswZ1ezViyRpcIGFWEtuvH71cAIgTCvBfIOoNdwtcABIsaouqZoE2XXyuAvw/CqfQeQeNYWUggF4YwqmH008t+I8lgcaNSKulh0k5IFetGmGiUikqlXTnYF52jLQMYXkgieQARYW2xOp6nC9yq6BqlcsS7oQnI+rG1Ffk1A8JVxHtg9hhs+pdgUpLJyYhBhZdBf9MkOUhNTUxo5oJ1lgEdg1Z9++KUynU+lIfaJjytiT50jxLw8iF8xDsjWcthKn+siFunH3WbNHGBwsDJi+YyYNpWCdohfAcFtDJHQnY1WrPi4cqSDhRVI+//waUibyAZmfvp8r7ZU4+9077sT7/VHrvx4hvuG80ff/GZe/bCI4fdG6eF6G158shnyi+UqVtzG3TBEn/FqiOXnh3SSQzL0C8EJ2MKQh8JJweVUEX09HFQUXcpThRHYw3P1EET2J10WqpiH4IKpS8go9ZKUQdEoTTbq+J240cHhMPRpmE2q7VFqAJKr8mehca3MGJGGL5I9qgXSZgV7V9MQ8LjUA3jg5A+CUKJo786QPJ3HQ3DKTHLUpdKL8DcFaIjgkN0QiGljUsMuGbogDpkwd/l1aI5SzX614dRUwXJTIlB100Y9ItpoaIEsg5VzI3X55BvzJKr4dF5ILPkeZSOPjNriYSCXl3VWU8P47W16yEvkYFBVHE2sco2aM2pbQIxzjrWl/iipZ5PsphmhreWJcFnOmswi2hvs8YKxoSPW10YEIaahF1OUaLajIDIevQnCuxY7HpACEy3Zu/owKxCBdZSQIG8oJIsrI/yLIMPLqXUWpZ4aISGDFA9/2Xjl9XwLj/WLHwDCcvQOIVs9vAoOJ6g4Y/w/YvGsVquJ0eR6b0mt6jNZVo9BYPtlWn2HlM2dJMLYmb0Ah04dtbfBCXJDHIfaNFC0C9ccYFSIDXtSWI/9jxsV5yj/p6QYMVPNLqGqSrowNQpWhNS2VmYeluU4uI8AZhRQJSKll5uYZSSS0vxVusrA5BhE2LUgFEg8aGcbYWdpa6d8u4qnqhYVBgtG8Ng/+0QD05ymL0hDpLZqRXlCBTq0PS2KfiJlvyQkOHPODnMECWgPY16HZIwodDSMl8StbQKqwDTNSlry98ngLfm6ZwJLJXaEtmpJRttuLmD3L0zlF8COk4QhggCoeYK9lyHUYuHBBYV5sa1HPDAyig6ZVSRPJ55pu7K85///U9LXlcyMp/9E4+a/drHbtiv/lLYzZufsWdbu/B1v+YiuvvcaQ/ccbv2SMRpJ+QFvDqw4AtSpMyFerFfbUZKE14UonLO2wDJFpGyteXSrwS0TVtpPuazsd3iI4GDLMsl0R2FiRDbI/A+3/xglsGWLH7eWTqogxHZnfk+LTZ+lkRCsasGe32YVaA7o2kFsp+AbKxXi/ifYplQAdb6t9ieIVN0dRaI+gZLS9TRTIEq3JT+28Z8rCJsaennib3FZBIpeAy4YRmEQNRMKy+/maRxjQ2Nhjh1GYZWhEPtK6yjTHLjcsSfrQeBauyf6k2AHKBkQRFJW3FOBOgL4Pk59UhWWiV/v3WbR6j07Y/Ec4ZeHMXSBYzzFg1phZuWSd2IoPGgM04PEC/IYkFvBCL9msYSUYF3IgujS6hyc4WO2itwUkXGEPgK/Af+DN0jYL9zu7O+W384uSxboyfY3Ojv1/NMlMQgushstLbDELmzTqDSFVkcwMWpIn0sNcib3GT4nsN7zIVtkW7z8N84jgXsMPavzH2PYtjLvdmMHJQxfcBbYVxjG1tdxdx9eSJJq82E2BPqkr+eNb8JzBlL183T0GcDP9ZT98a2G+EcdTRs626oEbnFCzZTWGmA1EyZ7NroW2pUEEhLFpkex/o1qCcM58wy8zBGujr7hyavUiO0Pb1PQUUjeRdgEVvhPUiD9QxRPK6vWMMSfVFJqURdSRb3DPVSoosUDNhdPFenMSHZvz73vKJQ2t7H1s0gjVnzUTgRsI3b1Usvm0Nu7JmK/EqBKkAeWIDBWN8zlHgmgzsZa0oafDy4qvpOKMKPgtXDj7j21V9j9uCF2c3bb/z8/2Kv15WMTIObe8Psf/mxR+13P/pZe+KxextZ6fW/Lu9d2uU9s3d8csSDD3nej2EPJI5dX32KdRcOOCCyo5dA6Lspij59aOWjwVvipqwZmJ/koCD65Chxy4P3DLBq66jIQJaAJ/BHaLFCGSBQbJ0AcdqFFEdZ6LGqNM0mbbBq8D6MBUszLPGwMW4ymkcQZXMiQMn3NFPo8V78IiyZoDm0CrA3Yak3rMTSJ8V6krkGy8ZKHrQrDPKs7qzRNGrD4+qcJTghcDJzdEmhU9I48dQdXQn8Z/MSXA/BvAEfVHH/P29v0nPZllyHRcT5MvPla+q9algtO4sUKVoyCVNk0SjRMCTLMMSZm5lHHnjsgQf+BzYsjSTAQxmwB6IGtgVYBmjBkEWDpgl3MBsTEkmbTbFIFYtN6fUvM78TYZwda63Y9xVZZBUzdcmqei/z++4995y9Y0estWLFJt1ZmXPvQZaTRbXzbEmj1W6AFx08G3OMjZ73Ao1SXxBYBnLBAmhgIGWPUqNic3gEwrQI1nVR+g5f8KLZjEMZM+YYWE88sZlwSGyoJFHnC/+LXYjroKa7OxXnPY5E1VmpNU3tj8ikCdfl5rSshlo9E70wKG9NoF16p27COG1HnhH0Ynm1ow2XnZfs4A6hbEW4LydpKt4io5iI5YXTHAqCWPAtc1RKbG7amzjjl3vYNOtUZ+FctEWHBkyV9mRzNXzl+KyF0rtEg445dXU1Ay5OCiJajYQoKp1R5KAgTvqC4XtA4iFz9uKTKg5g4801fT96tXGz98S90BR97WncbRbqjKDbqAUuHduWls1Tcgag9bzpqlYY0SknDS7jcQpw5kfJWBbQqcmrMJEM8NCmGpP5+rnJIEimKmY4ZXStXYubIdPk0xofteDkHZH7gF5aWFqayDvbWemeaptCCOr7Fy2HZdxk5uNz73g1FKKU+FCaoBhUkr0R1ua64nOqA49H2LTwxrgrS8wXHJS0CWn2T8eaqu5IPXmRb71d9rlPuv2n/8lp73zliidPbN/2z+P1J5pNs3xFfvKx/fI/vrPPfurpuvxj/xJ/wletoUFpj55+4HeZi5uBL/MVko7ADgsaH6CNfhHuRttHl/VZU8xElEcGSNnAps0sBXFVWI7dII38LBLO4oAJNspOaTSFjpRix7ZVrxAIOBUM78XwGIe0bpUL+MLOUXCShAIleE2s9JSg3mcNFLsKWpHbhEYyPzZywsbwTQUjhwKg+nA1b3BbhbR4ZvrHKQgYZConIPncH7htTyrmE/R9U4RnaxRmri4rMZcX4vqdjOYviCFdMqqCM2k/y8Mo4Nxs0UgYSFXBF6xydeQwe03MkAmgBa0RYOLCg5RyhJat1Y65QvYM5zji/zi22TTNfuRtTgF9EpyZHUnE1MnoaewX6ZQv96d6WI/j4WkI7JXZNuEddyhibDu4ZEvvpgCKlHK9p8+RLadlSl5TQhKDirbkJbMR+cr9toSDWTKGGGUB9urcbs5SPkM6iiBBYnuwoe29kLobJSk8p4hs6EnE/J6RaTKZMJN3I5KpO5OUyXD36a6weYbyYdtQTSfDBwpmfbPYPgFbSBwr0VPncw5JIxpNW6BArmeeVKao9wp7bQSMzOE7CeFwdX4WvkvYWPgo8vr8riszQFpSAVFaoX+APAqvMzi4kuV2C3qxbDSTcJMTd6bJ9c01ZmzbNWXHuv3QMfAr87ebUJejPbrVEOZIyAkpg1gDVRBnpHG+PojRxDTO4Htw36kjDyUeirXg3rMm+SuxR5xJSGl6x0g7IHcV/H5jboG7OLZZLBIp7HIeGNePXi2yqe8Ke0vB1lIsFft/dH/7rvUckisPTnrfHy+/fE3frfobf+OwX/snFzLy8Bs+//+41x+bjDx8YPbmW2b/6H99bP7g3p7eVEjf2Ot+uTyWvedv5oVQRL5mVWr252QXqmV4Is1s6JuiH6KEotiPWak8TygTNrp3BXMSPSPCoFM5T85SE0/Z4a4TTwPWe2ty/K+VgAkb0JdhxbaL1xg5rdPgJqGJkM/sSGJB2D8xmQIzsEmKhAjShCTkeOmSSVBtK2edJWjAl6Ttu4lqdhLXN+PWGHRduxDfh7V0bX5BhHddNlOc/jBfzlkhyoS/tzx7En22Lp63niaZUA0MYUXI/AumZ6gkaYowFWFBD4HZYobmzkEbKEBxziyVdIyWbnOM7QcW3PsDbfyp+6nxL/vq0HOitLUFEYezW8E4vkCwq+3V+/YPpfFEhgNn/WIILzQWX5bbr2qdQe+9OlZSWN5AEGzdBsQsCIu5Seo7KRFSg5X2KIFPl7xH62VGPlHNyTxze28nazi1NmSpDVXh9sYmdx3dFg8V3Uckboxvkw7z4EZl7UxSaH8bQMUp/dlQtKKYtabjqkrWwhxspOhFwYOULIx73M9MJtP2UEUSRStvO9dvqnXCq2tLpFrk+/jOYSOJo7TJiOR4DiUy4jVQl634UD/1Wq/yVZnwrYtSHcDDmaYyK6Lo+22sfJSmUYh6L6OqBZQXFx0neEEHgJimtToPX1GQTT9mN+XrwEpUFsOnh11XxZzCefHKAE06Abf5/C4ay4cnml9X0kzUFws20TLHRKiQ5FLHxiK85H7FH5m1tNuBeRJhbuyKska0/V2Q/1VVXkrJu8sT5IH50/vy/+kn3X73N+2bGJT3x7++bjJyPc7Hj81+93fdvvvbntr3f88Hgtq/mde1vt5/O+1HPvXT9aX4M/e/9+xb7ZWXKnjk0VnnACrYgh9jCCdF2RV1aWq8DnmVwaImbIIxXRkliBVsi9gKFU8kmqxxLolNC25SZ9Dtwy+nnRAfrsDgmLuRN41dgD9d7RhAIyjoYmxczjjO6rxYNUq0LcvDGj8vCC6YmhDnEAbQ65CjJFZfqBpxB5IPOg0yod8QlonknegkJ/gd+NjSkSOrUUQcyZHNhZbvsbLoE1pb1gghgjqp5UNfnAOsargoKuHz35ICCtN4bJlSLQaBQQCYR7pvAUFTMozZE7TFabMe5riQxhpIlSYlXhUR1yabF3vQG0hsBlzqkBqWXVW7FM61rX2kxTSljalHdcRX0T9TwuVdxrfHK1nAd7+5K/F0mkrKrGFb0X0PcmHcyvCqZSuJ6h4JbaQSAVZnhvOgvwkhCIzJRKYkwszmmTAhaVnhQeX7oBN0pNs7YG2LDxSt4PpKnhJcj1j+C6FgEQEpx85NTTreFK4SXII7OdRErHN2bf1peyI6MIjGTaticz9TI7d2FzqJyTzkfhxdLfm2n12ikVgFoRUROtzfdf94l0wesT3zekPHTKCtngi9tErrM+f0noEZSpB4Z13fmZvlUKFARai21aL/WtGKHqVumlJiHT2DR45HODF2b47iQmewdrplWt24/G65JPV7y3fQaWKpTVbb8zGgFVuJi+SV/q+Mp2oj4FtPhuyTzE9o3KQFJjmT26ahoWCSs/o2qoC0zCTBXG+bEjaCYJOtIagdS0J+aNeajyPsEx+vlYx8w4Py/gSvr5uMPHpoyzH17/93r9lXvvLQ3nj9vNkj3+jryr4+ePe0X/uVb7Nnj1/1Bw8v29eXFrh00L4JRGob5riGq3q3oyEm1hpmdsCEAQ+j1d0mOm64N4XswGMqJ+e9nZXbCSHJ8tVLpTJ7Wx23g0p6zXcLQUOaVwMtDqRtE7pwORdqMc4UM7KJQjIPHUla9dZVWFYJduw3lLcv3IxHUBgw5uk6sR1LDCOThsaR6IV3SO+tL2kaiLEF9jmkp6rnwdL2biBiUSgGBfljX+8YNOcJj5FpFkRbZd+prdYh97qpfYq015y1EluautfcJRxTAHdib1SUSXOEBytcquiq0T0syJn2iUn76E+dMd2vyIc5wDB8H4qprmF2kqTyeIZ6yDQDuUm29viD28m7JL8F4/MqAXr8Rgr4zG+m4YVPM5YVd7EXxRuzY57GtyJrMGzo7iw6QwOvHhtW0wrSird0AR9nEMe8VvH0+EJogyINRCCmgVYiKTqImEGXXF3FQq6Gpxnn0foPakuI3QNrWSla6j5OWlZ8CqZEigU4tkxQdi04z5EA9vNv4Q7FPUanIhT6+NaEwSjZYYe9DxrfvzrVddFYVJqKLSDRxJE7gc98Lz7MNQcqubh0Co9CajeD6aJogIe1FBKGyNLx8t4Qb5hKDVIs0mAeyOd92zdsub2BWRD11by0ed9YuztpyCivfUsruXemaCHl1cogKymrxQMyUS4plDXYi3VtUQtvqUCw11qge7Z+7ylqFX/gwEtdHuG5bq2nTwmYBt/PDdHIvGUO52yigNMnxlltl1pVp90Z67oXXPJNHPt/4tfXTUZefmD2v/9/b9jPPf0X7OVPPrN3hAd/c6+VjJz39ouf/D777Mtv2qtPn62ldhRqjYbapvJ3asi30m1b3CoAScYyGlBUrIVWg5wpQG0iTxP7qPctHVCsmbOdQ4kWh4hSQH+EnJEenZL762NUEdu4oyvR4L3N7XvVHKlaUHkaO0r5hZV1jZ+HzT51nqF449TWbP3NuKElpfcDS5gpsHOSJA0imG8TlaBRNb5QqN3G2ISQtb3fXmlJWzGfKtWPja5f4Sr2g6DYn7lkcpw2HFozN6dlizmVwM4zLvyFc7QfoTdpmbunW5rfKZvBiEup6hmz5ug2t69F44E9Ug1VyKqsZqmwz0OjEXaNlJkrKWCupiNhF7wr6y4JF3WzsfwHN5/f0b/KWGT7KQFYwWRawY/i1qvkCmSWIh+wVgfUpGyoUcElKK8cyqKfgFuefUFEDG3L+nzOQnTaFBXWa+LqZo2hXCmcSarpbCC+sVHs1gm9n7PqhJr5lo0xU04BKqlD14yeBNz0g02hRqCAYahI8APwZOs1Re8KCnfnEY2aVAUGZfJKrqAop5N1EYWlUCoBLfqIisADUi+b2hJLtzIzgcrVY2AQGyPOETGdpb59cx+EAbSLw+BjKDTccdRyfWDTFejmILAdgp74su2wPbrpu+/HgKxKGYZ8TpIElrc1NujX5TW/aWH0Q0S0pfGZq9vKFjS19AiGGqs90Of6pg2IchC5y52+1wcNnEdbmKXzEVknUZiJz9aStd7FwRETp8fRhptHYtTkny4F+LqvPzIZKSgWvus7n9h//B/8uj1+eP8NWb//Ua8P3jH7gR/8kv3cW99pX336WXv8Moc8LwNSHUSxKK+xCN8yjUJkmYOh4VmJBhc0HtukSNKUi4DfxrsbP3E79Kur3mn+R2hhRWzGgdb921ww2oXI9tluVex0QAXsarpX1TOxjzg9yndV6jyqlYXDIh+ZcG7nO1t2lsWDgDuNqJVg10oHVP+P2jXXbsMM+r750+ImPcU+VG7ya/L7w40W7OBVIeBpFuCpvg7OEGnNx+rc2XilPWyTMnJ9OowbiSVsMZSVIX/2uqCDaMTUU22g0n/CVBXj7k/5Y1KQYBRkwkm0BPuy2No0PPh8TRiX5lJSOoIv80x41ABrS7KzPP9zBsWKLouN/aUsAELRE1I+YOW2ATRa+05XOt6mxvVlXmlzv1AWh3GgeatJTlRqEiZRo4reLS5PKWFunt/iLTY+O9vVrX3xieRE9lAVV2rX2DHHPLZgHAMa5khgBHVSIjW4f9Nd6FIz4gIMB6BSVwtMo5SHVLeSqWBzlLRahL34tJ3TsCBN56oGAmiywEBM4XBr0gwU/w734zpEJ189BW/19dOicPPLVRBwXgnnB9kcvNBsOpHO0sGH/Td3Xxo3VhLe4jkQziQA1hufJTNC17woXRPv98hLxEznZH0EBMy2Qgv0COdzbKRcWxInuTOI8uEZgk2Q8Hpjihm4ldrNK7AG9c68OmZj0CZtvUalwUZbIiSg2Sd3muSBKJSLrJlhe143EXPqD10Ea7+UdPLmkxEXh6w3EsaqXIrqbX4lrKMCF35fd2tE2tG38O6blIv+iV5/aDJyJR2XVuSrb8VyOvvEy+9bfuMeZ3/oK94x+8wTs1/O+7uvHmixr2ORfx6ZGCDQLDlPU2qPtlNu4Pl+ohyBYEbICWKoco6Hpv8ZS8Pl5qJRcCj9r41yue5MW0pgwCObLftvsrt+JnXX9QXMi7SQkl6mFEg55bMdFVJYdTonCO8paPZ36/LbYby+UIaOc7mPwu9ELSC+AknQyUqwPfqooIjLiCd3wwJAYvdSOxmnMhV6HVZTxbHm3RsTduwuSoq7b5Daq5VgY0xFFGaCa/7njBpRaBLLqeQT1+887hm/eVBd54mcZm/hTxN3EDTouM6Wa0osFWo9LXEzX5t6qb/A5c14EW/kwlxO/p0C1BlF8zSH6H0mjsAmtj0+J62a4qQg6WBP83hRF1MSnecSS3B1kevaWDVXQytFKCnFTq/Qfv6N852Q46z0n6Wv4yT1YcIIjVERpTrNASp5+55e9++coz3QJoPvgJFDrTW6yGnBPsXhBpxoUrTZaBEUmio8gRTQoQ6EPPW4vVm28vdabeL3Wwod04Ni6quP6KlKEs2MoGh9H7jGOOT0SjCrR5RlT56k70k/1ISIpT3xgy1zLfXgqRd4vimEym8CbWiOVlF5iTSPsgGnnyHFvNGiJwiw2JMXk02P9KHPcImFtyJAaRSdRGWXw/WGHYb4NtvGKXkWfTYKrAlUxfphcyZFuxDQzXXzE0+32y67hNkgJHqXJpXnan67xk7g1p7MD0SwdJ+LMuK+WXAxpBJHmS9sSlbWE+wpN3bqoOudnukFZpj3gqQQ5jl5ycveWz91nU+r21vmrgQ4R6dL36QNLxVZ4JQqqWuUhxKhJP59ox14xmhjpZMBSP+2b1F1GoXpQnGutXQ+kHLrBSQlf2gyciUiV0Lyd3/8I/alLz20V155PgYn53lpRu7tN3/vc/bKv/q6vfzaE/O6a8yNpJkZ25LWRJZ1h7Mt+dIwgbU1ZIl8mkuqUeyZaWNC5rD6irl4yzpSxk1cLkgv8NygOgMfsfzcIcVy1FJXDEqDfRlkgv25GPaI82JZa27sieQcQSQWuk2YkCaVuPRzsNNz1Wc9+8YImLnkDsUufFp79CnCvuVrC58YldcRKDvsi/EYfJ9KnJpeUpgTLMGrzllKP6KVMlb00kR+l/sm6SXtTnNJ62E+zoY2lXmEA/qenvLUvW7/gafd6VWhB6mvj0qLoHqnoZ5IePt373NXPnHZqjdB5aVOVJLmVA+QbseKwLDWNRem+7STTkM9AHFlr+xYTtaoLHmYGfUphUfGXleWsDz8Kb6hfqCKGSbVbDdUdj+1GsWRfLcwAIaWJZpvAcoiSnifHHMlelWvA7RABJw5dQTm/O4lO6nARuxFkAQlE8ee0bimdOTFJtsUpCAOzIvxu7/jbvXX9TPGmm7yDZF5xvtTPm0MbqMMLM5m410P5KxkNUSvtNn+SjeDM2ypGYaZMMeCqNYYRQ+ktC1ZrWqEub3K1/MRfYmbaRtm0iugTTRFxcCTj7TjMMucR6SVkE4TZ1ZXpZuE1JwZciSnwF5z+IjRhdH+sDEN1VK98Cvgem6UvvUVJKbNRmB99JeCT4OjlEo5+2UT20NWN+jEjzaVkFx7l8jSoTaecNG3MelUf8+5CZ1tNV8nZQWH9o5BJHAS40mfHMpuQArDauFdaQoAACAASURBVEph+N0K0FGCq2ZLbF1xmMXpuMxN3OfQ44McGX3hmfSe2KBLqJ6IwE+pvrVTq6G8kdLAVZIHkIPlVt2g4l5KyQ7bR/v84arT4/k7nW2vr0lGrkt8/XWzn/mZh/azP/uyvf76aW+99XzaeK4v+uyJ29/+21+xf/2NB/mFv/bQzncZpulg1FvfURIwQDUzgG72Qh7Ck4InY27j6YkjdmHB1v6JeszUebM3srF1A3Gw7nYmjDQLcaHpLLtRLpO9Jzi2MIEZV7FhS95QZXEqWMd7jrHXGA7pvhdAcyYyNme3mkyHMeJXDDXdC1329QVXcqGyIo+cO2vropNH8L7kh20V1k32sisN5xyWZB1etNcInnedburOsmsyCpU3g1eY8izvchkFSZv3r7Qd82uAJAVNCZaBHmYrkg4RyOLUFwgxNcR31hUr8yLzExgsbh/S4UDI5GMCDVELwgUjk2YPJnxLop8rjd4oteiwqqnvV7XUBTWttaeiNAwURtJVIDWhanE7OUI3d+/HXJqAIlvQaUoGzNzPBll6NMfR4x2N3dJN73XvUIUDwSUGOO51CVcyNw5zK6KAcvdKPk9pKLQt6CO0fv5srwPXzNs03esW08ImWeGD84G8KGKhAgvmKTT61UDEEtTvueUekjCenURhdDSbRZvxjNjgSwUE5SJyf0ZyiQU19n5XZt3F8qrGJ/3tzJsY6rAr19+f3eat9pXBFKgf1kmGeBrO7vyiaRyHFDsBl17oQgqNjkeqsdzYJl00/izOAKPnFi+WmEzfpCaapGlo35xVJeQIhTg3HekoQ6iQK9DfMAeMNdmykUmR6Tq7mkpGJYi0XZBqaY6ShmubRtMoUHMyHt87gRByRAl0owHkvkgSUWdCyQCVwIXoqwnLdGdPWEPZ9Oqz6YHYE24KR0Wh/ytvABD14ygRcYA0hJm23oL1R1EqZpoV9ZAUjXlPB8Grir7HD1dEnToknwdN8qHX1yQjDx6YPXli9tM//VF75eWH9pHX7v9UHTT765oEd505f/mvfJ995jvd333vib3sD7GKjy7X2hxHSJ4pk0Prq5PFM5TpGvKI0HLCKWh+aQO/8Is4/DYVg2GTtbmSgGg3jUdzaMlJnU+IwHBFzoFBjbKOvYPeFl1TcAIHZQKOqseE+bdKanmJY4SZJ0eOtcAZ1XVAyVD99yIl2EtQNNovjdU2o97DjJFO3R5F36Tkwc2GhD6nVQcUxzk6hn4R5+vNPH5BRlQGNTAGNiQ40vE1Q6+BClqn1ZUgFWLCdNNaokhPkzsYSqhuGrgu8ujxNH4j4xxa/eJAO5NiEGOnCw5WiMOAw5SxZ7RHjnA9YHoBM52YnmRMsVjL6KSNDPU2rO19NEabJlUDATDUG7SyY8SX85lxTJCtxXJh0p0yU++2BgQKTr4RNnSC3eB3sp9lrZ7oySyryzUo6IOwlAdGb6I0tXu1eck+RcSoeh7Pwa2bQ6l536W4NfqcuUkEGnVSUNxOxkpDz7iFxbhaz0GksrbJujHlFeqfGKLkqe2IPJozxwCbqADep47Ywb/m0h3uClc3vBeStOKcM9umJxEba3tQCZv5c9VWfOHAgDbnQ8qC+Acc9OZiATd+AkkTH2UkE2egd7h/ndsuu0H20QilaSzSj8ZOKok948gNzB3l5aCRu4lAaDIZAiqyAW9efEiMv2Vynqgg8P0028WliCchwaRYU6eISzOgldDmtfZjGxCnFTTzLtiE2N8iRgvU90ZNEiwJCiUidYLczmN6xsUcCnqmqMer5jy/3sHA7DTze/xx2dpWLZUa1apKZJwL3Z+b5CdxN+DMxm2tEq3bso9eyctdr72eMzPifCAO8QXQNLsNyipsPv5xs5//+Uf2y//vY3v9o/e9jeL5/OesJqh++Avf7Z/8zEf8/feeUhCealwoGpO6WMoO7nJpUv+m3LVYI/qG3LNuP421Kg6iuL0DWeh5Xesoxhas3ztN9cqc3iz8WARiC5tS1BFcTN2nzhES87u4HV/cFIRARgChv/TNRUW2oNnN4hnpFttOYjvojCfmovAruG8QwbZGIlwl56g5OaxuEhJ4KTlmJcV/xCmBC1Lww0xBkx/2rJbRbwrr6RPwJErvhFWFkc20ICv5cdXcbqkABAXZYK1MfzIYL7DoOEpVl+ZoCVCkgpi6wCiKUaf/OWQfEgrf+O9hUeDshitWyb51rWWMLqPTBQ/DbeZOv0GbyZQWoVNFiHA4vC+FwCPG6O6ehLDFe/4G0TfH2AqQYEVUxZU7IcvA86X/bo/Sqr1INRI/NACjjkPaYw7DHwaLG6wvPlztqSbihPLLVoFsqSicfeHvW6QNKGQY+YfNYwds71qXdJxv5bwRtFLBQj5WmATzBMYXPm+oNUIxW9mrixOlcqHdZxkjEPRGt8+VcvBRFPc7qDdpxSaez3wk/kbzmonmeXb1lO4sygdqREsHX02qVdqx/C1dNATAKAudLSnFB84ukuKsMCGG1csRd3m6g6jhtFn8a6EF9HOaTsCES8czqj7e9qSiSA85oPzh8BagX8611puPa1cLw9o2hxn1nCKjA3JlkQymLIUIUlTUTrewqwEJVmy32b0mRxL6KOvjGvHpNs/JYoeUVPKUkyEAcCOghFcClx0E8maEEVLBceYqi44be8Tn/bpBRl56ZPbuu2Y/8T9+1J5dMRbzGJ/X6x7/+fU3342PfPDMX3r4SHc6LHuqTJdi8AOSSJIsZ3JCoQHFoLYRkssVgUvocgkzCT1BeBvpe+1OWXApp8Eg6g1I25E4dOsFBZ7Sv9JZkQxJdiRtbSPOheY91xD3BRiexcmeK83PNpXaMLRu/XCXsh4T1ivKNMDXubxIS4KRItcpjmSLq7QLmWl3G/ylQicTgyyvFD0Z/fiLo61CzK/kXaA8HDFPhirVkqnl1FAcogBhjNY5NReI1hhjTYFmb5TrzY4eX4oOQ0PnA5oPb/1ZeBnrF5NwCWMyAYvsCJxwfZ7O6nA+v9XerWqrq2hO5+VqS0LkU3buLKB0iARdSoA0fivhFePgv7nOUv3ZbjrPxPs2U16p/NIxEj+9bV6UPrUSGR4MK0KGiy5j+kxqiS4WJFD5IzQ0W9aQrQAqjs4OSOR6AvNyemt1rlzXeaZqfp4sjBthus7MA6ekEDpi2kjM+qSZQsNy2SUW1S+BhIK5smFACKsaEMLq7tb62tF1jWHrC00lIsOTIOIXanMiJ0jHUDFTZo+rgmxoa81hxpc28KuR/ND5o8HOFOAD8PIpg1irO84fkl9GH5iF4KXJT72YAhd4FCw0JB9N6Lkar20EOtUzXZnyJWVWfhNTiOjMYt9aE1RlZLNzSkpZcuWN3xJrTsenpE7/ZPrFSoIKYoMkGsmQBupZwlnPNK8YtAYf/KgAW7LcuqGg91CpnZ1lZF9DljqeZW4DzyynVtS3OYWsDb34PExrAT/vTEc2WpkaXuC63ssb/3z9zeFcX2xn4KG4iarQzN17OdfDZN2JcYdb61LZM+HML5Kmub7SRz9m9o9+8rH96q88tk9/+ulz/0Cmp5986eFV659Penoithp4MwdAhXOQfi5T2GTjrb2f1k6ExJmrFYGjKA8KKoZYkeJiEolkYPWmUY/e7QYrMFiw6309LVzHqmPRDHOpjFyjJtUDZKx5nSzEJetaqqBZuCokQMQizaYcBWasAGmxhJp0B/15/ecAMJxOzQV1G4Ux9GxOQcXcqZ6fTIONpXPt+O/q1zTNu/JFWSfJl06sOg+65PRrpHtp2lnrxFuDEGxxZrXX/8HQjUIzh1+OxNDpdYWTUKBEEqZY9x8tCoWZ3wE/ayMAyd7FK5PevyEr5nXhi2w50NSagk8HzwZVUQK8WYDxkOBgh1j2duuJEJLG33S+Gpteaen6fAl584RkxfV00LXbB9AaRdMIRFA9KA1iCVft/KC/3/odlnvS6xwbPl+EnTB0qfHH3S8JeAs6pFeaUhz8i29BIJE7SVKkdQkws2P11cLb1pmyym4ZK/kDn2T6HEIy6O6Pseau5KVYxq7dlj113ntMPD2ZYtQpwnOQiaXtPKU1WL9NonLyFC39hPxB7Xt02Kaym8CmEclUBdvftz3Swtg8A21v0OZjRilNiLRWf2L/9qc7FMGrwu06DJyPn4JRVoCBHzLTHwIAHZ8KThKOiVYleQehOiPs2z1AaVwfRNCCaXNzfGynkz85WbHxGVUrzdqpFGvAUIrg3g0M0s8t1WDjwFGuFr4AQpHW+6Ob83B44wHKk55zJ4ggFFxIIcxbZww7GZqNikEYEsJWV4NT9omNU6t/1tEqlioN8SwwFYezLBL5D/3GTWmdYBuxonzP6sLluoqDosJ1l4Nd74mxIkSLWf1Fh7V1Pw7n3ZHaamhBbtSEVabA9qZ2zzXuMgiuvoAMZHspGbm7M3v61Oz//j/fsJcflT08/Ll/9mUnG5H25A/eSf/gaebrDwgqBrlHNHMBAUBFklWKetIFEUfi2b18tjUoAH03G4NQ3IEiVkwAWlHzTLiLvCS90clE48NtCf+WWFyepvososwono3yJk3owpEu/zS2OyxNCX2XPDTPDd8UF7LN/poxIzU/VnRTZacXpzYF3MCSpeZO47fRAZX8hoCDklptOcFeFZ6HiPXFQ5HtMqvTtmKzgwFN4nOkkAmilyo6fdb1dXwRTL/JJHRDQ7TRmum0MzEERoxfhOKg2q550/y26iYo92G1KxVLO140PKte3KPEUEg5DCWHABW2k7QHnjsbjF3NRpr0TelRJ9DJUf49ZbMlO9AgaOCP5JsaXF0ULHbOlS0ULHzBdXcOs71oC+e/sP9WNcgAOMaqQIpW2GkSlNBQF7QrrPvQ8lkLCEc5wznax8aXfcFoX0OKdIBm6iZliwCL4GIHDDOZ2DCHrVWUau3u5xifFdSf0bMO4SNELJ9OxnM3VKNfN/MgJyWIarB0Es3ZHBgJvS48AGo5RZV9NQHEP6cSQxTET/cfLCPofn+6m1PTpQlwm5QCOw5qeGdPlsKEU8tTc4Zxi6jwXoHogIwdrm9AF1Hlt/6F9Q8z2KibYhooULfGdms3chVlIfhAbz93N+48ivI04GDacskyOJOFQmta1x4+2QB+CWYLi5gjhkKEnRFjVCKUISs+rz8JjnIkdVb9bh2R0Y8gSfYcn2y8sPHFHcxWCPg6UkLkWUGjaOLe+lOwypMKeTXbjK8ZbpYpEduAV9WDHUc2WSs44hU3UH6f9965F0N7vNh0ZCUjFz3wyW8x+9mfv7Nf+KXDXnnlqb39wYv52Gdn2X/x4/+L/ejHPhk/+K99v+V7ejbwq/GDHj5t6wUTowD5V9KPhGTCueovzd8FAHZQFYhahYgKIigaEtGcii7v9TPH0BCwjIoWZa08ln6I7I1SuYx9H2Lr2CnMIQScAqNlP8Gsp0Out43J09tTtPdBwIyx43uLEWkRzfZmUxukQxGqcA+m5/ounF0Xs4Cbq27BZ18IMPcrMebZtIQWB4sfRP1en0tcB6lCQI9wc05xsxpH5fDROc9F7xTOMTy9xrAITYMtCaYdG0stJ+TjAVk8sk0CqBTU9hhKZ1lkNlTbooLDr5kd4ACL559P14ZIPxpUHeDsyiQny0lIObSceqOLmgK6Tn2KKlrG5s46kL9IUWkGJWs6LWzAYIECpCVHcXmBfVquwOqR6D6KbvML5NiJXh2CE66IL1PAYqsGtbcu6dWHs7wtnq+JTUUtuql64MPFVzLMSMZheDWKZM9cXU4wGtSMM5Yrx3hh0xVpMDtjdYPpAADee1lrWgcbWpBfrPonzHWn+gS5xq1CF8gso9fnzsf3BR46U0pTbEwD+yCt3tseapm9KA0NHLOpZAsuRNKcdc9+7Bg77yd/xeoM5re2RlmPHzuB1nVUQ0ALfKdDYe6nUscE+YyuxX8ZQmUxK1IvHnq7EE9ADolUdQ4QXD9yXsd3rJlHKz3epFmdnYWxW5dpAb/qNmDF2DhLWwD2RGpkvwEvd/oV5RzL3Lx18ehQuRY3GPd/GZUWEHVKp8ZnvmgQMvVq0BfHRLUeM0cNFHXb5csnU4Drf44uPhKcltMQOtRWTkKSqvYCiOiN9bbhVNG+gdmmpEqGMVhGXhWBEUdkFsMTKT3rCNJ59LE6bh4KxRs077m9VjLy2itmX/5y2F//W5+y9//gzr769v2tlfTzep25ml1+9N/9fvvYZ886339iYS9dX7RBj1zj4QeSvOyTVlLWDd9XUNEA2m16UCITZlhCcirfs6b8Llb97Iga9MvAecY5Dj30bZ16KdXxVLeNB6Sed4OvfiSL+BSUTwveUtlCLM5Un/NPZNeVWvZAwwsOUWy54fqTD1yoV2HsF9oiFKuQdmcBcqmoU0rkF47ooWnBBCX77DhbIE8gRUh7i1wM8BDp1fVpCIB0sAcjv9CgcYplMs/4OL/jxSk6kJl160OK6pCPFIBQ0mLoGoF/JfbcAJEKazVxsp0Mxi4tSZ0Q4KKJlLou9yY89vo7u1w6msLOTXbMpfk6eDgMgPSuUrvHwDCGBBwdPOL+BfwoTpOWA8gjtKdsC6TT5NdmJYR2/eB+gbNcSX3QOmhnjiMggJwpQhfapZj/qS0DX+DAT5HqRBfB9NgyregFcLpAB2KhY7ZP+7iNVKMnDNOAbpP13ZCNdlxl5HxsDptkc04vrqCTGe6GaSIwHw9HORr0Ct1oIKdaDhqStQx9XqSvpz4FbZ09KomRXcYsgjubMqgYp1BmD0kapH2CVWIkKja48taouza1S3IOb2HcvdFXYUki4MPoIK6gJ9A24WXUtjl46JYG8eDERYvppN2lb5bolwYRQw4NER3UKA5SsGiz/kdKzAS0R1IY52ol9Sf4jbYPp8lMi7TpwwE8NFsxRLO/propZAQ3y9Q6OT7JViM8umxKaCEDhYec8b0nFDYxix9Mqn0BpQCbdaAx1xAnb2KqEErWsRA+h5Jci2xZhuKGJNA353BmH7TYab+2NVEtMV9xTEBe5F9Cg7n2wpn35jvi/AKwijtcnX31Lbd/4y+/bR95LV/E56zXg6PszTfLfuP+i/Z7v//R8zu+49PXIj+BXh9G33xS9TJksnQ5diOYeUMPPOhZZWPplWaCysNQYmEU1DF3dBFDbQzZXqkYlYsCOegYg+hrJeUYDnSnYpVtBzUmV2ZGGJvl57izksNZuYfacUynDnlE5AeIVJXyGcRZpnbhTp3LpJJcpAm8F7bJMzYhlUQh1cN9/RFNoma3bLrI52VP3ukyAnzKw49Hm7cYLdmb2z6uGurJy9juAPvpiqC5XDJHJ8hIThMlglANJFA5zrcPGLdjGEufyxK4TU6BH0riFx1KLnKaruj7TAJNQIazp+p0+UwJayo2HTgbWem1YU3+70At7elA7VwQOQAjCBHUD859wJEFOE8xbr+SdpNIRI32VrCNDeZRofXLOCuAjVQYztcgDeUzu8cg3xm1Jhzyxco53yfFhKNnFGhCUinWekoqoxPITFDDApSaAFNnTphcA9EDep9lvVrI33FvAe64VhCPXqjDY07Y6fqKEoNoqsP7H4OrdhzTm6KqTXkpLnB8fiYj1VS7LEDuqANY00Izwjacdbyw90dZrsGrhaTMZpRh0gg5iYmgHyRatbT48bi7d5eOMCV/ddx93D/xC5RR7P1eWyNHQ1P0HVpJZNj8vupHMD5gDNUfVjYt2y4byOF6Uh3ujOBnd4gH0SZgaiRl6E6HtJYZcaJjfO2v6CfgcsY2IuClM6mEH5KyQL/McPvFpgEKCq6/PTPk/giipOADx3OGxlmmbNnatR4LSWnZzBhRYOGIe/rsj2K1Ryo5sh8P0nKoreZcdQp58eAvOcG5qpdzTdG4nmD+szf7x9958/lDI3f3952SfP6HTvuxf/MtUFbP/XPW6zjNXnrd7L+9/3P2C7/wxJ+888QePX75atlp45soWOv60Y5K60adVIGGl0AJNreNGbmmtZgUewgM2ZBTFzDAKtrNozdDotHiztmkKAEqUg8Qss6KtTrSNXu/PD0xv6pfTn3JWqfncCmDstjYUSUT18b7AokH7P/IRaFpr0Modg26UaZfAN/atYWoimieEVWdKbNqJ2VaJyrGgdpv8p9FIt2TTVtifb+lwEaghbkFkv6VKmTGGQHJemxiUBzpBn2kO/HHDfPs1tQZ5SNgKNApQI0JjmaneJybcmpkhScbfoSaMJHnQVMWTuY9rxiX0kJDfoMwEdAQLzvwOHA4JB01qjW4HcpRccKbjBdcxEFAOjjZYDhsnECAFE8JW89spIaC1t8fg7cxa0KPM+DicHQ2MijDZtQRCLn1Aak4PNjPEtndd0o3hHPbgsO9lOn1f5+rPD1BObMvEV82eSwVfNDIL3UQv4rC06gG47YampVApUG141B1cG7QdU336snH75tOUjrHleyO3a7JG+sL5dHijNZILz2pBfw5IQ3BaN7rKZ+zoZF7qmipTuZpk+xjtR/McxKCHqAbTkd6dMSnJik11pUoC6DBcRmjQCbkNPtpxXDjDT5JsyFv6itMpeHlWxHD5AQG/LODtBRty7q0ZdtrDwkOJElqywcIPO2ynW10Hw1u2UF0ie0wl0b0QLImzIEfDQ8xFFurc15FbP9oAtEIAW1dFsJmblkoy5ymx5lt/dKM35kDpzXxTuXK2UoZT2CNAeFhe7KtOSTX+mC4vL4fzT16o1fUSR9jVFIhINKBECfAM21vYZ8lIQNTKp0DHfhykuxFOSRd60RDbYERRF3nmOte3C/J4LNo1MX9URzf9y+avXQN0f3I86dO7i7r99///U/bb/7m99jd3bubpOgFvNLs/ffLfvTf+fft4Xf8RPzBW79qD19+I9i1hOxXzX9tsUxjB9pmQpBfc8yYQr4qH1o/FEQmFEOxZjybgb/IS+NQCZ16tllBMK70oqyg/I3LQlZ8FxqGASQkRDvG9TxfNIYzy1FNuWJ5dKagdKZx2Lbpa61mUrbeltHV5uP4E4yCwQYSXYQgfJGQ0eW1FH0kga40QSIFPISOSScq9YPGblDWOlomDAX02vMUdxdYrXtYw14bwJpbE6QIF0hvM+fWOcKpLWHyD/xj+tZg47yeZSbFhX0nrlTq2MaSC8DluwBE7VZWlNIaDdC7PliJ1Zx9xTabthTr7iSOgu1MMdTrAFo6ASAU7ch8lg+YYPbtW/cVNmR+WRsdIZkbWSr5x4nFIhw9NkpQLpea1eEglpLUCmSzohLXVl8PCjk0ui9zve08QZu6Q5nAr7RwQKga+mBb63/53dZJlhE8R2hE3yhVEUwncUFoX2s8gDmc7A5fXrpYDaIS+v6l42aE0yOj1Qh9r+j+zV7vadrRhEn2jnS5e+huORofmDlFxCyXvWZ2mEcZpUX8iWCmxEMdJdA2pLORjDY56xNW86ACPJyxB3TBswe+v6oL1+piXzFa+lxdaeZxZKgRQqU3IDliCGsK2vKIC9znZIGAhji8BcqWAh7XybkXtxeSkN5pE4tL0nE+AEMOG2ibY6dzvzuR1ja5hfoI6DIn4AefXyee0FPxHdC5ZWgKaL3VBRpeLgDGtprr7w93tuqyKryWHOZ5QfrM3JziaiRXzpjU+y5xcGCPL30rlfal7NSG0OPiQdsU7p/Z3lzaT5ogp/hjQGIaWMM0hDtaS54nBiwXyMuIsKkg90Uv4OsB3HcJ0lnt3fX5775r+a2ve/71/+y0d3/H7Dye3CS4z+N1d13Lf/3j321f/M3P2quvvvcCM5FrNs1pH7zz1F6pL5r/pXfswSt3FAcfLUqOEuNqxhrcQzaQNypssuOajMECAbkzgzWaUFeHfpL+caksihzf9ZMnWmvVPrjGrozEpDYY2gNDapAX5PAUQHmZN5QLnmszv94zEa73o3lOZTTxfZTkI96DlEqgXddRsiHHVBoq7cwHGgL7EiiVeKugE3Mt721ieBcO/Gc1Lud2w4kBBuNo41ddauXqcOdgfw+yZJo3MuAQkyeohJhsFdmsDHT4cj8Wt2rfaffxHyMn2suDZELxDHQYsNN3ifCX0Z2Q09RGtINJInvtoJmFdMBWL5ZAUba/cLLWQohCzlYK3CasqsGWUx5OAPmEfESlgs16Nh0eZRo746nxU4B+RfvNQmFNv9NVxSFfFovTZoufY35Hd7DjpIQTP8W8OPxTMwyGrIPcCdMISFZ10jbQC/Dqvo5wJLHIDg8kcJM5ztTBfvoQaqn1ALTs6MrwQnrZp82ShsY22c3xbK8adl3/AaCSfQ1pRCDp18pP58uZ6NL9QT/h96seqYkMzMPK5PWyCxM8984MdnrQU790hungcmaihN/V8G703pkJUUxbsGNw25aXAd0PKgSUsoGv5ipIdIwOijRp6UCVsNcxVZRlN6yAgwg1RjRjiicJsQDrEQYlUx7oHWhn6ba4cZAmSf1o8VNovcPOqWzlMcavO7m7TmLJI5XuT6eLgaCtqDGgAj1sg4igqUcGeH2B9jAyDSPT5xnmQvd5BnLxs3YaiThBkNGy9fkTpIIHBy76JgnJL3gcn9eEsxOxn/ML+QS92+TLu3umAk8wW6gf9vglzyfvV/3Nv3nYr/8Ts5deffhNZgF/9OvuV37j8/bRz/6QffbPfMXMX3vuH7C/ro3x3ttP7Dv/5c/Yb73yqM4PTvOHcqi2UEHJhUXLW+3lQhNikxTGUsTRlV7tGqkDyukchdO7RIiyj7+DW1GsvcKdCh+HCwSGrLkayMI4LYyjStum7kbTh3y2k5arFGWxZ0TTbSdP+4X5cUgrItXfZzxU0ccZ+GDq7xo2hIXNlD+9AU91DpEOnJvMIOak0ruqQZJ/8s2zxV0B/UhutS4zA9Grm8kTrBQ1+kPth1vzx35DJiqvHnuk/kmqqFxXj4bEgIM+ZTSSP7ZIhZbeXhARLHh2fYksymBE/K87zmQFCyvsJieRthePeRs/T5+J0mwy9MO1+1pMJQAAIABJREFUCUkH3CgZHkkOOwx0L8lYvRAouuht40QPtzUWkmbCYnMz7+y1kZw2XWKAXI2wGoJxqSBRjzld3fj91+07l9tAImk9jKlBX4NgfUmoqdYYMXB3X65z52y0+CrIU0thncInen2gzCnJAEkochcQCaX43zakkbF5riCJPvZ83Rawt5Rdfnxms37R8dCXdeBPipdBgTwxcj10+XhMKcD1o4Lj5rbyJvP+rbJjKlhA/9og7OCe0RM80ECjJS4ulHCzGRiqxl5h03DmfFj4l8ZLR07VsxjyIqpY7ajC4VLsRsfm29CgNMczZlmTiOrckjwBFba3iBnZg8WyDMmGT2x/pdokf0yJSDAaqwKe2pSGQ0mcCkGpH+NSKQnT2PxK6T48NqWjkdQ64NjYaCYM+zs5yyIMZr4zJk5pou9BmkAaHlNgI9Jj3mpr2RCTgwuv2RXcIBLxJsactyqo4eu4/ZXUakNBtoZpVF7tT8fd+ryHD8zO+zx/4n8w+70vGYPAc33d/YPf+bg9+q5fsffjfndzfiGv6w68/+ZT++k3ftpeqd+NR+dL7dZ+iVi97nrAVeUa4uvLhdFzqbiTPQB9YmbCcIeeG8tbKCYM87GCIqSsAVo5PO3uKmxXbBZuai+AJmP57h1FfrlLVnoFnFhArfUMt1Jg7K3fXR9XlxC7CmWPEith73158I8ojupsNxPfb8n1YyU1a7edkD9SIRMEF1QsIj4Ga7Da+nSY1DSA3fIQ57r0GbVqVCj2mXZhqqdP8YD0YMXjxIA1js3Knu+7Dt7srpiKmTeR6GvurgWIY9pn1TSgqM8OZWPRjUPwmdKmbfO17rAJCvnlodlVMwHOQCXAiRfLJIFdA0GVCVAyyFcoJWMh2BBC4rc8exQysqZEKTWzpjF/JwmAAo7rCr2ScJcGY2HhdUrZLnodm3tkM8mAhUEVE94CNxE4UmoIy9UFAfPAvo3lqrPmrE8ZcNykhk4UGoLgnq6N+FZQzRi4yU2qtZC61aTV2qrrfzA9OEhyEqqDFPxsLhEMWcKfqVmh7LMVrcpoNGsyMZk9iV1b2/hcK+Vc0JqxjReWQJJK9LmZlIKwlF4ql2bBkkJehyc0XGUhJkZPCqt/H8RJ9sxtQ8Y0W7g7Gs6S5comKUfi30RtpGv8dz/bZq4hmaSZXBjNzrDC+rLPmSRDoSIytzRiJp7wC0Yhv+4hjWrhGlisIAZG3RruaI/A/Y/ZLJi3vCoanIBAK5OcSlvBo53EaRSHFF0pLh5B7KNwE7a5LtRvGXBQ6WlAHJJZUhodkwB2aYB7D+1b2Is5CzRu/OKObFo0On9GVsjEUsmgk5CT9L7Xct/96La2HjBxsbLF+OwwIQpNJmSfDvbnwozCN8UdJzauhZ/MJDXim4ln0Q6hqDNui7QruTz6/DxYeAc9+q1J7HK758PIzKPtBaM+8YlORl59fQro5/W6+/LP/4ZF3H94TM0Lez37oOzLX/wt+1d+7HH80I/8S5YnhmWgZz41ZA6+DVvjhTjSYt8nZRSArDH1hwjhliMGGyi3g5Z9hkwenFh/ZxgNR4bkXWcL9l1uUOor67SzG37Y2d3uJBy3wObF4iohk8hiYK4LRXIArhxJ7vTm8a2WDSzhANYY7LXf1ft0XIo97pWqs87tpX9iDcMjkj5CPRZMlUpRj2ucxU+8RRUPlWCBwUvc4QRLyEQ4AUmWiSvUT8tfT9IZ7xAnGcddBCUdipvNOpU9CgwrVNdNQeeqU7edjO8ZqjsoIzE8UQ84Zbp+e9T2FOSwt4CwqGROwdsvQaRvnwzQlqiC2CZgPhvWoBrwwsm4PijnSH4wRKvTA0k9AQhJ4wyBcWzCGEE8i6VoMRGomtgyL3ZJoE2ETTroC2c+LS5Q+A3HeVgw30vbUiKAmxQcqLBU/TfVE0Ef/ZsvX8L+neDVAcxRxx6BiiF4caehbx0SlYhSRx2CYTf3QvnEYAjaDzashpAVTsQzBpyVlWHZhs7oedGdd28ExD2I5Aqc7GzvxYUPcCIXpBCUC79GEu2CKzaay2KelbPzY25CQ9Nz87Wp0NYT/OcRClFwpv8CnQFcDvoPTudkSMM3Xud20n6I0CJZB61iYl8Oop3kJFCl2vcn9S66mJVeQH/kGvrSJwS+4ZxMFuSiGDt85ODW4hhJNdYNS5lObQAnThpnqjOPYcOPbNZu0dFOZTq7gyA8K25z2reAM19nVVCTZjwXuvxBHX0ppa5i8kyLuxXD6xqU9wJfd/ULzxqdwH+/yNeVkD57/7S/+CM/ZJ989I4/qaf2Uj687AwOosf77NNg3yp71qTwGa0iG1cYmVe1xNu8gaJonGETom3Pegs+CRf4aCW2w4WCgcXA3FGsBa42FT7PTawR0gnRGcRz2qa7zOX8bSxiHrC+ZgKtFXSAHi20taglD3ssUJiVeoecsIc8nmTnu4k1ytWLKa6nZnqJndvINgNR0QARj0XXOrZmSpbBPEchqPk92EAAMIFM2ZSCPgfBfBgPF9HjpaCOoAlWCaGCMkfr4TJNah9soKOPp2S+JqcAFXrjKtDoTd+KI2CIIHWp0tDOKBtpQ9KZYynHnBYJb2LtDg1VW0ulEH4kd1DT83mlmsbUMGgohdvHb2YLyfmejp5wzmQiOMD3HI9k1Uy+g2lUPjC5zaKIDng6u0GwidLp897XlN5iQawVAHdnR/1V9qb7uVbwYtlOT1pe6/pvGIaU+HoIPsZQqpaJNh+dSyfH9DI/q5z7g4W9j79nbdjr2WA5oiMaaEq50gJm0wFMPU/s9fZmYKxHiaGY5EL0cX9c7hDTPQcwz1AJp/LHmrTM4Auy+jchZJJ2XYnglCVe4heKLo/I1ia3YdLp2+WjZUltWdx6HN0S6EJMNYMkLZr0yUiOtX/6og4kx2RKQmYwCGfxodxR8UfMoHGVbDwGgnrMepIafivFYDnKYDRkLdnsGT1YcBXDhiHfqTHlyWxq03yBpVPhtrJ61oYU9cN7rHVMAC0hOHFCYJSAn23OzGFCDfW0SF+SPMwQa8GYk3AUwuRbADhxpjlVK7D1a1apW4IC79Mnw/3oTF7A686+64XnIHpdN+/B+cB+8f1ftId/8FJ9290nLM8oWLpwH7QnI2sh7EujrkOBZTR4k++2rzQLjlGC0Cpsz2fCWEaz2nbbF6vCvu3xe4coF9AZU0CETsqYOmxlqKEghKh348TeWX8Ja6GXBT9aDvZ6f1P+bpPLmLovAu0d6NqVNrVE62Aj5LzPlqWIsFYAZW2+BUIBnbB/4h+itZKDhbZMbtvEI5PpIBHIEdAcJB2gUkAreYXqMqcgHbTDeg9tKZ8MmVAQkQqeOlkUvL4vk7ytUlJcChy2GVoZulVTuu9VkmG2osBHn2hqAqZNQV7XL8jYt/tXEiqaojIGn7hQNOXXTWwloWTWSoSviUbNQa7GSapsEz2rag0caBoFJhI3/PABhxdMQaF33pwq27moarLEjaHbh+sKYuopRYlEUVdbG0LHAE8b/9rKe9//mS3k3OdVFNwo3bOan2E54yoccBSx3zMZprg6U/tk5B2uRFxrY32h1PMUtOBzOAs0ESHL5xiGntb1+wf8dbTVFu4yDvVK1LqHTmCwK/bgEx0DZHLi7obCGNuUiwMYNE3BN0ALAiUUZtlmzvTrv7F4Kkp1fIuPpoSJprQzTxPXu2NzXMu2kRV8SjVfe4PWeN1wP2VvAge1GCdoAAViSuMTF6mQHgTD9Klm2/RD7SsiM/2niWt2roPtZ+hbrISQiB168wOpnVGKA0q2kyfGLumOVeQMWjq9cJ3D1TbKx6nxXo6XbcYCYbTcuF/M6+6NL7zxIt//a15P3rm3T37+Y/bqpz+oJ28+sYcvP5rTEDbBB25Sil/WbEcDX6sDGE2yEHNJmbEhjBMk+IM9BPLi+xtEPbpbXMokVeYIngryjEVSUbLQ5vtPd0lXutntJDszrFMcDgIeYlZ4SLP6qVmrzoOBgflY3YeYxQTQEd6wRs0v7IKTM7fpq9PBAF5XdA/l4mfSxClgOpBNll1uswnYhqQfwp04kHmbz/33Gkrq4HTtFVdFom9RqkNoi0ZG2SowfgL4XkhNwNzE+2gr0Hfk9a+/boPLVsULZGvbwgxqTIEcJUkUo4lBu4AFY2nso03752JqTM3vUvxis+Qc4LwN9M/s83HuX7/t0c9nJTkIQmwXuFUHTTZ7Rg+SD6ZiTER8gjcSQjTwIGbTh9u247x0IHN/8P5z/TqRNgX3UVti8lD/fKTJHjiJfpGwIaSFRF3UxxJirVoihC6ibRxUKvpTkXri/t8gckwoCkazNtXspdFpiIK+xJJujtlOjZ+d/rRt9jny49yOS/hqoqmLJQRWMAPLGexyn9i1JW88sA2JXDCPxWOho0CAZSsaAiAIEvXb350V3SRDTnvDnQh0Chb4Ya4DkWhaW8egJY7xp98tIBmR8eEUJA493A06IqRhpj7a5D64ZdSMcDsOB8xSVJ+0FZqCangNvYHQMRWi6QNIwQ0Zo7Okf+ZkbkUtmIoWWXdyIMCK8kO0GxASM5r1KIBuHF9x2TLwrnXU5CNR9svWVbZWeh6K2JMXUU9tY8UK9+4GLfe7xrr4GhcRB2Vjl+3ONu3++b/u6u0XmuzcvC766f6te/uzn/+z9rH8LX/25af26HGGkAozTSXCSickxQyc497347sPgcKEjgPPstjS5rT3ZdlpbEDEsHeRF0XkhUz5Cu/0kiogZjRS3oJEpwHGglKmwxaTwLB4jOIx2GGu9s9n4rMtf1hyMPyv5BRJidMZlgt1Y855eBQ9l5ZrU8nLwKDHizXptJqasqIKB98Nu2Smc3XgUSW4s/TbxpdmhA0USsqRxN9I0p3/yF2wZgDURoL11lgyZoZ9Bme0sakw53wKjb7QrfDZaRucbTQElStef+8cCoLa177Ybl6G7JTfAjB7JszLpqITrUDvJ+O6Jm1eoBWbb9NsQFJoO2g1EL6qpXFzmC0xlTqLTIp4A8r6tKzRNs4K5JMk4wfKxht8WQqlYN2oryI2XTJRsN4ta3QwduhkhSHoLrljWpmlqE4DqR4h4UHDYVxeYc3eeAcPqilVcClXkA84EysS/52OcBPZjEv1TU+WEEq2SmukYv1lMz702XyvkZR1G4m+cBGBNw4qsn3P22QYLIpYkUxfjhHdm0LMOFUXVT/IXWC2XcXjPm5yG6yTQLjNWQ04y+oYRFYjanesCQ0z3HJcQR0HgGTVnHZO8Lpmpa+IfILuwxsEdWac9clDNGexE5EtNjuqFHBdJRGEykE2l/r3Wplr2M7GV0u8saErQi5gJ8KnivnInVRFc/iMaWud5Ww+Pl+ub1XQG6KGZJ2surZ1H3N8Yp4TSAjPcKCriincgamYMf/Adu2e4Buf1dbD0RE5ltivOK3Gs+7tBb7u/p+/97sv8v1vXvfPTrt/P+3P//DhH/+Lh929ZJJRQt10IpU/wGX2mjHSneUaj1XwsgsNBmPbPipEMg5ckK5ubKbE1C3ZdBQ7zRLG3PUcqVnPnLZ5wFy4mMK+fnvTJbCIZgBIAmOblMM3qA/qus589/fn5tBIgYH2tSWrDgwL1AnWgQNQSGdRi04fQyfaGBmndOjr8fzuYazwm0ZuH1yqvEJXm7WbEI/FN9b+B7gwdgHLGIzfFW7OKX0IlLzYNIdiZEG4T5g74Ao6rXo4wqaw0eaum2r/RsTqO60TCmJIJJYqeenqNcNO02qV6HrUwB3rrw599+kXxY06DuLRHThjvvbcMPZKSqXgTn//2Cpa5bdTsZrT2WPc8dcajFCFNAlNoclIOMYmCA0hPPrE2//pWA1vY0ZYoVXSTnVqzEn/8iHBWJLgFuFk/i3D8GaKxg+HwZxbbfXKZQ+4AVWrClECF/a3q3lLXD8/K4fEo3Hc9ijwfYsdLtRN8QFjIAppiGeY5oqFQ6F+beuR79cCBjaHBM0ByH8g++BpKuRUBzfDxnqip97Pa48F1UOzhvIFZSkluXntKAk1TpvW10g1Ob28aooQprCrYGGllE2d63Xrjk9TjPasy4bliFySvuFEpJr30IBHdL4sbDP2RgYOnREnAXM3aLPQOkUg2oSWzVe9Klv222xZsGonekIwx4012OzU+xEyDbqcDchnue0wJ9OsEgCHhje+xnZrx3cfsAb2T/Tvu+XxZ26BzKk2eHErI2FtkGgj9+ykxVnAH+jOu/c4XyR0cfcD3/PPXuDb377WXnhW9ub//N/X77z2sfz4j/yFho8b7YaNjQNw3qt+7r/tXvNZqqybOp3+4sx0mtY5fWyEij/HnSe0oOkF1lsx1AdVyntHC3UlAPj6wg6iGLeQi5kOVsLwm/DB5lu1yIut3w7eRTVI9sLddfYtN6JSiaI4FPpy2LIR45CO4D3l2yA6kEoQ+uO0sCi16xAS7KwEYtDRyU6ZnqikOL/V9msPxElN1VNyr3SJDmXM1Xy7Lmxq1GgSFlMfolTJ5ciL7hLClFvnw6YbxLzjTpIiVbl3ARQb7BZOjQfRl751PR3+Emjah1A8np615cmkomhCM2eVTA/65wOiRGf7tsLn5McsQCGII76ydESEt2/W3YEDZrRTCsg3AhEmdr7JCT5EPqLG4lBHmzwS8t5OtA5u63MSDUd3aGB+zXzIfgxg/RghqQAITsfz4hTSmyDByyeOtZ1p8/4+7rVjl6+wMMgPbwvRCI4OMeq1h766gvuVnhxG7klxDaOjouf+BTLJoAEcvygOM2lgXAWM7k6F7n/Nn8565vPf3cp5Q+Ugh8rCZuP1w8P+5D1jcYK716iAuyZK7RAPsvdpvWVOyFTft2SXQ5B2EoUfaHqGBownfZKbQYwIg04TUohgn2cWREja4lpBA/1H23B+zaiRJu322kwiq35/lGPFqcXzoRK7KlrjLNj1MDeptYsfnkMKK1q5M7NU1ZlMf7ibjCBS8HbpbXwKUR6HARKzlMSsHuyEu+b1C3cRW4vm83/d/Uf/4Zsv7M2/5oV9d3//tv0f6fHOuw/stUeKUYHh+X4m61eEZC7IfZcReuNCFZfPdRPaoqwO1iNAAFqN31lbFryLumQzSqAXAQELg+5QDG1bsCLbraSCbN0WGCAW6fVBjt0MblcBiwDqNvp1GEV9MhjU9+4JCqo+xfRyT/TFB/vIweeHvguofQ6XGNRFhWGiOtmSMXNpy3QOMtfHDR/hLAavMEFg54gzmRuMO2F9aIQGedwKzWm9TE8I1BjPoTd02EOHFwUO/3YT7Vli2SBWfc+Ltro6ZPiMMX9cLeebB7jEpcYBYhTscYVTUMtL4XfaqSz7kDDbRnC7E3hEHJCicgoIElgcAbmdtPv6o2UtFfbGbGwS9YmnELDRljP5Vhs6wtLOYCPWRDykT6l7Yzb2t4ZvJulVjIuoTg6ff7QdSeOqxJ6fWSj8vTY3YYK8vHCKuoMtAKskduYOQ7NgbSfaLB2V6tIK91TCoU1mGnu/5T2eNTUCTDCOTexMQug2frl81ZFSZ6N+/Yj1HKeDf1CW6TbTNuOTVNdpqVIv8ae1UdOTWKuwq/0eMR7XtmFG61U7Z+qmhK6nkTMq7vO2WMBAuilBphLUla/u4lMdurV99Jawy7jYZi3zmgsCQ6uholn9SI7upSQV85YQsxt54LSrQP1TXH+idyioBrW0KF/2+W/AKLLHFtHiTMGemkilRBrnwxZlb5410A0Wk3uUYCYG2/2dnmPRuDp5fAvYjECxRo0d94VRTXQAfEGvu3/4U8/fSe3rva6D5K13044feGif+b77pWC7VGhRy6KmThxS61DlnJLlSr2BZaizJEV0jCbTneKUSWLQvdWSWhGHWI4YGzaKDh4AzkQZLinAYXSPcc6euEC56iBKKyke9kbTUbWgOyakR9GrmdC+lGLIfmZszdhl3CICzKpK09Xwc9STCOzj/LCOzOIaGTCCIa+Pu2lPaxt2cpprsXIOmpFZIO8/bdJjkMkksW6gbPHda652Gdv9KBoplS4d3GBvZgS6SD8URVjbobVeCiJb1rmBZ8Wpeyp6VcDoPtceXGfb0sKp/zWYiAT/ueScAfukBSUnxHtOQ+79/iM5P3Bclfu2/gBa9b1pS6uhmzFobsS1NZHMfd4fysNJmgz0Jg4hJLzFco9uc1HTmhptb79YmsWjQqiIrIftOtByhUS4ur2+H8CufUaGS5/OxiJW7EwI8G484sqm20xJML+a0RGXKTl2IDLwSgoMGfRd6qGem1bbAcbiw9FShLWzbvAByzA5MMO63GEiyJ1ydbm4mlVL5xwaKMH0YcK1D6Q/IkYeOlEzBpQlBzjrK4T2iiAyuWtj0RmacJBo0z60WIUYDM3wo/Zth40oH8JNwTUkuAOn9d7uL2usc3xLYliE7UlaL9c1GcY1lxq6LAHWNYaitRVyNksHV1RIVLZ2HUZ/XjcO7KGYlKZzosvmxuyTcyv0UqiN+Np7ndOafJCscwVOp7q1PbRuiuvEWaQBBlvh08WUFDHIx2f9DpU9CQr78Opr1k/NHuc4pAGpJm+c8oeYfMb1f6fdLXS8zlfeeqvv6zsvAMO4+8LnX7y/yP66DrV4aPZzFfXB+2avPi7KpErGqNnOxls2PN4eIz1WHn0NWGtPg5jCsrB7jxn+TdFjaryFKjSchtjkDQEDMU2npKAoKME0iAzyuanLnOc7cKhswMqLfs6EKFR/HgPuoN2sbjUMvUMJLnYPpagg53CU1kpEBRQsLGlXKpI4HWKqFp69zpjb4pYxmEAFnYTACTkWAwHstGf8NKpSZuj602ErOgNsARmCPb2hGR4UAMiKOXxQJ+EbDbGqwIA4fEuCEjqbS55xbtW+IS52skrJZf+xS5wBFJgUxkjC9iQHpqdDTGC0hUr6/oM139VbhLxwl82nktK8vr4gV8TpM6UgA7dZS4cen3PmjVF079ApSUaY3TO1IydTW71lFGuNgZSSO9nQuM5wnVBFq8EaFJJHAI9CbeRNPOyu+p4cfN/TzXuH8/ngRSnkygSeKYqXyRqQLR01Iu+txCQAZTQAQwAeyTJWeBRsQVV17rqqzTW9VTzdST8WefAnaxdVAuAaYyHx8Zx1FRL6wsC78Fwx47g3GSRMbAHHm5BwSa6IQlrG0SuElaZgwheBd8UMfUMV3/Q5+q1zLEfh00fGSTYa6Fc1Xjh98ZVR7R5vFGtMjVm+/cCMYmQM3RBKHq3JlM8Z2ulVa/DcJrzDGq1XJegieNm4RidTawLeWHcD5mmGCZs7kktgoq8jqEtniJMkFhodDG4lNcJ9whU4ahTeEjb0nVxqLAen/5unQ0niwKOsRZSO0I2DjnP8fBNcGdyGO25li9dWyrpaxg+zZ7kYxfzct5Y9e9vsldeHOnter7u/99+82Hk0N6/r/j27vJ/fs2/5q5af+XNhbBe6TtmjR0XMYc6tWiZIXjAb1DYBEDUJLQhzdMze4gHEPnXk4hRF8bBATgwFQkF3zJqsYALmokG4Y7VqR4AAGHYrOVXRTUovo6FGIrIwhwqy7+mTAHSM/U3gYGgfLsf+A3H+W12TPZRjzSVVH9kSVu7XquxPxTb/t+MwLRUpAgwexL3Ri31HG3zDwLFFkH7lCnI067TO9CFq38QG5L8b6Gh7CPhLFvyZ+zJTXTukSXaPGaNp1gRCDp934K3QBglWkdKIyhtMyIKaHoWsbVoXwU39McX6m1HSaFNaOIxCaIC1jkj1ipP82+QdBb2CSYZCnCVQ1eaa6tLcdclNgHkd+4rTp1Ca9B4KKazfHsp2MGiNcbmH6fzMcb4qiI4DHRDwmKGZpHYcIfiuHLffh/5UlTo1kQ2V6VycWR7Gtbm3KGnZrd4wHmjD86z7g+KA+SUq4vVMGlxUAdEGnDdaJsSEwAAKZM3riyWzPjFiOBZPSFGdrh9tEbZcbjkLZ0vLDXNzjxkb2Os/On7EGr1Y8KdneITt+uw05haqwWt6akYDC5CvVy7cHJUawrm/OPeRKiFl7Dex4/rhI4ToukxJt+/XGMCJXTnaNEhZnNoifqeNo0NFjzMEx3sCpRO1ugVE/CYA0L0HphT1bdOu4F+Vw21RrJufSizuNmIVcjj6BJsmQQuWsu7GZUIy5nfsEJKQ3geNUt7o8+dFatD23aTm8xqSEf0BHY0D7alXfD3kYi2MWojL6lSNwIDSJAodmd3B/NbbZp/9jD37z/9W2lv/9MpSPrg5zZ7H6+6nfurx833Hr/O6tuDT99L+0o9+u73xkVfrPp+a14PO6YJzKUARIjVjATYaHLne9cPHsOrquSqcgV5bVjvnLPZRjKaer/IN4SbhjUV/YvwuI3GvsClLVhwpQPc9MpPXiq0YHNlnuKitOpfohP9ec9ZgjHvPaB/ZfnO+/EE0AByAWpFDYcSlI7OJgx20GyKDwIFdn9jqgzx0UEkhEsL/B7FinOifRKXPkN9I15rPIQmE0jjbXJOshg+HOVJDmhilTbv/TXPR1apjxRDEKBj4LuncmmCSgThaJTSgUzomt22tpTx15vBxwyYGD7ntbfaDHHDcvtOttyuorrQPw+S9WpakaLzBKGOneWs/LRc5Qum0d729qdXIK1PHQ5ggbCoxyuBPjmzk2bJFa6o1kN954aTEpHFXfbeaFMDMuJ443aEwom9rbdFtqVkhk1KhFnZj03mPEEn2QXGkz/rH7ARrTTlXh1Cn8T1fJLD0ckw78eE+QdpU8XuM84mGuADW8Zj0da3H4uyzgloA3y8501Rt8piM1/m1uFpoG2kEQOMC7jCjoy2usikb5SeQigZnDzmJh7ShzPiEHOuVO1QF3FVRV2OUwZMMWlXKxKonum11Gp2BCTWBz/HtAbCbGFMImdcNZUAatnuFux3R5L6KZ2iYO9d4CtQyG13HUgSSjNFpmf7emSuIsJ8ISxIG6ehGgzD1WINIku5L5nIiRlixwkxqmtLrrdXwA0QX7x2b1JnpWweVHqviAAAgAElEQVSaVXltw7g3qEeEWYejbuPgyG8j777OAZoPZN+WOtahw/GEIMz6QV6E6UkXhmCKvzv58fH2VzzkzoVnGZjB0+PH7OWXK58+rfov/6uwL/6S2aNXXsDU3k995jmnN1/ndX+fazbNj/1b32H3n3vi7737xO5efrwoVBwwNYCegkuX3Bgc5Ap0RrBzE4Yoziw9B0Vz7GKprYoS/25Ev1z5YmvU4bl3Ldkj1rC7klLNKBjy7Sw0RpI+RBJatJ6r0sXI6bZXd6T1GF3gnWdk9kXiLLrBBx7c4BbSLlhvoyssjEdoRO+o8cewDYHg1SCgCvCtrUqgnGXQjTVr2lTMKDmR41Z3HiCTNFI4t06ToxB2VunT9homwZlGx3C+iqnuKNYiPU5NN6QxF1dblanPpWjEujMHoWaCOe6l9mphCLMpfgPgJlY6CGKjSSCadZ3PzR/gnIUz+tYFQONxrK8dDunn51RNIFMVZtSytEBWtKcECLhCZFh/4gEkArCSni0QbZ7riuygwAxGPxyglBLxjE9L8GuEJuJMDht81kpvablLQa9qeie05Jx6KpYEsVJ8lNacoOxivjQ1t2bUywkY6d1BkmPOm9zX6YCMEnJeqNpI5K2TJpY424fN4Xar05LZ0b4VblSaOszmHEEsy+aLO8fUlnSxxd0108VIkjMpoRoAtyS5dFXcEx9vRqMkggy6HMXUGqc7weJiF9FPWw7NA7CiFdS4i5skPgRNsNgicpwu0zXerWuDn1gPB0PBZtx/W96J+t0KqZGvThq9Lw4Jso15SnFcKxE7xjegQFu1pc26BMi9OQ+bUmOwHC5XDOUBrSb3frZCoDag1sbVrF4mCpOlJr8Kky4MUI0GP7Z4hOcM4Z9mCIK9H9fv1YdnLz1yf/I0zr/zd8O++tu2zNuf9+vunWfP/T3/yNf9vdv9M7df+urhn3ga/vgRPNxV7Rk8oH1CxTxAnsB9Uk6+qppZLfMwI4AwGjDAyLkvjHVWTJNh3DZMB+iHRk69YdTOI4scHIIpZzNDxmSc1irwI+fIxLcMmgAIbF9jdS7x/MbGQq3CKbxICIpyyQkvEqBh+pwKJc2lOHc/44T0DsdZH7xoO+koSiOK/Uhj2cVRrc7NzyLYNeIJ6HyzQk5H74pWqelg/Vrb93QpYWoung+YNt70xkqCPEUMBVb3tWZ1lAIDYx/MNrLN5bnTcTQlFQk7oLA1CRdxcbTu8gB1rSWK9BfSEtQZwfiJoO76wThNELOur7qTyHS924j1qPnX2RFGNxUNmC+duDazSYy0vSeiTbho7A3QcEh1dSjxburYQhCHeKRcJyhQJz6I/qOa1NhGBiDpAVdJIsryTrf/a9CVtekT1qDXLTrRVi2S0ChaPHsWrG/OrUm+q4wZfCUPsHEV5tbexp9yYJySBBKYSYJBEwbWsjkbrU8NDUncH+kH5sCviP3e9BKuJFcpB3deBJaZxLH9dIKlNPUsjCk9Iadw2AiAdJY0Ku1xU5h4bPVCcZ7umqgG2oQa9f5xILGdyPUM8ij6n0yyAwiwztbgNBJXWm9IdC4mlcXFhzAj2E+2ZBcFxa5RLdjTh8a4o7hHeaUUaJhHyg+3YeKgKJFf6HAhadpAXtcZxBWH64JGET58SCOZ+3GJFZ1N2NwAFoel9zzaHo02GoD+6xazZLsOBLuPODgRH9tPcIOzGFx85hRwTVC9BRyWW7fakKoaFl2K/Lq3vHN/9qlvqZWMvPqRKeyf1+suzhdqqnbzeojOlX/wd/63+sLLn8rP/5XPWN0TvQWGmR2iOS7c27IR7LdM+4qF6EqOuxqPzhW6FC9J8iEcDeQJaIxvA3C3yVXWULzFqiu3JuomoLYljEU5CJPSVnKz0GLdI2HomCxiZsxKh5ZgAR+JHXVIvEmptxulYlw7qUMBuAJgeShlihRtN03EIbk8SfhrOQcQuoXZOL/G1DWbtapKWyzrBMyiPS7gwthtay0pSBAiSPrX5a4MJnvYMPkQlaPXVm6Le8vm2zDYmhV/37lOcZo7UNXK8UZYKQmXAeaWgq60PRnypqDwZFdWOrFd6GzN1Gmj6TcMEs5mGMfc5m5vWCMGKGYUtMQOxyLwAvHryhw241JxKJj6H7OAwMGYBMgtwFs/kelEC+B3Rkmgs2lOQy2KFpKm4ITjho4DPguCLShQBmoSEZqH22p1elHUGERnnzlzz9XE33PRSdng0O24H0y6M4uT7qxnerdGFMcZelvYwt75jEQPSCzQzME5EOzU8GaIms3bqnhlnUlHrBG18hsvlKByqwPMZi4OLs6W+9WoYJDb5zTG9bXz6W/iGupVu0JOrAY0AmMpa3kKEJ15Rp30Fn2e8UQa20sYSOjIIaw88I1qwN6jzt3ibONQiHDqcouneXCq55UuWrdX8UQOKDdIEcUMWOdoG+WKTTFTINq3MJRyW9lITrApOjnxpfC3lshd/EvAu5cWuZchnFEITJWnDJqSpu7AfoK7FwcRUnODJtmobTS6XHdjGe8q83x3dEpN78ICTITHC4MAYF1btOG8MzaTHuoKYvRtB6fWs3fSyvuDIO3YPhyoNzhdeGgq7eZzBOMo7CQAmhcLHRh8Yxsa+Rxfd68+egHv+ke8rjj65N7sh//CR+0zH3/k73/wzF6KB5QlBMxZstS7yTHzEktS0IADB3UjwxpaRnFrt3g6ZDMpuOQSg/TnMjnJ4Wu9fZGZaFfB6BUNKUgliRiQEvHYM/ssmhuLZjCcUE0r9KirmVIqM3bK94jUr6gGQSKLrcwUVMoPUegp4heITcF120qDw5TYDRGCe5UdZbpFkfbBKp3RaKIUHszZZmGkjphiHqdmYaG3aEz01c5tmuVZmPHX0gErAZtoeKkkel06QhFHyqaiFK7Pn3KUUpd4ZTO2TaFYki0XS3NwMCgFG4t2wmXInRPlKAG8Mb6ubuOa8g5LVeBnO6M5esj6HhxAfGqmg/ZvQ9XNwgbVUDJI1TS4tFSO8ouZcifDG7BV3jl3uuIZxsIPeddP9OwOMkom6GsCEGbrw9ooDV7giBW1BUnaFFaab50Q2B9aOTjfsgfJFexmW4LdDARPQ5E+3mqSiQtA1y7xcsBzTOKwngDWm+RKXQ8Qo4sDSU3Rx2GjvBn7hevFdrmw7kHP8/fwc/ln4vRz61kVDW1KEqQI5ZLt8oyXHDLUWpgc2bM2KQz5el4JJZSb/Fe71BQXpKADyjBWL6zUhUtvQ9IGO3Guq/XpLlmns82nOl9fSh+Qr7xDFRRZYB9B/Orr8ba6hA9fvb0gIcR55/g45IZ9BUu0zXUVz7FtXVde6NlqLmffi27N4YJDGyctNiGBphbKx0KB8drInuQEgl4GBewXpGdfIpNwMu3VzzebWSO44UW/QFygQgI6/7KdJk/Voay3mrysYsHSCcqBceLwrh/aqvjcg9wmtCR+f8m5cg0L7pix+Va+kNfd0/t8ke9/8wKaab/4y39gD79w5597fFg+cY7ezA7D3n42PRcf2DgCX806XOEJeXbRMtOIFfPVUVnzzSglWJ1LbYrdhmHdcrJiVBehBe5G2s2SDzXaBUqD29WxsHQU15CxQJ7NRJprqTbjDW5sEYG9hErURCnKt9ylfDjZ1BZFeaN6eGbJFZIPm/N1JNjGLbr+7EghTuIBkh7N+Hz0f6y7ch90QhYK282NNHLqc5Wm6zX6DD6S9egO52CtYluj4EueAh31ZtqN07KaYzY2Dc7WORHOzug+fqZROfU8BV/jyAbJEIK5vWa7UpUKdnBV4cqpjN//eq+7bsMQyds3O0EgI7OhDEckAp+yRuUQRmfCCBajNCZ6et9LFYxUVWjxY0cEW8JbjYFswUMqJyYD9LemxmM6JSiiSB6MTWqqUBZcAySCNACpEL1YWc2gln50Jd0XkYZOIpOId5nCLsAASnUNd7gE0pi8P8E79PenLJKCU1J5wZ4MDgAJH1X21rauTi1uuU2Zi6c6y+oMxR1fY82i6Vxq0VL+pcLDCA5AihjG09XkQ3KTOUzumFr8crxJCF2Vo0yiw/UscKPJLZ68uFOayE/6VLQI6rNBj8lt4zk263Io2FC8QHMzZIN6mkjASa73m0ALxcNWyk+skpz4iLxupTtJwMBsqk9NAzBOvMFT0/NUkWrTsb7M+CdzMLZI8yvJH+36txNC+VLSLUOJXk5yYwESTyG+IL0uf5PwBCHUspk7tDL4oLWbM0GCn9tmrEjc04dKxxdM0WodI1toG8OW07c26zgQPi5567M8z/PpOQr+58/S2N0//b2vPv93/TqvCyb71d9I+9xXXrHHjx/Y+086w1itX43Cmvx+EVHVeMXAxsZuZsyJdZGa3GJ4BMmtIB8uQZOKefuGM6dzY+cMhSGaTf0vOhgYtG/qhsYF61inrga7kQ5it2h3ogm7Q7hGdOrrXys8UDs0Wjn0KDrZaHZBmK+PpUsTchDZCWlUOPGxknxzjUEbPauWTSn4CCGOjJEYCQmsxTCohr3KpWpCXWsjvJUjgl8Tflrgx9kYCrKqtprcaKyir69wg5x3uXj0MV+Ra4NRFZBkTthXnzRZAuajzpnwwXG8mzcKJDm4hRRy2krPpVVQq2Xgy/Y1JRusPJUsUQ3MY9YxdUXqQYIOOcfk6EQmlcWAsx7FtfuGhDHmuU4zohf4ThYZ/b2P9DUWtiZhjAlm3gN0V1wkTiyOEd85Nn0J/XvdBCCyE8IVFAeLUQeDyYfhw0WWA6vRuW46jfvYzhZNN2tlTC2QnyvWq5kk1JuwNmJ018/C4ie9RBWJPqSi2ou9mGrB6qeXHLizkfuBNVKevX43MQlnvxbzmyzSOM3JUzZODsjQYrskWQByyJosb27NHXagEegx7y6bRGdTBM5Kzr8P5Uxy0I01Poa1yrp/UWM1VtQorYkrJLh6f/QcJdxqnqaubB9kCypxwbzGwTzRS6aLviFQgItUsyOsHm3GcKg0xZJwNBrUNvF3d5bD/pbzdLuqrdZMMRPZUxMcvctJXI8Uboom6kdACTfSCmZ4mILTpemI3xpnm21dxd4gFplCfRtrYmBm0UnQG7/frm/XUAg5VjRgR/VXAghWsSvA7XTWTWyDWFhs5nLl664cwsrVo4XiCD+vp38969Mqzpy5Oy/idffgc//8fEaub3xJVB6+8Y699Mrh57ORHiMrvevb1Lsrjt6lJ4rA2OQbkqQD0eMfu0oGfaQKPVKjrEUnOG5EBJgAYqiSHhr3BS4mkcEbM2VEJhNwr0wUx504wk6gcBJe3wkOp9SGJCVU8gkwgs702N4RQyFBakwxVrakZZHPq78PoSn2mlU+kVvngG0CWxsc033mw0kb6MzS9P3V+chz1zCxExdw2xxTGw/J54MbG8TheQ67Ah/hqas/7o591bEasje2nrlr32sVdHWTO7Fk3moaEgF4BWVfLX5DX5KXFprdrCOzvSFmgzL0DIoR03lW6NqgU9nw/8LIegoyXRIqpEuBM3kDHPZcQxe4Lv6MXoLLW6DjVB22VX6AShQapWJWGkLkkLRZuCuRciLH/FX+cW23gauY402U+zhhVNP0S3r84LvpywuXcCiMbkDStvtLQgRNWV2uuFffs3xroQ+500UR1aphOLkgBEGqJvXisNwbTItPf33Z4IE9ZwcIP4jlHeMel5Rg97PaDPGC1i15u37U7+vS3m7XsaD7VXGvFAUjH8pUcqM9ehg74vyTqBtb55F0hPpiNnEZlOpF5EgPmE/fRQaXbTGGYLBrZp7L4BXZBhX5Ne0vxpXvI7xijqv1JRq/9w0REiVcvtn/jQ6VF07kNQUhjY+TsbWhbEebjHWOxg+gWJQP3ACbxmAq1bCzHpEHluIQNpKzB5udMWs5pEpwLE58/vYeyF9VWTkHCq+gmEzu+JPpxFtaCgcVRLxQu/a7P/9Xf/BFvv/XvN5/65l971/7Lvv0x3673vydN+2l1z5BwUIuDW/BygrwBOqSHjGCwwq1AhsjWRps8LVRUewwtO6nF73Nw3sIEFIEzrQ1HtxXwbAecHrPvXNCE82yHkY9S3lh+qdNaSw8L8krQA2XaFGL4vVjfcH5nqZfBxL5VHuPzQATJ7E+ysCQFsuCG8CMjRNFAAR72ss1PbSz5gC5M0ddTaHNKa7rTygobaVDki7GHj/dVbAj0hPx6p25eEs1kTntkGHvWFCtVkCpUKN/hM2E0yLGu+dDA897PApWQLDGuhZTRJNRtUxr1/fv0iZRdUiKjg4O+PAWsl06qieQHDeYu63uizbNJyZwtNg6VACx06GdcNGX1WLE4lHP+7PlTWSZQUnFdj6qR2DNvGjUecKpaZqqY1ZnawgptkEd53SQMpmVOe+lD8M0ORZueQe6RiB7TlqPNqASgPuv9j0qMYS4RBrSa39IQQe0at2ORP56TJELNADKEMeC1OJWjwwgsLXGnLSrqa+429MKDRDBfLfUWXN9dow6xK1u4oNEj5i8GcT5WkS47ASv23tvDRCsjo0s2WayHeO0VeWuXyNf5BRMgG6AcBHudUff0ejlliWpGHKy0K7e0tFWHeHcZnNIYw8p268hrucU3Y77bQaTs82G5nY8eJFURF8ljJISWjdmcVqtjWnSnDy7FTFwaEO45lQfUcQeIpcM378b72/nfQUiVBJAGejFGiTb8xqAU2tyPj9fXXoxeGX7yywEzMFArs9YyFHnyHDMY5g+L2EgzIXoGxRYUQkxOIW5his3UOrrBDg62wnM4gLDsuLxgfMErNoKN6dhrc+RpdxDc6rI9x7ZRf6S43t/QEthW2WV2XRPYFZrYwK3vp3P+XX3vfXtL+zNP/y6KpR37z+wf++z/7b92oO/77/9+79uj/MT3TvRKoQT3h6O/es4LAPoaLbQo8hh9nOUzwANiDcsqdrLdxmH9XkDFPoKaScdjJiIXph2IIvJ7rc1tl5dQp5kvyRsSxbL4qECpBSFKeqc+Udqv2MDG8sKD8hll9BEdltaR4ZKnDJZQeji5g1fzuuSW1PQdy3R4KyONnbKrZAVLS7aYx2Z3l9rQZYXW3gQVuRojhhRL8+RPi5y8hPy4gUTGfiOmcbONiOQeL76fR4kKExZdLSneKYNx87HjIjcGxzOJrSjYugrImyVIYnYAAjuKpoSbXJQKUFVBpp1mV+Sqd9+Tt2dOSb6lCMILS26Z80MjO2o7yyrGpmfjikZtVEP0rn55pelHvICS6mUQNPGS0gei+XqSSqx6dnMoKilfbqsd5miWQ8x5MRj9G2V0ugyxOb1tJOMg7wh+8+O6+Q9sdsGucL7N8TAPhBD0siyTZvvLM17uak9zUm8a/N7ktDs85LkGinH62YSfGK+p5XjRa881cDwBS8M899gsfa+IKiWPsOhoTs2CEF01M+MnH7GZ6AEPwl5dKdEUdku0K4mNyBrg2H9AJoH1IOVeaz1j7WYNfAEtN9gphhXGD315dvrWk0DUmmCOgVY5R0/ld4IFiISKkd7oxMwmo+p16c7u/VCd6IR/bFBO8HBb9Fxo2QxVof0KMZ0n7t2tCM9mV6kvABQY7Ee6TvLVRhS5160BbUitcPSlCTWKBqp0KVgmpXAPsOLJeAAt46OzdwNwkGXZirxJC/Q5YmroEVWilSwfxFPCnO+A3olWB6ppe3iMamWSQqfWld29JVf6fm9KM4/dTbwta+7n/2HP/MC3vYPf93fn8v07Iuf/3Z7/3t/3x4+elUZqDxKux9xXLfAVTSblyDC13g617hwhC0IvKZvFNk6+TVnHzts4t0PysIEt+n8mzTZ2KDWh0N1vZvQ+wvGVlBiG4ztjp0xC9V7xN6mTWH10cCtUti+aptq1uAKCf8OcY9kHsSddNuPC1yFAWdT0OxKkehD9UQjApGyUeGsny4rF9mbQEhirpPdTKFxKCZWaGBalyL0NB3i0o0Fim7DGUrJOgukjqlFwo2yObXgYFSYG7DFTiIb+MXo8mtT9RwYSo6L03D5kBI02Riyiha4Fs2gCcDTCiRfV++0OQCaQus8ShNth7rh2MVnMt5Q0hiOByUXVyBKJ6RGwUYgOHcSpMNAOKitkJYxIosycz4TndyHU9CGD8Q/iBqNWnOg+jKHEeCy92Pd236KJ5u5wzBKQbIJQ1iOff6IEkLSEsIb1vM6qjVPySb60u8JKXc6xRoYvKt+dE1Js1Xw8cOMHhOiT7D/NCCyMUVllzZmXuYwtfRt/0hk7TJtpXbIb/7e2I0Bt0M/i1Oxi9COqRYStbtwEs5eFaK+7f8FgKT0CejCMmTZm8XpLPqQ66vXUWgd2Fk1YFaTN4IaWxcWQmvxpZAr3kMiEzc+LmgCFM0XQgL0Ji3jMHo33U7fEdbmah2A1wqKx/bshX8d0SyjSoJkqVaco8cP0Ac2TzFMlc0ax6XRBJO3QLw6I2FhWCHbbXGbO4cNgqRQ028wv+H7obWCSRBl9wUEMY7SrTR0UpPNDPhD0wit/5+fQVV0IXZRUe/GBqdAug9hJuLCtZyCD6Gk0n9Br7t3P/fPb1Be3qc9fe+0/+vbft2+5eX38iPvv87n0blsNKjZ50qfIKGTlj4ehqCoiDkFlmPEbp/u8rjwVYph8VAS7aSqWfrIscno/+g3j5utfTi6KZEoourwmSeNEC5IpOfVDdVJ1XIP4pp6jJTAWVPzWrIIT5eTrM37Y2csi78i9F/tCCnxDeBicrnd0glIkL7QB+q1JIFEcidtywy6nuZCp8slBu9Fz2Va7WZM7FljOE0+k0zpWEiYGFgCVGtzgLAOniyyDGd7IgvPDoT0+EBPxIJH53nAI75lanDvmIaY6+ue6M+46CaQpMu2nZTTkld0L7/xgDuwkbm6JNrXIcEkwqB/4sy48IMNGZv7a1dNVN3LdZKDeeAp09TEAveH45aehp4EuKgEKBypOTbtLzPYBEvzSdiN56pIGjandh6VeOiBQ7M1CaSMMk0CELnv6ehxTdng08aCYKU/RT/+6xj0Qb2//f2dfThSS2TLzKF69+VtAUsSwuioHEPiJtf67Fx1Wa55DMnO9R/tk6J+DQWeVkpf7aPbCHtMEejJWfTQopfZgSdJsEqrRsnaImwbw23C0TqmQbIdfBjsP2FDHuRMUj8yZkIqgD5Bl8IOyUGUZKYNxgWSrlTm1zX4FZ9i6BYqUJnmECboRJBZXf/+Fe/O/5+5d4vZNU2ug6rq/XfvPs30Yc7nyLGtGMfJBCzkhNjGIhgiR0EIx0SQELjkJlwgJLhESEgRSGAEyQUCKSCEc0fASCZGiRM5sewExZg4sUgYe8b2tOfgmT53773/twq9T6216vnbTtLd0yPlS2Y83Xv/3/8enqeeqlWr1tKQzqzZ0iUywxiSTo2ajS6DJBDbxqmADrXkOlCW4ATt+t0BmqidELkkStjxhZqH/Ys60YIXc+8/p6TTaWyX4t3zQTt9AulEupKrVd25xKaghnMG4I00coVsCxF6Zk5u8CSKSQ+lBXP0/mM1OzWuc3/wSjpvOvnzjvMH479oPOG58/mv4VZDoXzMLNzUSO/h5+alz//6N+Frf/vPJZb/5quP7PWffcb8Dz4b9b7nAN+SSdWLhBw3WgmZMO9AvdJLBNSCPgh5FOGLrkrgYF0+7GoRAxcxCWINrkfb4PyMtyH1KEIvTOOJpPA18QXBjSzKOENP9evEqGRv2hNklF12mqCjkiXWUM2TRrA9slayUkCRitWR8oWEhxl0iMkl0+BPo/Y9Yn/O+HztEREZNr1lMURdQsdpXpF6clXEH7X7YTxrs8Y1PrM5T+yOCAhqtO0bshsMOsH/ak2jaCKR4wTvoDTt/AX7n2A6YDoC0iySF/BJxNuoolOZo8h14IBGh6cOVCcaaQHzxrllVuvumpohRDx8vmKPzPrniXyZhombpF9UkGMZjVAomQyj4y9QgdDQ1zLMW53429k7CUk8kEjV59quediHMyfA9dB7B/xCufOm7Y+fbP0mzrCPxffv3LNEDdG1E72bWxC+VEQH+Kv7tAkcBr2OWgK0p41m+uFY++K4UPV2154qdNcemqJcq8wVI/pMSbuzv1MSz/REHn1eslDmCPYefWK3qxHRPhx6vnrpuHgoRhTFzMTEGJ2f4hqVDE7jZHtSuZVSUP1Nvfs2a4P8qkJOTnEE4Q1K/QjOMPVp0Ecr9Wb5WIv/nsCl0sstrFJlkTGT23VDuEyz5z7vl349rDcN7dO80bq18XzZ+EqMT0yoiQSOpQfjmB6CGELcsidLTo06lyxQzaZZc0eTGPlTEdCZEQI9VnB1qFVtEgXuB8VCcP3CVKe5339iPeF/axtDTUVRo0j87vdzGEV2hDGhMpU4QfNHsk7nIPyFYd84hNT88Lids/K9/9x818d/zzfty3/L5wokj9xe/dnTXvjIi/ad3/cJs4dJfUSacJaCNudH8O7RYiGFwe8EEtAhMZ3oizFP5S+2Kgp6GkFGjynYJI6P2VVJ6oc1uQnQO4e6VJLbIA88aFCybsasONFyy4tOXPema4x16iBHGRCMZKiEEl8HCB5k2yLXHGAf2BhmmQm8vtmiWYUauhg5Da7t8vl+POH0HQqyYdPP1maNa+Mnyp+esnZapNtBqxEO6nKCAxPbRt2SGIJgJAKLxKNE0Rca5pCfYbmqvU+mjMTAdm7jYK5kRZSi1DlNOQUvLtgRfpNYuOaoyEfUJLHTSVXghxeNEeal2gRadG+G8l4QBAwkWT40ok61T3WNdbXF/SMSExP4HghNJvc+A5c6bKDuf+e+1dTA704yfbz7NK5iv0gXR/fjepY7jF04+OjPx4Q4pZoOkqUOm7R5VEWtiRktQ8uO393LS5rwGN5M/DeXZ6c5HvP8136rQG8zBwVgIspkrCDsAERmJMhZM7WRp9E1jmUN17zZfEl/q6CNucYTipAHKt4atiJ0zZ10qVlfpGG63KnUHinsuQYmj/HEVmHA349nqmKCEIp+h2uYF/t5TB9Zt6fw/Q0AACAASURBVMWkJUiuAKsyIZVdD5VYVbrwPftsmroTY+jQxHcZ2LmF/YHkkdn+DEcAmWb8K3hMXPRT/q5T4SmVsIxs5sQ+KP1ytWrykWrAhhnyruFyB3ukJm6Ekmr2v+ppp4SkSQBxiiUGe97sHL6iMmhEzFn167zg+YkeEwjwV4y5rXPNlaz6+bGp2996uH/jn5v/4D/8M+/9t/5DPr620X17WA/tJ772n/orL79szz7+NOh64ktQNZjENQ7RUfmiFRNx0DM8a9vA7ZNrgvTBzl8SdGbR2ExDOa3woQSH2SctVPpcPIFtgmmWNOvdiFhaAV1JgjFZcoY1oibBhkezB7I4VIF+sreGPUidKlyxjchGDKzqheDSoIV3kHLgW/+iJ11wLFx/dNJal+yYSStyDZ90YDwZLVbSzplk1h+AaNDVluCA+9aAtbae3aeeuQ2y5ZO6m1EKTGZQ/gBgjSaA2s0lCpGy0s7nyyRb1v8Sp5hziAXp4IxQ9ylZnGDj+1MsApIysx/JZLPfYGeYwcHfBGxBrG/T2CR8NYho9++oXLGrGznVL51DEla37qszJFdpEGICS2BgH36J4VEkFMP3yLnRNZv9yl6JQD+p7W2QE3YamjrMPIpiC6x8+1tJFHZ4EqVKs8IBwFohcoybZ3k487yWWanZXmQzWIv+t/vAVmjHxnbA7CQF7fULxteOB8l2+PGuNNSBsSmYdmrtMxtWx3W/yPbZFB7gNQ8tsD+wk8M1ROElFT7S2VRoCClwIK22SbG5nxQgmZZlx0hSPVwsN2fR0fAU4ouzVTNJsZMU6RNrlUEPY6y6fRdsraxwBCWuJkZpqI7Pua16B9HaZ/35YLH3yZJVsk7UdfKhnYBkeuAA1OkF4hxxaBprDDAtzKQ4KdUXmkqZKfCqBNy6AQO6SslrqUKKyDhfdOPYH93EThrttCIe1U82GJU4D3TTfMv+BO3gohsKZfRAgyBKh+tQxe6sT/Tekx0FygB0LhS5SGJ2Hl353cake+/95+Y/+k/+vW/al/92n7p1e3T70P6pH4n69O/6vWYP8HwqoamsxnS3b3I4wSJWyfnS+7xtYET8+kOwmVE7bMAWth+rlKUD5nZFJkKXndUwiBh5983zo9e22WwRFr7kFDgiQH81sZcNsyd8Cc3r5oI4Jo9MOqGi3m6PB19htHs2gqfWzOpyZsJzwPJyGQJrS9r6T5LlCyqT2rtQE6LQRECDbR2oqe9e0eXEBR4YX0v37fqmH+WcRgyOJorFya6rXoDGU8nNqBPVpJHlUxr9MDy/TldCYaaN2Vl0uGoNEMwO6joXty80nZ0MQJwj3qqR14DJ4QlurEzx5DYHIC3woqgTqgLTCfCaIm6gd03jtqPfEEEkTJr1gwZ7qpCYdVMK07wU52YQJ1LG0ZBSdeYHnSNN7SlEelg6zmE9eZWqzE1Y38BjqjvkQUN6ABU/FJC5tcF0yBDtBIzAX0GyN/JrOUWQo774GgnuEFd9TnrCduUCk8LR4uTDQcZMHgVbueAmYUmDHcQXAK4G0Dvqo5Rp3Kw3dQ8XbyMotAQqDj3ouOC9N6p7B/ZswQPyDrxm4AG1/+LV5KEYIeQST0hOKFs8I/zh5WqlcRBnR85E0mT7x4rzRLXZx3ZWEcbhL6PpIhkmJ+49eK6uTZvcC67OINdpsaE4HMoqjseWafrDxKVDcGT5yrhHsl0I8aSdR23WAqMBo8k+apnid6jIAE8QkrUQeqW6LMQD8eb4Jkl2fYuYSVPXZu2Xbn+yZaP4psvhPZOU3OKjEXY/Z9gGjxiDOAsx1vi1kqew0R5JYrU9lZig/V/M5FQu8lu/+hv+3PzqF375vf/Wf8Tnggp+80sv2ad+8DP22P179vCBMgQuQwpwOnlwe1HpAXFssApA87zbyqKQ1Vr3Tnb2YuCgaUveRBcB3psrZGZoDK4xBRRYLG3KjXMU7q+ALLrtMYdtk9p4fYEAHGuoOOB7QmqdGNBCcNffluSSkG4OBTL7AsdGGpwt7NQeDnW6EVDgYa16JzFXEtTw2lNmQkacSt9WIHFKVtbLwSaoFan/wMplyK8TaxhTizKMJQo82kESuHITjNCFUwIRwRWiEKttampaJIkdvgbHdxMO8jH6igM4g/xQnG89QXQgJCfCHVWqyNjBkpVv4oJ5pONC1c3SHh40ejhzkJRhIo2ifFN+QMt/KTOscbKVqlYb8LImclBDshMSniIYOIxJKWkEEzy7ohHeIOCrQ4nGK0yMSZpk9t8aWLltQTAeqqW2rr905KgFdoo5mLpb7U1HQvSa+Oiid9FAIJHDM5SHUF7ysuNIWdhpzVCOaRvO0EQ/b2jdwIbITYTw8bFXpBdFotOa5dqRUC3HTqKxUmc8162cQbBQwc25gnBzyB4mCVus8t6zp4RWlYETJBDxvf+o/batjerpkNXAWrgrK/PFUxnuQEHfn2tukp3K5LbVSJ1WO4P0stAIZL/kPZHAgjIMGy5HPQ9rpKhn50oqS3eKJjpUZEqZi7aqAj3bFASVIVdTRKD68tlx0u4jtxsP2Gm4pck3HzsQiNaYykIWobSNS+LyoXfspsHQdbzTQbtb90a5aJ+nAQk2CitrKlCoL+wdsidiNCJgysg4ghGruZCmB4pzqsWeQY5nvlgkqRQlyJE63l4nSFzcK4jcnUsBy8S/es8/N3/63//Rt/WdV5y6d5Q98+TDvbh/x5/zodvv+J2ftL/58L/LF154wT7w5KcW2xQmp1R85HkyfdcZEdsWtFp3Ez90wYj20nSYpahycSduh4u0yHDX+h8lP5CwHQJXFouqqjDEzSq3ML2AlxxGOZ4pDdUwgnjWUmbFkRUdy0MCVMREtiomRBoV5BOmFg4LPulA+hbxFHhOVlxsy09VJPJXcZqC2T0JuaT8Em5h6lYm7xr0qTpBgtcI6HyUz2C+4zbd7H7EaeKbIfCGQle/tEDDm4bZ6x6SFMwNRmnD9Vk4NlWSl+StOT2BoXxMa+h79mnEPhSO7F50ghkYPDhtc7En6Iz+OFkd0HjaWuVMsnKDvOAcqf4GCypFqdHmrblMrXRRNSZIOotFE0fRtV6tZg/14byqMJ5L2yhr/1duLy4ZrCnpD+4PZzW3/ZdOpUoJ2NC0QwdGtY/AEvAYb31ydDh6ZvsNbxFWz5cpVR87m3JwH+pVw2bhjRfHJU3TQVuFrMyZf47n4Sl8bTpytZ2DKNCN450CPsh3wFBQUjOD1XgoKhUyD5/SYARogMbyDOY/ICHqGNb/g7KHQ0/Q4+unG0GEAM9cDSC+z5D42jzgLeFwiO6ciLQxaPFa31Gc+VMfbE64JLlkwA1TQbeyzwRBJUTGxrgQS3chbiRb858VsenwgXg7YkhEWfYuJqM1x5yLow96+WTl4f5yZsZyU8metvhkVdCH1IQZd6Dr/ciPGll8yafER2qK8ctpeokHJwXmrsYB44ATz9VOxHkO9mM5Ehwgja8C6IhzfyHv9efm73/lv31bX3nvxuzrrx72a688a88+Z3JzfEefKnvt62/av/g9P2A3cVP+xXvmT8XRkpz9qnwNmQrYEt2vI+cuDRkUUUTWuBESqmWyeiQfgTobW9XEk4bOAF0UIzMRQs2I8cjSkanjUnrqWLY8N237bgqytTgEmicguyJ61FuWIboBBLxnTE8LQcTeLjB949KqLx70vZtVyZsnS0nWdiZu5XZikW1Qm4I1KuChkAzpkiREk2YJrzWQ9xNCLndNWzpzKpBWAz4KiTFUweLcyZo6Y6DDu9bKCHZMnLq4qtQAf/SoFkaO6BWi9gX2PNitKi746tc+ZZCORmQ4blv6Al/qfA4HWJtEV0WuU4J2aowyTkDhjMUdME5PsINvmscgGTaZek7gxbhqbm++/3MCTg7g3r3F0kpBvYpNyuCJt+91VFBJvIQn6kZKdeu2gZTgMKI8EEFfUY+HFlva/VdxQ+3hNYnCSLUZhdl0ZIywOBId6O6lgDhtd/TesEU22mi5+hxGbS2u5YT1WtGq7No/QXhI5wHeZYBEky7wQiSamvtnYsp5qNifjd7sBhw3jpqgB3FtG1VteD4W9mDlXlYIpel/iI6UsiwkvbVtBo3GtVp9CXSNmNQoh/RNJ2XaYBfWvRHSJoUY4CVBsM85MMrCcfrKriQ+2NIw0QqFJBZOARZKNYRQda1oCcPpoDJNbxIMUvxtdPKYRISSMfTVaqkqhNQkULdnxU0yXm9hmCh91vtGPOW+JrF6S7T3E2FU43D00fiU5BtT4T0EG9tAE7je4++deB+xPfQ7HHNjdrwOqMQrj3MrdL4Zn5sf/F1vT/Ts/j1b5g1/5sc+aD/5l8w+8Nwje0t4eluf86HZz/+tn7F/6U98un7gD/1+e/TGpPgBJYgtJ1Wo4fLfi9vNck0VhoiHDAjk+CCgzMMkj5Bsbo6muWbfasoTqpDrG6L7o1Ig7C8fNpvq7OGo9OYWkT3QYZwqipyp7RFsKg14SDkdA055RE1yPA7jWI0EYRivt2tqjkhND3PjBDBJ9i1/Xm0trlUKGt1p8GxLVbCpClat+Dlc7raANH3K0kO+JFu1kHPoScyKF41r5kAMuyirIDhZ3fEew1iP8btL75BhYiPQ8K2qjdY9AU5qmA0PR3Zem3HnrE8GRAaRvZrsvyMvPNuqQx9Ea0+f9/7kmJOK+mf7U+bvz9F3m19K6rMORxIdtskgn+sonqA732W+Cn8njNKWKhJAzpzkd44cTsvUdveGpObODSij2x7NRm3iikws9oAYIhM5tVSbYYbxX323VkdhSHuMXvvA00TRbLOtyvV9Vc9NcH3KCpBJ/ybvwANpK1L3qOOw3ubAasROPyhx3nSH2EPcGI5DMLl0dOrvqQJqsKJ2J4IBR0J8/32+y1+rYAD4o9pNiAu33h7YkPj5nffOh6s2J5DC/dR03exoVtedK/ENHrB56peAL3bFhrQqhCMJi8naYkPKRN5lEjMKVdOiW4/lgF12LA7QqQAwSJQqH3CEvPYhGLUWbQIip46045FqwAON48Rq3bP29m1fcZlzLluS2ZRIW8kKy6Btxs/tmyxJdpNvkxz7xgOzjzxt9sf+6a/a3/ubH7R8/Z7d3LzzPOk6xF775Vfs9qsPIx4zq9cz4RqDp3JiyramgqjOootaMklt6X78BysmVHdsM/ZozeZa7ooJGjE/E8IvW0bpNcBZf2YMYWwu+/eqNEEJyDphENneLEeAgIdWSOAQS/IfqJWyQc1krAykYPRV7N/BVabNh4NYe29DPlmNJDbGSv6yrxdDE64WLCK3k8niIiSSEEMGSP/1cwmAwQ6sCXyEqSAU18ne7njDChqiX6igk5Hzat3lFnDIg2D3G78/sEZSLXQefIwUrIpoiI/Bysw7tmKSnvcDIkJMioqG3WSVWY//HWii3A2A+G9gZjVVDhMWfKfumcQoHx4gctFyRQqH46/x4JOxAF4uJ5Pn+QQq1a2rMm0eBOajdMjUFvsY4JVjM5D7fH/ZtP9MiTwTTb8TTEnubH9IgIFUo+V3raGg+flGWvZRcCYA0FM5u2zgDIIKxHWd5yr/xMPiA9hInWwpcfuKooL95E0ZhQftKHYnyWgMFsE3wkOeRlP9u5Q779koqnJ8O9Pa8Y3gc9gKMaYL625P59iK73e4ZbU6wpT8YtfJdq82Y7ia410N5q3OjOFw6D5IQB0yMhGPYhYIIwgw5Vw5jUzc5JUEjl30u52ckIjq5MDz+w0ePXjzpGIzqQztuSke76ZcJiR8ixe6HthwDxw9kiWIPy30lzUFkpP8WfDLQSIrrhpxv6n5pr1654zEAaXWzCSkQmZ61hOTESlyUSkjQ5z12ZfCjpngHWwXwa+AvSAEuaVlvhwTOiAcFcNH/yZ8bvJtfvl1T1/5qtknPu322R/+Vvvqa0/Ys48/eEfckeuvPnjl1r7/j36LfeKpLx+v/vpL9tj7nl8tUaFGAG0lHuTbIbigyVhiZQwokzjnpO1UMYR8uoAGPGy5JBbDT4weYU6eHHwtRoVHbKhFIuLyPwT1qhbl70vwLtfYGOoVYcbMMxxMODLdYuJWTl4WwXvggcgoqRXa15cxLO/Shi6aXu7GWGYzL82GDr+JQkZrIFNMW8iA28nxHRjIS49WIY3CLNPQdrTWzFrsSRuMA4D7ZtZZeP26E/dHcmHHz2QQLNsSJ8M0g8/cSpuucFwkTRNxtfg8QdOMCZizjnoq6a5hTStRakXDwryRPf5rp2CcYXF35zgUGosjyKhEjRyHdCnW8l4hBGGbJI10LO46h5bk8cf/hjZ+W2VmRCsU5olU9Z/miDYxCRsmpS8xMdv0ShJBlnyJE871rerbFiCl/UREUJV/rjWVwiM3xIuZKfYXp2oTjo88mkg6kdZLuGZleieXw3JO4nzVQlDJ5ph6Zs3GXek1p2Ian/cIqmb67K+zJ/Dn6U1C3MDcyly7I+ou8rWJF8SUHK5k5UYFFsIes1P6+a2lc2ok/g6GBFii076okZzgQZsDdlxWYAYUg6sN7j2c5mskwe0OVwgkIrJKddaiF2ZEkTqcIWNjAiw+ht4eVKNrEk4musVTnZN4Pv+e+yJQCzkTcFdQWS2kQ2IxJv8aEg1LIshNZDq45sTaas6fzi9uMyTZCB3IvTQ1tELOSUpAmVKZ6/+dZG6jZQl3iX75m1CKa2RSEkVbRoYzJvv3+0JfEHuCXtCMwwCpakdO+y8nQTmO9DOmwWsk+nf0UeB+2sPHT7uLVL+Xn5t38l2X4/9zR9nvfuYL9hd//dvtqWcevjMia5k9fOWhPfbkPbv31H3PlzDbsh8zKo1gxWZqU7r6n8L+u5E3c99TzfFQNfra+ea53j1cSB3bKEAPa0JxMXFyK9dgce+BRIc4ynTMa4hkbHRAWTApzjToRbjICgXXZqXuCcMBSpLaiFLRSXBbRz29kVuAwq5X45RLyBumx9CZ3BicoBCDVfUIJYLv3TpZLAQzxP5YTmGCrHexOr6UU2RNHX7N2V3cvQMcEeoOTUNny0JQbYglEuwiqMxD4BXZ0+8qNKFs5/+xdhB04Kcng6bTgy9KZlq6cFfAFKlAUXj+joRUAdLwAGc8KLB8A6JjjS6kqh/CJXQjWXIQG7qkEyK6dRDbwlUtBDKItAK5R2rpjtkUlREUUtK7zcE8VkYG9V+jlvCQTYsJ0pZ1EAQYeI1IkuS9XZCVA29i4WBKaN180vo7z6AfdXSZunAz8iU2jg0fCWCoPriKLYitWzRGSicadI2IQaQiIUzD2wGy3sNCrijDZWk1k3UTTPBMDuT5hX/bzzsoRe7zE7pPbQFnUTCNZz5R1D9DfNTxM7SRurs+CVMmdvH20MjPsIHpeR1IqiVpgotwCvcsYvIh1GsYWTaqwithqPJDNrMcsObrGK9GRqTEuD/TIuiVZVDDriapFDlwRcizKcN5t2SiFXUQgJO2T//5qKIyEdBrrg5nvVAOz56cUQpvcxwBvsG4PL+M2bhyAQ4aGPutjG9yZHeOjJeFipUV9Ummla8TZPplZEI1TnDpkPw5IBwcTcv7i7XgZey0Lvmw2/bVuR70rdN57N0OsPyjPu8oGbk+Lz8w+8Pf/kX73K8c9rO/+H77wPsfKAa/nc+Fjv+f//FP2vf+kWfOT/7gd1s+hCZOSkikBy2CY+buteVhcIAaVjGDHA/0DVmjuRGyf6Eniw7VUqf0vWVqLp0PVDPIlCjuVHjPocpoNQ/oDk9AZ58Vp2q3hDRjc1VBNiMMJhUR3diWGlqlLEH4Vxt2rZ7ER/EQ23fX9ny2DLgHewjobWT26YWzCqv5UWYGm/AxE0cDNZ201SXnOQUou9zjLzRtHPQl2zqQtm27f5apbMP7vzv1wEyTbww3r+hRYt3bnbaT3U1zGuAwctq39Ee8JMK8TBwbESoos0XthorbWYsrXt8XJNsphWSYuvO2zF2ObwSMOBSYbOPtxGO/mxUgAhvM9hFTU1F9a9eUpsB05oGPgBvJdvUpIBJiZBC15plmNbzSvf1RHJwdozFJqFM9ZFdkK05F4RCqDbJzSvjxjCiv04k14UymSZMZ2TfX5C9eeDTuSsLtdXNHciASqWlLrIcM9Gh/X5ND8SVF9+PYb1DcmRZQNSc7N6Rqlu6itMZEq+79mPymuCrWrw9lEKhhegSqJ7l0aDr1ftQnJqVzJyCjJUhrvlJHrHwbLuGacLYph17Z25KJI+QuoLhQfangqnipvBLURsQW7bw9vddhTCM3LmqlCG6bDYZvI0h360gKH4L/0sQO564gOZxbmUombI3brlvCVpaFb4iJU6Qbx5WLIwsydI8oZGPiU7qJhKvziuPfpWZYi21y/axK7wA6VbjwyZ5MquSM0Ju0tqGH1eBzQHmSC0a2sCDociVCSb8zLEXejIpbLlct2/fw846TkQe3Zk/eN/vdn3nD/vaXvs2e+8iLK8F4W58LGXnttG/5gU/bB7/tDXvjlTfssfuPe7XZePbIWbVuac+6am+xAcZ60wkf8Xxia0JbKUGlgvclVjkUK3r6foZNtvYydOnRATaSrQDpsYR2LvI+6ZDU7xQnvmMExZWShtf46FBifYrP2H0YePC5SQTeSeQrIAQ8R7GbtwXSegWScdoqbYMaEbvZzgJaiiKj07M9uq3UXQsRPt0LNo7yMeVnIGV7hj/lSvCYWRZOO070lA4pHalLu5NKMUbGaNH9FkE4+42Hw8QKLQgeySD2z7PZqk/cbl/iMZeuCOwMOFmapxKiZKTy2pysxvEU4QLSbPRJaUh8Lfbehl1PlS/wg6J1x2ouaIu7nQcuvRFMrlCyHBGF2B8fp+6bzPzF7q2ic6eww5ygiUENhtohQ5my3r4STkUAO18BtaeKnAQTkquXTAeuKyhqdqDnxO0Dn5LsLGRXuNKtk13SSrS8pAZLTuNT38QJp9EOOZtAuYNJIr00HSHD95bkDLHYsXExoZSC3zxPpDJUqWBXGZN90sFx8pA6ftxNuE1r2X28mPqIP7pfdJ0TTnY2Q9BOtZz4dZfHQ44SyqbAhAhPum1Pizigf8PRl2Oz3d+o1dYoo8OQdC6lNtF0Db8OZCvB1aHhcmyS187GTUddiAgpDaHfaU1+sk73ruTCWR3ivqZdJPi4J8yAbqe4ccobWiCJk0vOnlAsS8f+PmcjSsu1nLPiYqESWmNxsXMU+Sgc7dzZubS3IDZFUjb+SffDfTTaJwVzpMA6Wt1HCP/S9W1JMRPBw4oZRZPYWHbv/ecdJyPXTbzwotlnv+UV+8pXP2Rf/OJn7cknXl0EwovQ+uyzt2Jtv/WTmfZaPrA/+YN/3L5QP16/8cKv2IfvP29ohye03be6SfPyQskmVGCDKh6Z/kt4OmauCD/u6C0rAHbB6Z02Uavk6q7NzCKVrObuT+tmazv4cyJYYYVDW7Tw6qeSDBryuJbUMLOly6nNTMCeJ9n6TSfahOxb5iik7S4MihoCEKdc8rwbu/YacB+q6DJKmEUn3HeWPw9Z/LY7lV5OuNpTKLAn+rUtZR6BTU4eOWMdIXYFLNrB4vkwDSBlD4LyDFFT0eHgBKPHaUfUCx1E3HKkgrxc9LFxmPchSL2SAV4GNHIY8gmNECA9O4THFAG8XX3FBooZd4+5S58EBfoqZpDEUmtph3kQ2EtENgbL5gsE6EUSIRMLG1e6Y+pIrWRceSdSXdK0Uup/y/VpHF3rQOPIyEurJdL5ODvN4lqSOGp0oJQYhmklqRmKZA88PdfByMNts7NWRYLWmO2nL+7sBKuE4V14I8tU8YSKnN1t77oWEbupLn7WVsMMRoDEv10TShlwm//hABthvA08YNGhoMGDbLsaRUl2dZC9j9ftlmFs8cn0ilQtTWWuN0BTRWfs7e8guutbW4L4A2kP7HPx/4hhhPV8BNRrc9bHtEA4zg6EZPuujQNLghX5atXZv8eMJHBn9s3MukfHaCP3b+Tnol8QkzwCXHz/LqErZvK9Hzanc9XH26AAAFU5Xw+8KwTsLW/WdE0EaAuAVS3nZekdzp5NduSCMmnzBBcyuBky7WvIzR48NHv4Jhb8u/y842Tk+jw8zT7y3AP7zP2ftF/+/GfsyeffsMfvmX39xcP+zi8/bc88axtUOp88T3vwxml/56N/1+oPvFJPfODxlax29hK3/ZjbpkIVCRPbtWOz+V9+tK4SQF8SFVH0EJ2kisfW1zfhmVcG2O6m7KZ2lM5hTTtdR9Z9HEyDKGKOjmwgay8nVw26Ffscw5inW3shNgkPWCmBT3SnRzfEJ7xMMQi4mD5JB9YD5vsX4arVSp3DNVJLR2RJMJqGVhGIRzCHciI8+J3OpKnvBjprHsOpRyCGbw1aaHdV6LagNtDxuixxfphOXETBbLi8tmqXed/kcy0oqUYWL1iNOxITSRgmmuE7bD1NBZmhoFW40WcklrBOImK5HaVIZY6aAIBeNapAIFqymes1EV3yexM6oOfSE1kQOOEKtjXl0xdJ8iBPhZix8Y1FwC47zMsxoYL1pfpGPkPu6KsxKW79KJw4MK53jA0weG+uejrFeCpS9XikiV0uyNDX761C8bbolhGMtGddxnag1HZEYE2tGzv4T3TZdeRy3YGSlxBfM1r/YKRBpwgjnEOkJOCqZEV6nMgf4g58MYcGW8OKAjNm0t0Nki0mv54CQJjsejpr2C6OFj9U9ob0owmeBuJUDsditd2c1qOot6zNqDZBr5CGAGk+MA5EnhgJdHcqwXVdZ6u27XP5OpiTSbNBImY7bxse3vFraLozm3O2MccducfSgom8vojOTE76wy74qE6Qb0tlENWrhzw2QkWuJmeC7LwQjmUceKem8LFzZpBh0UQPXoCqGNdmBFFItZJvlanEpNInmpAwvZ7Ya9pzxFXZvnNMz5NzwrGkRHiNVVF142bksBe1Z+DpDWVlY6o1xq+/fNjofkXrE+4VNvCg29teHh/8cNn5DYz/CR9F5AAAIABJREFUvqtk5HquX/6q2bf97q/Zt3/X15qYfpg9+6zZf/afP2c/9VNP2Sc+9cjyLRe2XtajsP/qf/gv7Pvf/3x8/x/9Z+329Swcyoi2XVqQM8a7RkS0nkake1G41CyL8y4wMR3gYX1auwuV7trBIBNQwhvckHBSCKfSO3qTBOvJdpvIWakFBVb0nhFDcYiogJpWBfHHCGeVVUpdXQtEzjBSp2ax2sTW6m6Vk8waAa9fV73nIwm8IYRAHpOcCLUK1hJuEtwd8SUU9Awz6waTvVgtYlbRK92KXf6Zuc3GyDcCRTWkVKL5GAXk9gDN3Dm10V87srHMtLb9CKMupIwdyd3nNoVOgxtGx9DVv+PADRk8sRYylGp18BuS2iEppk8SjjFWVVkjcMZMKbhmSDh0ViCdzR2z4ddKOHskyEzPvXjI2j6V12ssCPpIByed+h4AgDemZWpChPYJslbCHbwFiHuLEKupbi4GiH02gv+fB6oDUXSZzvT76bGNfm540RNkZ/hne9VbdYiJGyLWeBg174d9PjC3Qq0PphozvgqVcIGLOn2gk0f14JDKsaEWKZ78OCRjkvnpsK0/juVTyenRJDFZ8a4bt1v4nOcNdSolvuTB32Uf4Tnoofm8Jv0kC+G72IHGB4Vr7KWJ0UhnWP0zfedbaVzTIbgeTigekiGiNKn2dQLSpRG15i7TXiILvq1Ha0c+bFaeCzDz7fkzXfd1uOJQl0qOJgXcuM9sa30IdhJoo6WfAOIUhwy3iZLCazhHzPYLd8vqhG+QwntTudxh68wCD0mpjZZQ8ZfabHaucwfHOJsbuVky3CnmWnoLfZz15Zf71qrHQxgxz9U0e+OVsD/17zywH/nh0174DXvXn3eVjPBi9izojTfMPv4xs3/rT33d/vrfftG+9HLZY/ff8jO4+Ne/bPb6a/fr5l5cxxabhoFQkYvM2CR5ltzMRE3ZaSAPri0uY2NIU2ljcKGKbG+PlY63e1vD66pR1oKKBGBFrWriMHQDbg0QMtcYo9RAyCSgSnqsaVvhMKEAqiRkm7PYsVlz/a7DRjXPdP+Rc3fVtkwiKvcDnz9eLb1ch/ObekWNoFjnymszuhqaZlsUdkGVTdek0wTlk3z5V6b4iXydnN5IBFwZg0BWCiO2GD2WVmQxgmSTfGDRzJIuxCeWUk8ReEKow7BnN6siJ7GcsArHLsTlClK45I3S1MDa1t763ycyi4M18BQ3NvGqVPUvae3SQzScTuvekzrdGg4n6bLzQ4SvlYdNaAdnUG5xAfLwTFy2grmVqZjf22GbVdc0eUrLipMYo4utO1TLRnr7gDGKSVJ/KX579MCBi87V75z55FvUvl3BN7ifmRFsPAOsHpNvMU9cGhspaanlmjQEX5/26cx5FbMMsX/HiG8SpdzOl0YUOjKdwrNQL1GvWcb47MQchPrhBiVJmSvYJOte5GjJnE5mtlse1fiJqFziIYVjjtXUTVlISCtVrx8+gUtUaeHiK8hxxWMhGTflz7i1QlSs26BNyk5KDVXv9mff61ULhrR11ALfACsb908Up6Vp/kq0FNASuf7e0fTxbdJU66XbgT4+vGbb9eEOUfvPsurXkVxN5KpwUSj5FiWla9cKABp55/v7cSXfjrTUdFTNpjJmOuLokO+O5EEIYNHgEyJRpMznTGdTZDArRKAnt3abgNmaR679NXl1/1ALaORypbmMN9ztdvuG9UZef8ntE59K+5EfvrXHHjP7yId+m2ThbX7edTJiCGC7aNqvfdHs23+n2fd89sP2cz/7pH3o+Ue2PYAOU4/M7n/wJbt3/77f3p7Q1l6wewa4OtnsU4HJvuhwiSN0TfyDWYwacPV4iVry8EzE9JAxMuEv38R1ip1lLJYEQlXo7UH7wgnBaqFle6IvUnx6W2oVUXFng5MQS+GS1ptf6EtBgURUMqXtJmVsLI1M5D6TGLRtq8/fKsrwoQ5ByCrimD1AS2x2S40KrZ0gHIOeAf5bpHfIvMLVYAY4eB6BZdO7KjaTJmK+hqgEyn+3AdieACBCNKz/8ILug76UNUeH07mqh3b6cTjyMCauZCmulTUh+9IVCTIjRxwcBzImFFATB623TRJdRGtSJo2GpMF3zioJJQjTqEGLWt0hb8C2LNNVMOo0zsJWOUcERcPdbeSdiqAiehqGG6TeTRsz/Be7mrAHO7ZVKgwanAzmRNOC4dwZ6/I+5pIXxefDsFYhIL0Mghvs0qvNJKMjdIrYJ9cxIiodU3yTGur6JK9I4Izah2rwr84FqcpR8xQ5BzEgDwoZSdJ0svqW+e71G85+23vJ2190Zs9xOVGxOdYwSunV6yvBbw3vLm/RO+5a/ol2mX7W5h7TaG+T3WAmnqOHDx9JMy4h3p74LRgvFF/RTEud8AUlBGzSMYVBks44wKAqS/FV33g98pSY5AwcDCmQzeD1FWN6zfLS24piXRZJdmwTl7SsV+ERJeiOvZK+PxaW0mzqqlT4YAlmuDtIkMzg2WmTzQQmuAjJm1Cx1NybqoeO8xml9o7217JsZErNum9HnNkkwtCCc4YQHYD+vj7jAl7JdsfpY/1AsuRaRxbmG4YTRvwHC+GKlKeDUfnQbu2JshvtueadrP/xx374weqKfO5z3SF5t59vKBl56+cKWsfNlZC4/exf/bC9z1+FYBVPjLSHD0/7oe/95+0jn/lyvPzqq/akPU/zDobdLgUgpEpuWLR5WZAh4JVt4FoYK2mbyWCE7LQxQNnbVxdeFdAN48DI7DcQmNWrEHau6pBlRIfZE2PfDVSOa1OufD5SbDhjGdVvGO5fLH5agcuL+oRriB1RlNsJoQ4qbzyavdgyLjYQtTV8SBcghisPbs5gBvqvnCCgU0x17yQklsDBD7BBL60db6ZLs69abgtB2VsMiMlDzxCs6Mh5ZQQbicgMqTUtMf1+/a0jt0kFnIkaxUZLH7gCICWUiYluRo4bom1dpeW/Jj1oz0IuS7S/x6d5ZQhAoEbEbhU4wmPrfHGOhxRkFzDbtbpXeH1MBJi4Fv9vGAt3HpGdQKHlrLFY1IQEcZ19SO0AKqCPz161lsCYK1ILqdA/Z/LfuTN7dWy+sZPFmYzW5gFLiMIiTHOQCK5uG7h8arl10dcl18QGYuv4daw+KXi9LiGVJsKghhkV60xRlXh1PFT581x6iyeSFLNhsX5druTslmZOoOUVfE4tEA9KQwDv4GtY33h1KI+KVGJJAqdnZiENAiU6gXpIi1FUWBedcGg89NZxEtfWqZwwfkcOqbmLtN3UxHx3juyNmckRXr50KVoQ4vCeKSXgr/jDr10pOVrIfOQAyoi+RHAQJlGnkLhW2LNt7rw7zJDERWJmrOG/0v7tIN6/LkKVRMvQABgto851MQVk46SDTNdVbTjD8mf5A7Z3ZeMr1I7qo5v5lXOydXKhZuo1ZIE1qv6oCbBkV7uA1jviTw9fSUtBFQElrYm/9iObsiPGB5K1OURxoiFcppS9dEKR7wKv1/Ruu1i7s07szu6F+OV5vd6bFdKiDb01LwdU5GW3Z55P+94/eNqXvmSqDN/t5z1NRq7Piy+a/Wv/ypfs733+KfvFz92zDzz34M5kzaMHaX/n679g9169lx8/vvU6DE+ErOiuHU5BtNSVX9vi2A3SzREL9ICpz6eWJB57AotD9ckSDuz6oi8YUCcUMlJI76IzCG47Gf5XqhApLlIvFbIe8L4NNv7EfddrVxvTBMawnnedsJ38RyfiVH5l29w3uJyMtbFz2/1Rmy9oyUaWznsirKNd3zSTLhox3M6GSlUXO5D1FFZtU9rPRKReBGg0siZDGGPUFgO/2PBcoSLazcTRmcwc2g26Kh1q1HSlNInzsrbxe5X4nZ0Bqw6Wy8VikPqb6+DD8dnEhVXKMdhRlKHzlzajXfhWe6hisnh0qEua3hsEz17gTCb1K94EZ0Hxa8gNmMgsgCFT2NROroe0C/rzAUlsRwUxRDSKy9w5kstSuD0U2AWsNXJ7bZUQeEe+LKIje20IsOsFZhRBM5yQsfomEtWZhr/7CNpQua18r3vXv4jgCp8DTxpwAC+DGdacr1CL0uVyv66SD+Y1gqa0WBuhzhb06KM8mFpfr/xkU2HoUd3j7UcNyn1iYr67Ty6yDv42NaD7+ekYYyOmKJiFj4+6OI/QkmVKQDuE886aHVUC64wPlKDgCOFIB8v+GroyPdHOBjkI4OLn4wnL60Z/XNw+0zIC/4IaH33m+yxdpDTBUbyBdnmQ7ywhQaUsUwxD6le2XWrvg3qJKKIgMStklDZAC2amQj3M4pszA9eoH51ogiYgHAdFlx4l+pIuefoxSi5GmUeb1wltI74jKScfhbU4nw/it2lpI52VxI6Kq7l/PpnmPcaiCSJJHX3/c/2lY+mLrP7FqgBuGQEabHf73j/4yD76YbPP/co/gcnIK6+Y/Y6Plv3Rf/037ct/7XvsEx98IFDi+rz58iP72Pd+xJ7+6Nfz9qVHdu99BGSX2DKlgZKdbuleA693KlS2Ttb6TmhPgazfbyGIX/bLT4CTOGrAzMiE0YXsbcEh7jUljzZyXfceeaCLQSWmOOADmuq6eLNdk7CgPCp4AvC5rH14YJm3RCTW9JroWVR6SVUNjRX/CFwzXD1DqzyhetQVf+tCN2cpu9viixavEoUIzEU86D8n7L7QPV6mczZhpYsUaomwiSxQ9ocwxAHmRalIvu19J+k35DoyJyIiilmQ64KOjrYdOVoqUF2B2toNC/puDfdaY5/GPd+g9oJUeegZ8X7Ug4EyFfml84cBuHfV3AjxOTpOrffgEsa6AK9YOAtznlzyj3552VzvsUB5RSp0Pb+8ib7BMhKje4gAEb+HriE7O56sGOlAO/gSK19ZdLLEaeQevWNzwro0YruebGc3zCUVT4utalnerOd32AmMIdgsM9KPMHbmIS/HOwhiYcGE2jvX47rFP63OewTwKIM5KqYXoqkQBnSoJbATcnZME2nnrGPGsX/UAIXamy/aaN/BhYytQH0gRwPsl+hB9HbJXMNQsRSbhzdxIOB3CY05445k1P7uMNTNA1PVnQstdtvIuZ3FekteCtEy7m+Waev3j8asRLIomR5oSiTqKSdKgBbhWh+RKLHDaX21zvz1j150xu4FgkVy0L6A+2mn93ePug2kJbk/s3wnLCXWbEfBOR3x9eR2V3rW+9fudO64NnEenEzwnb2VahVj6D2eU+olQrdjmZAD0jUua8z1fFeDPQHZhReHJ3Nsh5irFIWDuoEBySAxh6Qew9oNmGx7IXN9YxHD42gBOo0zUyCPfffgzg36pJhUGsZa2YZWQGhznU9H0/eC4X3hYRLnFUO/QdnoQ7HT5KO7hNdRcl33GkCqUDb4+qtuH/142r/xxx/Ziy8Nf3QIQO/8854nI1fP6Fe/bPZdH3vZ/uWP39gLX/q0PfnEa/3sMu3Bm6f929/1b9rn6sf9hS993u4/+VzgVV88GckiqVtMYIsEQtWQqhI7d7yy2WNxFnlEI10XfZ8QudlQR7ucXwligHyliAYbA/SEgzQtorJjSu2E01ZWEwAqSII153QYtkGXJrrRsrq9clDyWkhpAmc/kwgAx2YYW2aiwYqShZx68WaadF62HvyBbpTqJh/DpFSDAWOqPSVAViJ77gn+myoZp8R16XwyxUNCFQLw67cwNQtz/blycPG7MPBLxCPOPnzF8lgXEmOYXRCgQH3Cxpe6zuvhBgoS8h7k08HcipyGGdtYZZZ34YdDE70xPps1/tctxiAbrmd/6dnFacbSdKJTTB1TRNM3r7tko2rz/oa3KA2bTGKcC7mGhMrnLVJKEXPgCbaWU5yE8Bxm8Y5pbFL40ctE4zlVYJJ9MoSpFYOR6hsrZgNKvpmLFcZ6iYUYZLy9ofUcZTs2dDrNjOKMkqvvxhzSOI4L+KgSYF8bu1eIGAMjPgBKYlqCwF7dIA3pWxhgooWarmoCW5cEXEo3F7kvoKyyTcTOLjcnnkFy5+AFhvpbC4G5Hkj/JUrBJHEeAARDZed/hPIYkxoHR5jjrxqi66IdJT8JcY79j62mYgrN2gaRyWnB/YnckRTkItgZPAr5eiRfygXCNTATM2hZ4FzMk8U9OxwoftCDLJI4qXjWDzA55Cau9Mbk0cMq5WbSz26O5iKARUNTmz8M8xbAgr7cijD4ivfSc/moCPhYjciwtWrjGIURyFfCwOOJWSy6g/wGLR2FjDKqzibT8IViBJhWbIqpQVNK7bn8kbsgnkLN2zkP6lAgMBEaa5WwsdSSCCvkrdv3ff8j+32fNfuF/8fsmWc6IZkRrX8CkhED2+HZZ9IefvVv2F/+Xz5tH/voG+vZPHj0pj148KZ9zw982m+/5Ws39594YrUhsucsbrF8myhx3dPB9h2IzuAHFLt40dNN1ws8I88oeOFitUH4oSskTzo/HPsceGGro8O/htBP3ziWsnegoSwGRTFK0EBv2wlxGja5cwm+UbcMh2U2gQ89yW5ugv3ZKymWU2Lj0H22BaaMNMbArKBNYVb+TMUNB6AUcRidwHp39i8CrGDZnqdcsllSBzX4w6hXnJMFgvvH0rTjYza2zzEHSpA6rG1AamDEXGsfpypnM2zrCrPiiMP58hzF+hKHkXngQLZNXAHML9IuvSIuNZaEnx08sXvql3TEhZ2cXZw4JUZY1jQis9ykoVYVRLV6XmC61q78Q5Te/sLr+k5E1cDSyaA1pJQljJIARqIKvmaBLUuN9uo0xXr+8N0DVGFngkzYXolO6/yz2OCIDPTt2U+79NSHvoZYBKwHitfdE7iO6qQ/gQQDQ3AxaZzX2zoa9ctNoYuN046ma30bA32vn2uXHP3gghIvaOnjpMPdw6uW/bu1TJcaR3Vtdm0Hol7Olu1Kzk/Q+AKZN+S911UHXmyOBkhzMpqYdj2CE7pXIIAAzPO586TWc6HUcIhvEdY/0OfToU7Jomsn+pkgRocDpQMFck2q2XGCKCCFFtJXHR2DMzr5CHSMS/SgKzLA9W+tvwh2wJBAe1B5rYRScmnhmebuT4vnfyx/ozVbtLl2OJX12Q6aVQ2qDWeJg7CMQ+qwNdyKtKmxbDlaUqkX/bK4PzG72ARbGShhTmbtMv4wwlNXN04Z1emVcbEsC8ClxoLWLvo71+zOFSCPlcgttdvr71BCr0ubTvLgUAPFiUgOJ0Z/NWtAB/ZZFE3pDHJ5fIWGuRrMSERqa9pfEf/m2Pc0nULhZoRHCFEVsHfPaMaS+qyMn9cqBrbECRA5D9oy/lsWP4i4cVP2Mz9zY1/4wiP71KfMvva1S/T0G0NGYh3ob/M/mTyX8RjK7NGjFj25/u+VGV1/77i+78bsyfcd5v6YeTxmEY/Zzc0TVnljX/jci/baq4/83r2b7jP5msKjA8NaOXHtHvIFxbNAIk3fe7AmOyPhGEvyCHBSYLs/6s6fwhmKxAUuokmTIK6eQDOBWgLA+rryXKjzqjREcGDVUG3r2wwTjLCWeCLIa4CCtssSRHbZGseZvjp1ktB0MuIm7Q1KNaFECnRvOw+7cGRfBFQQOzvX7R0R5Uc42zMCixmEmsBh7AQvBDfnHVDJqn8gvCcB1NE01r4NNR4FdN3Vkewi7fr/sc5pJ9jvkKm/9uyBpkFsjH04dPQa6aB1dTOpihDsCHtvpPVuQ1bjpsJCqUypdpMtELkZB+LuwW67i5HEtHL91s1WlKUfeTbrwQX728HjwwCKdpJ59Ei2JKHQ8emsSgbzqIPQXF5tQbjIHX3ZabtBUB3rSy5lgKNXSxJnLOaYaLQ3QxGDIU4THNf9uU7Nq4RcjtmQbZkauftEWQqQKGRBckAzholy9+aWA6FvZ0dIXotKXbp/PDr8qy4ZuG6doi4ubeulm0dxMYFQUXRuKo4qRa+QCsjsNnF+i3GXcTpiCCgjlKbtQw3XhQGt1bLgMQe1tt5TEYA8O5JEC6du8elCq6Kxi+Z6RlNnV0UWeP8zz3sF2WDnYTWds5lf1dKJ2STr6wePPlQpX00BLTw46YJ0R4msTrzWaHAwQNsRf5REm7W+HHTrIFCAg8XXHnbo5ZwGlfHeAWxK9GkhzgP7lwD7riVziMlRa5QaJ+wRLje4kC2QKhuHWlH361b2GERCUwCBIyXtlnySt43IrxiMzkvJxKEbSu1WzufHqQK34TFFQ97N5ImNkNxdtzZLajSFCvg1StrMNdbzT2JloAawCxodf+GhxikA5Coh0ymoUpCLgqJ2PX8MNTjXbqegQXuf4AEch2kUw558quxXfyXsf/qxe/bcs50DXPnBN/KfuL7k7fznwQOzxx83u3fPNNJ7/e8PftDs+efNPvQhs/e/3+zhw05M3nzzSk5u7IknH7PH7t+zm8cO++THPuVPP/U+e/ID56VBcns+SkhdrFTicKGDhnS8SEGtGJb5oogE4DAZCa3TDVp2KeHVDr9L4wwrJ0kN3ZTmoScYKCYOlHpGblIfDZoaDj9XuhlMMPpYD9dBBRC8OPMC1L1Yhl3Bg6LmPQYDYZzelZml6RbAKBEVa//hS531REvZJ+hj12Ge7Y0P+hzkInsxQRFECYdQt2oOkyZ5O2uhrMpVDnDrX2MGl/UYgFkNHDtP684GOTPXfW7MJXSecVmnFt16+E4dlbwjMZdDJfH51mVtdsx66xytXyhKOjti655OPHOoPdDkn0YtXhQVYXKXtD1Dt7/o6IwnlIx7ne0kym3IIYAuFwQHwJWIEs94paQhpkuRjiOXZkd736RBI6SffTfDWlsPMpL0Xiy45t+S/ddNARA3g25zg1Tg5CS5tO8jOOVA3hNce0iyBScEs5CtLYMKejF2aJXEWfLAIK6qDACHix14EpRsjkF08QxLoALrBn/Q6srkiJQey37/SHsI2ve0f3GEhotUOHmkeBfGY1r890E1kdkYhsrE8+TsHE8M4BSctsf+pNCdQ6+0ONRRiFHw3Anx4xsUzN7ULUrbJ8haP0huWy850V8uWp/1smVVlL0+MQRiOJDVl/Ve7P1Hx+XXx2poZVTXHs6V3TQOhv2lZrWEvIgwH4HUvGggR7UADvKk4isD5VA8l5C048BMRWUmKQuV4Oq5EL5CK6G7Jnr4wHLW+zvxCtMxdNNlSUfoc6TPsWJY8xnMELrN3Qjx9fM3nVlAUyLRlS1KHTIzbawyp3iE9RJ+mKpmufH+4WLcNVcwLM+QVg/PBKo3Z3ENl24WNyywCZPw73BWNEp0oAsbmRhGAoszwUYJhuvP3ipXyeQ3m6Adq6q/+tcOe+lls8ffoin2bj43l1jZ2/lcCcaTT3YCciUmnf2aPf10IyIXV+RKWl56qaPF9b0PH6Y9fPDQHj54tB7OV77yZbv/5BP2nd/xB+qr7/9p/82XXzDPD/TkItVw8bwIw25Tt1UEr5293e5aS/EZEFXzHSgyXoLPOPla25qHONdsjHLpkkARrbvPocPZR+dA4zRUgPee+rl+19h0sZRCR72BmKsUpXy0uYKqsZqTJrDT6u/KAtgaduoSi9YKygXNpaE70PInVMyHcKRzUGKUGEAalQHDhq1TP54yTqhQueJrd3wtY+TnyufM9rqwxMUslPYkhMtKmlkoxmOScUyac9Cp8Maz2hUcdDwMs87NpETrjQrUPGOaR8FJY9uO6eR07xbUma1tBcdYjpz9mJlSsTij+ioPwj6G1vlrhDdUIuEBxC7GKOdV5SA2dAEjAoiF3gtGx8T2/Eny2yJUZ1BEoJhedaMCs8z4STp28kio6WI3e5a5CgzoeaxwsAdKXmxHkArFeWeTYk2XslGUPu73wUxOzLti3t8z+7vAEeODNOBL+wEJS3aut7CRfiHJI3q99tRACXrzqHONYJswv2DSML0WvxqoQcJJgZFxFk+YtdqyOGY1JFvTJOBdOoijwUjWEzkH6GRA1F+abM7BDKomeg8CHZykIIGD5btxxSbjH8QQ0MYUlIkIiqXklCSFm9PmVmHsUWsQBqLyc8xzhNUmfhB63Rl1DHqCmDiUZsXItW2K9cTWablIqEUdRAzndWbK9Qf0FtH27MjqCLAoEwJqpRiCJBYyg8FGZdmG0DA7U6WNjbkfcboC2QkKVc5S229Zv4bWlysh4bng07MKUJgplOREkkkkJDiE8WYpnDDLdiKZnMWqLbBQqMjEvvXjXmfGS+vrEMZ8XePjT5V9/nOH/ZWfCvuhP5z2D/6/btW862Tk7fZ42KYxZUV9QRcScv37KyFZUEv0/77U2Cwe2esP37CH54N1Cy+98Xp53LN/8MIX/eapN/zezQ3XsQjanZgT+aXibWEOGsuQm6ObcSP+geXKbyKPqk+1wJ4uCHMEtGKgpNPz7gbtkr5PnUbZ+VGZq9+5fHL6MIBVmuREQc7qwzClA5v0vUowHFGUcUZCpbop2cI+vBgDeWc4rsPIuYjfnnDri85yMFgGuHvtTh9dBt7W2sQ4g6kTC5ZcOboPddEPCOrgmLkGKkC2bfIWIiz0DjcqCUhceNwjTQRT9syELS0YMNRBCPqDXrd2HRI5rsi9/Ig6L62T1vbvVN9NzWs3NtgNgi2a4IQ/NL5B3oJgtuKFLX0EpKHQLqcSRGF1jPCbxvyd1we1C2x48KSZTInJDLV+UoVh9luEZBdctcKd3AUMA2bofiesd5wq5a2hm3AzbdCM+RAHcdWFqQanqVrOk2ZWPUeFW2CX80LISopy0jzwkNg6/G8XhkZ202wmVwdoERVOpMXpQPdm/13/c7UforEgtz0RsHn69GzbM0+UATOrRV6gk4KIfohGhkCiTPJu+/kBKAQzaB0rUhgggfVYPCYImIGBEKh41mSkIxWHzWurIhuMibpHcGgCR5wczmljxldbYDwUKWNI8ysWM9nVHW4FnQBAX9R0HicM0xD05uGAKSFotyogrW3T6H7L/DLlP/FQKreCrwgbHEj2lVkX4zVGRQqWLu4YMNnbwa0u3WU+E2mc27EiAAAgAElEQVSn13OxvYO8g1jcVjuVufjs3TUzTgL4HNOk9gyGF1LSu3iEVCF0WkP2nl5mvWzDTzJnlC5BgdsqOUblnmYpivrXSCPfPQGYOmk4gP3NBc9XlAnkZcW/AIZdzCrbXa1H5+lWTWoi5PRY2vJcRTBvkWCvPK5hwrOWH9FtMJntz3XGv/la2Z/9c/ft+7/3DfvYR83eePPt5RO/3eebQmB9/Amzr/+m2S/+wo099eQFldyuW7gXpz18/YHFb/yiHZ98pW7vPw6+jp9yMnCNJPZ7pF5DQTjVyGe15kR46szF4inyxDeUTnblJmkJJBZ+MgdqthBQve4QQZO+a/nWjZFgOiZ3HFY14g1wgxxdXBas9/o7eHi34FEHDprxOSrkpDwNxYSBN3h3HoEZnDjzEFscIu/Jv3+NFtH63vpQqq2kMHlxYHbFpPGGuyARj5AphZbwyIPs9hHyd2pncsgssx9GSOWxOPLbnTbEEaBO3GU9lh3Adkrqo67Rx6aO9YhJJpgu4UyFCnoi1Zw0KVklRjyWAQ1kYSRvaTMQ0hO2o8XHYoMzWAFSXHv0cIlptMs55DLQivcIrcNZKZwsv6RpxWAHJUUb46gY2Sko6EncziWpVw668A7F9P220+ZKrdbL4WQtOMfUG7hzLJkNPdMw67Q6/BFO0JyQoGPWehBjqXJqVuy8MxiCM30koVyFL1MxqdKmY9ZNgPrKzdaTy+QAxhDENugRB98xvdpeepkjwb3SKVgQ+S4tHm3k3NpQBrWnvvNFQiWVzQjHEJZF0YinRqowcJVOP8bNs5hXrb1EtT2xiZkhS8kQmcpKr8D1Wns4m+fadk7VIrYQx3ESNMm3Z5JWNCHc8C7CmM30WEbzQBaQ5IVBxzBmIKnIGReTmrhmYmczL0EvnnoLEGsssqkY85bOWtFwr7nCQ5Zx6vcA5ZzCD2OKtc+LIFPqkoWjQ4TqQHJPOEGwmpXlDtrKAK7BgFpYIF4hpY6gp6RVL2kq/GQWVKX9QDuEWEZv1RyZZ9PkS2d7jUjMmGTPk3V8kM01cx8siLBxPDdEVpyXPRUxZlDGQXlancDpU0GhO7O3QuOr7NVX+gdffWlQjF/9/GH/9Z+9sT/5J077tV9/93nDe56MXO/gA8+Z/cSPP2Y//7fu28c/9sDsYf+ZPzrtuDV78uaQLftCXrtTtgY8OXLKqIlAblT6c2ibUtUCm474vG9Ytw9/G4rdJrV2jSCCxMTFHDZaQXA8xLAKqVcsZcs4ZuYXyUSUqMBYpKtemaq2j1CmA9QMcP00p+HUbE4MshwGbEOa3kmeI/cRCybIlGeRURsYSVq5V3DOzGlR0XmfFArDVXlqqp0SHJozEWgjre6r6ZLE8Pr8OwzTGCpWiqZ+0rqgkabPyyjmhv09eSJKEFkM5w4zSRYR2MHPq+N2PYVutXalHn0iYlOyHHG5G5sLpjcZabNqlhAo+nFoKsFfl/15bAJIgCEBTcz5B1WqCm0j8P/FceW8+iIleMAS4Xo/QBucjWnWmLL28GkAmcSzOuNqiZcDx1rNGHS2+kFhcqAI29T4v3auLBFTsBeJ9qcUtfj3J78Y4C+kMgi6L7keiutqxgKxIINyBgS4zpyrMnQIaAkN7EKeSA+jV48pGBSCIdDPZy2KOFOe3sDsgfVVJ6yUoGXeF8v0PjlZ512hFAFyHmPqwAk2U2vWD2dDuNCXHIwN0+27Dk6gPVC6WR68xgFadmHXg4SmyZKaoIK5a3cQkmeXE/GRiYBNGgg0BY5g/TSD2uos/abgngMRdgVkdNGdbkOPwMufV7CKSmriJxZn4IRcGgNZs+iKF40NQO1zHg6jJl/SlUzIV3YgOPFTGNCcgBPqf6dMHZuO1e8a+iTFssNnAHqlOE2I1rY0TCRrSROO4ZVCcM7p40DSMSi0LKoC8rB8cLaP6qqKMD4hV4XDFgKG5Eudt6n71pcGStHbiwlflkez9dyO+OQn3R6+Yvb0+3v48Xpgt4/K/tpP37O/+0s3i6rxbj/vvc6IXyqrZr/45qfsme97xp7cFFiv8aAHr97aL32n10eeOs+nXm/4gXB+cZw6DeBgseEufkVXqPSjWe2TXrUhFNpgggABkNZBOFBfNng4wBwnPEZlda1RtB+v8jwYAfUh/ZDi570icarEYo53yn1ANBTznAkJCqcOg4ErRZjMOYtHiWjn1u4zjf14kCn6W1z/bHMqSTECo2MX+bXX53U7Z9rs1wKZC39e6iMNEwK4eYGc3edAqWt+R8RT8HX30gbJF0igLKdkRMguMnOrZJR0qsU7jPYg4ZXqP/d56RCg3Pqxm13xUinrrSircLdNIgjwtfx/BIii9k5gmneEz/vvn21Qp+EJA4rncAFoiIhUTrzARMLCU6ja7pu/GgOKFWjKif6BGzyBMMHefWsQIUfocg2zsD4+NgNoYz1ztLyGocKD3Ig9y1VFkxZpzIqDhXsnAynCzLrWSOiugHCg1jSXvxEkQFk32F1RWqJGOEv04rW/OS9vI/DhM4DfV5V8f+pgzGmlcOGYeR9SQOLeMQJ9LTzNQzFtaEQlxB+jCJ+54hTqToFkXRfBapYFi9kmGGg4oZtPBa1BL7q9FIZ6wKdoXaV1Nrc6LgCnA77ThIxYN5C8C129hRuRT9tJQwAjNa1/UUm1NDQWi0JCmb9WzmrP+YIMgzIsdBE3Y4ON5zVGUMLkxJ2LfG890QF5Bgrd4znlJHrZTiDqwSLic/pf7wu9m/Wnqdm4gpqyHjSfT7Om8QNdlSTVumkPAlGhzgACiQX7SGsqIbalWSkRVKe2neTmSXIizxlMXczpp3OyrHvLRYZyOAEVJngmsSiKlF89tHE8QXseNxAMB5HUlgUdbG2etZkuBTB75aXMT308zh/90dNeeeGa8ph+zHVXF4/09df/SfKmKbPnnjT7+c8/bZ+PT9rHf8+ted3f/rzMXnxkjz76pKW9FMerDM4F5M8fdX3Z5GlqwiBx19RRksVeFBWGrDXqI1dLVNCzeBLsxzLjROLrHEalOKIpPtQmCSmNOzWl7SydEcaKO4Q6WHD23njFBmAlwE3oNlMUSxsGaMBAkXSc3AOEbTzeLanhsyBc5CpnGbxNowg+Lw39CA9OH6tug+eC8+6Bjha7GsxYVEAVSnmIBnYmhBQ+g0ps6GokInGHdcJYXnr1zlCtYhthHw46LhibtNe2jaF67rGo95S0LtpaWYioqz4M51tY3JOvW3NGETLgo3NDo7ZkiiVlbSEWTE2AOHDkks1G9NY4XN3vf8nnLg1IOzPZQSNlcCQmTA5EgqTZ4+diKaEMbpA3dwotnMN9FsKNhgt7gFboSaHCY7i+wyrlOqpgCkrLtrhkKEw0LbB1xoI+9grR9p1JRmk30gV3wKCMCvCkKkotkV1S18iqymM8oBx/sF5kMzPJ404tV4I+a9HF5OuRs1SYkhdhD+dIDebmuApYy6v9QCINbibVfQiem3VcDiGdVMkTgEFFmTZxBYMwICLggaMl1XZNxQIGBnFb0QyrBIdZvFKSKIC1iPcwmO64NKmb6qtqIY6GSaJejASocapLzh+ALwsIKkfCOpMGYril8OaVdYdwpG7mQc9RT3VLPGsjjunqhyXobEE61sRZRA1CcomR3+j43X93idws8cZzDRGumafY0EIBTEjjg8YJ7FzT/UsglOIHdGD5soM/IXrWgNiALFWAcTgT2Zizs1zsNXCjJwJ997R5DHVlteha50WYefzeNZRy1p//X92+8Etm95967J0nCP+Yz3uajFxM2jcfuf3k//YZe/Vzb9rjz72ph2VwZnr42q099enH7Oa7j6z39eQZ25lNVEICTSdXmVhz7SdKUhzmawZOh4iUoZHRb6d4gE2RnDzAicoWDJvpZmqdLDfFcg4K2IApOsZYa/XiTUwLwPKVowt990Y9SCx9zN0S68AoqJIEh2KZkbGAoAfYAj3NDopBWNpmVzJZYMEAuoyz8AU3wrawS7k+pnqEUvjpkTQnlyW2PY580fj01t3AgtUVi8E9XxXzwWQSChR8KUWNygm0FE9qoo2pZ5DNZ0dBheoxSWLrizp9ewaDahgJuNPqa4mtIuE0VDIRVTjwdNHzSqrzQUrGa0AkFrZi6avybSdWbAgkeS3yIW4xwnHCWK8DQ7QWSJnkTjc/cRMBPuncg63D91kq/O4A/PhRwi+lTg3wIz6ZKeLWsN9+xvpcBlMV3Ql7ACgcxDsqgTLXLz8oTgh4TOuIpwhReDbmDzQiSJei+ikZlUxSuTvZDhSvcppLfWg52S8dX8LYjCFbwjRiQxo6j5fSs9HaNybZxs4r6eHs2Q062HfNhLH9Pon5sa+pNsSgVOp2IoQZw4MDM2JnYacu+dY3w9+X8qnzNOsLWv/3mOY150Vs5hCx/+MOJmt7wAfv3Nkxltyb0/3TMXA01gLQJPR5/xwY0GmOQX54N7SJkuRh2cBSfqcINtNrxD+TC9g5+Vbce0g92PzbixEuCvaaD1HG0cqRQajA4F0AYJBHd3qDmVbq0kZ08BRA6hMpRIsAsp6UJ2Fi7cQ9lczqZid1bh6ZT58rhi5GWHKRxCKtTfUXdfKJJ8LztuzHfszta1+0bwrd9D37xuspve9psy9+0e2X/9+HdnP+pr3+9brzdxaQ8Mjtf/9v/qL9/j/9/vzn/tXvtnwNchywNNZw9Omcup1cbqvFSkO4/dUb4MH5AuUIvD62W5dgzuj1dpcOSovrL2/j1ButUe1AO9q6cxmTTjrRuCO6iOySpwI/L9rIC0PuHqIMgCtK/gKPd6gYJbSLaH9OGO7QIiejDxSY5B2QAdkQe0lpVMFOAAcYM06eNQ3gpVLImXQM0s50mSvK93adnBJdgq5kME4An89oBYUiFEXgM+DJmfuglKgFG5RQisF8sOaUroEoAvtRGkMxIKmtcYsMkIs4xCmnxSuLI3PVncTMtTBxJd1vzCXaoJEIJJJ9pQm6j/M0cUY/kQZq8Qgm+EMt8ZJGiH4p2b4ebJjPTACYpb2iajvltrFmooNhsv40DDWsCq2tZUMrFmMYzp5fQRaty2xKiyRx+/6yw2GBYWiNEiFONcJoFLKrZNj8eS3327UwkxW65pQlf7MdtK1HA5b3RVc66dmxWmmMzSJ/lbHGd57pBFo4JT6nlnEsrpy+71AUNlADNvJDD/AUT01IRWW7I9HbmoQhZ2uFyVawXchTMFzF+Qas0BBlXipKibYBoqNhryJ0fK1HgpoU4G17RycSI7d0wf+B7l0S6dyyRBVeusQhREJ6iFbKYDiwmjeYSmD4FpdkSgqB2bRiYNO6qbjTCirQ3AKIQy26U/tvAElWSOBpUTMAA8ns1aLOVM2GgaLeEgmN0oDmwGrlMUaO2STSWycH2LRIC9uKHJYlY9vuB+QdSkEexI0NTtXCU7ZCaYn1fqlWTRSzyJfT+QU96KIDwD5CbVvORHgYP9nFmLdNXp1QY1hy8HVzeH7kw7aSkaefuXu2vxefbygZWdXiMUXnh543++9/zu0Ln/8Ve9/H0uy30TDJW7PXXjnt95737t07DnuAcN+05mONeS+1Pj/x8LAbQesMFDIJr/h1Hbl5HxgcBlLjN/1iIpdfckvu9NWz89cHI/cUWeym89boexbzK6vLVLVCkAsIbEtwxsKTy5ecfoTIJfXkPESID5P3MOMNDbmshg3Z8DEc8t7NCZ2D4MLjyBhO7LNj/vplBxwYlPOgx790JMEStenvdhhJkf0ACiVAdlftMhW4kXLCgLlJy3cZ1/3VVujHziFezam9rQ81bJBpX6cJcupOF+/fWrFQWw0HQ4GAJp0q8kVA6pBgymJr9YClSyBl1l//KApdnojNLyIsfCegKG+MxFzFEXh+XSDyLKU6Bkxh6S7Qd53MldGhQtGvzBbxkzACGETBt1hkYbEMJl4MsOEqx6MWX7b1wkmo4GFxDqmopbD6xiQpfccRDCcrjB5bIwoTZT6C4nQStEaLmsQSvWNj1j7Y5xh11FRv13aFBjW+nu6l6++Hx9H9EEGYjO4zb42ke7WvkvRjxxTO0g7tRAEt3gWb46gtSO2tplEKpDEw1Tg7st7PEhkpVS1BjWgSOLP05xSOoR815zH1LnoYjJUTaogzKe44syEYEsWsD0YU9ZA47t4hoN/vSkISJTfefmcWibHuDnBRwlB7FoOESIF0SrzXU3DoAyw+fqm7LI06rE4w3ZyD9MGIudpSdGyGUz+cJHuppQK1MGCNe9W2QNSxa7coh/OQwyi+4Pi7wsAlwpklFTLxhxR1evP2rULHBg+BsAnr2LW/wCcJaBikcw0jHw626vkfAk3rGlZ8ZwqjFLw4QIDE2NggZHwgNVKasKow4AlJaWUkwMnW57W+Q/XsBT4fdQmkPpbvfQ6izzeUjERgaYfZ88+a/V8/b/Y//ti5GJyvvqbodOdTj2xN1yw5UYTjkEpuE1JHdWnnnQH9nES7C/4i5XGAxDYvAJsOWBtV/U2VbquKwtm2F/gBFcwegAE2M/wRgXYJWttqjhItRioeS87LEJ9kTusbbdLUlSpty6IokpPd15EUI993zjcMJHRAa89M8EDxYyf4MHgCzoE4EGlw/vXZdQbkHsFERS0NE/0dNMXvHhgeujKuETv2uBgmakMTJiVDhO4Q7A4hnyITgKq8CCiCPlR4EcMZe4a+GurHNlJDmSnzleIms6HrW285GwDAM2E7OjUe0OUaKLWIv3hL0/D1gkuzvvfgOQBWGLa+kTSN8hePSf5YFKjniakFI3e4+We9OXwL6NAt+bJM1K+VfaK47mMtEK/FH2WppoqQ9W3Nu6MLHjBjJYSkGAFMdIFvKK+zc5dtW6ijN9PLW4KwgRL0fKosjTH0ApgJRcdmgdQE3n0jkswHgIklK5QOMNNLCJrHKRp7zA4betkpDwLfCBGsUNsiKTAiPyA6NgO7KQtINRbQ/QfnQIwSRrHhBBgV10TWmktTKlraFcQElN7RLE1TnwnFcOoOVxqFKPQFWwsB9C31gzhcgKhKQIAV4IITZstifbXBhhslF/H924MuDZsH+CJEfE7hMUXYkHJQm7UFAtXMv6gSmmYW8K1WzVgVHTlyCxpgp9PWnyX9zfeGJsmHPt6gZaQHOqT90JQnEs+OWlsNMZHUGVJFJy8gktxuw5Kbk2K8FMQ+kd4mqdIhlxP2RK01tHHkoXwUhkbdFXfdkGMmYG3VOtec0JWBuMcZdnVSp9T4Zn3edTLy3DNmP/1z77f/+xfeb0+973aps/79z7l9+ANu7//Wsszf/rKvI/71V1+1iHt12xIE2XrIdcPjpXx0PWvTAtN7hkc6U3OiqWqESMRTc4RY/ej8HFDgIFOabo3EaKGFBGR4kgF5VGFZwAWOA3N4pVdvfwBeJPndIEjqT6rwgCW+E6p3teHBc4URj4uuhBkBjKjc4e4LbgVVrJN3CueAadnjQUlL+u67GlGC9V2bOGlpH2mwnf3wNe2R8EFxYe42FVKrJjGjWO7ljKD9231zQqQuxvRUEQwaMJFNYfct5NFm01bzOyKewrevgrZ9O07jSKGJLWhkELDcZ1OI/TXoGkSYilTILnXCmbXllgwXYOnHaKQ6dU6gboS2T6Gg4b0GGXcc/AagB/O35I01H2d6Su3wa3p4W4dpWz+Jq+/9kRhjdZcvBRanKFhV2lqKY2R4diWYFKLCDgn4u5C0lGNIqAOzZnplrtgXGEwGN7Cx0sbaJuTxvsRbVDuASBfFe5k7u5q2AJ35G9BOxYDLtPpO9ug4t6Eq1IKiRShgcuGbQ7NEC6TbL91uWjmisXurfLz9oJ3tKCnegPprPMhLs3PO6AbSIXorfV3DI9AbT7G+doYQ/xasro0gV5P6QszkXtaUwWCdTh9rAYsbJw0iM8s0lGQboBZANopvkZUhMzzS6UxQa9v0XINwy4hmyW5V0WrcBwQgqEbuxorL9KNCRYP4zlJqgOcugRstb/fPTg+5htYCI2qejsDD8adaMjQQXmy2P8tlWoXtMrUqyGCzy1iKvJGNFXLgbANDGJsI+yjscwMEKnJ19w2d6Y7/tnWWmbIYaYTusgoGYG/AYwgyUdfg4TvPFN7+5x0nI5d532M3Zk/f+6z9M9/xZ+1bP/Ga3dw8XPPFP/R9Zh/4wPI//Yd+jnrM7CbtL7/xX55f+sqX7fnHPxa9lQNAXy6EAtN4CKBBDSXTKbFaWvAdOVQ/Ozrcq9S5hdnFRXgDo0KtCXb3ShUZYhrwqwYvW/j1sG1dbwC/3dFrDGX+q7cfXS2cFEVy0ED2YjTSNy9txOaClS9/izTRoFORyvrX/lGFSP0JtCkwYnmttrPjWl5+xX1naaK7Ix4FGy2OmRXjNObWF4eykhP9w6pPGUsxzrWmJ+J4ZeujrqAYGNlmbKdoPEIilg1CFMrENNn+uAivpCRswoQSjcA/tdIm3CgdjDzjoTHqQ+rzhmCQ/fSlWkcpb+MiLAL2pd6SJEnJs1C5RNWzkVlvoP0s0s8cR3xnLQevCY0BauP2sYzuOcHYSVNxMq1zYJM8pxSHCmo31wQ1HjWt7zWJu07UlDsWAWIivWoNgZPpINBA0ZQcPxJZZDvlJEWzh9oROzgaPQJdM87EewzQPFZ8WHbrJ/z5mP5jL5QScLxyV+7e7QyIWsWoA3NhgyGClIWDJoxoJb0Hyi32bw84xZ5IiYKMrzxsCN7umHs+HFKwaePCMCjiJp+p04MA2RI+zM6z0QqVKOw0S7Inx8pn5xSMYUcUeT3fpIsGdXiQA2bf4JoY62d8+l73MftVw7x7Np26JEnoyDcp61ZsBkLYDNb3RBDajtc43AHtO5c6LMfZONGTDKgs9Pn4NqD2HOFkQoPAI9Z6Kha4HDF0jg8BLxihMOqtd5O4TqgnCbToHc43hmKN8oXKz6FZJtPFDIjf4fkBb6JVFSh8VHwu7h4U6FTF4ogOBnaWqSW6pZiXW8MxJOoaK1pXmyEUA9UdXPqCt52wJXWDv1mfd5yMPHnf7OVXzf7CX/+gZf2kPXH/N6ALbWZfNrPP/WO+4Dysbh7Z+ZkX81s+9QnEwbPHB8qJ3BMc2A8czsxyR/eUAWzZ2DAgnNIQnJO0v+GdpDkSdJmdnuTPMmchEGPQoIRtMXivVCsuHcCEC8f71sFfQbMpOrSNFQK0BBrTiBlk4KgHSzZiFjxRuIJm9IXepltcAJ21C/JW2UDUYsHb5WVKXl8Y1EZ1UiJm8BnkZGHvCGKjYL4jfaHfqnPvrk/wsldcW/EtgopsjAXFlKpIAlo/cLDZD3oJCUR3Pmpy7COdQSVlQUFzvsF9fpmEq+nB0jILitBAS6SHxlsW5Gvq2+iLTQmAa34RTwzPjZPDPg+aG53FaV+MhhHUjgcLPgCOK4fDWuipD9oBGBR30HLRBzzMbBdAIUGl9YTEaghPTBg16iS6uPGs31qPppRxskW26IzNCE2fN0TJpwJ1jpoKbpMr2+ZAJdLH5aDZt+09M/4GDgry0HVWFpVtiCfFDAklivngi3abB9QZ3Jo3l1eUdk+xi0SUuMmoYoouwYfmnZJHGi1aA+62Kb1tmFNNvCI9vlznhnOmx3nvknPr8uWwjdzJwsd4AW0gG7PVJ6szShWuMqtqW+Ekg8Xo7WlJYm3vWX1bCJJ2hh58LrR8yjQ80KInVRdTTrbgxeQWUXb9SCjszuqjO6AgOSuTOJpqSdR5qTtQfFKjBEAUetp94IMAoq4nPRMpi0OKTydZSbVtBVOFVOvHLnrbDE4Q0XcEcE0c8g63v4OxdAB8s8NhrwDEz7WTZxpIxHfbzj8GuLa5dHoBL6W5t4Tb9/jzjpKR61qefcLsL/yNT9hf+Kmv283Tf87C38FXXF42Lz+yz/wLH7c/9MEnjsfzMTtumEpfS+6GuqjHgJMDKFKcKUEjWWv6WPO3IPoA0kDUjrDND6ST/NXjCEUa2zj3kHJy1KqqH9b6PTPRKg11JHGAQNZ5P8SbzG+omsRUrBg3HdZUq/DP2Ue7l8da+QcJo13scIIB80WStuw3RCQaWDqlF1ZOW15HoinSSTB/WT+BRI8laEsv7YqR0QCVCp1kWb/0UtcEhTcNJ/hImgTMcx9GCZOTCwUqsFzo32sEPLqnGpg5XJzD1g7VzxaFzow6m8bzvITknA3DLqIaJn8CBzF6qHSQoABYUVGDk58ojH3GdArClmXqmgxxzkuBGRIXJJowUJ9C9MDkWG/KJ2YHUYhirT5IBQWHh3RQW5Q5qLvTNKJyFtr66+097XCORcdMfGQc6sHzVbKlnGxkT4rGi9VAHaF+Mzoly9extuEF8keZdJaxhnN39T49yLphPkJ7KSDLwb5HdRMYu2liDrTTiNNRfwEe1KZRnus7zgZVfa5U/TqrjR/mWfoZFSFNMmJoqklcR1CmIYoIzmyQ9t3mJev9OVRO0ZFIjm/WhgISI7OptjudWvpVJy5BSJ0IR654ypBu1BUcljfGVXPLTYBhVtBrBgdyEP7HkRzSJII3xHq8kUt1Et6VqP2ZpVIUuXu0azlQYwYATEBhN1uzqKcLT+4OWyJrmOkLTkx5kg6RYIL3DuvsWhyh1WYhLNlKaxXw8kqNa3ZfiuQXX7DWRp3jIVHL4DZBZF2/KAd37XbMxQSOnUjeZJbFWRHLGpwO1mbM3fTKUsMCaARcKV5rDLTrlgnAR7sTxXIGHTiDSUhJXxIgeh8ZRzaF7vam0u81q3nJGaC/+k3BR95RMnItzpffMHvz9bTf960v2XNPPSZw4e19rsX3uD34ja/Y6194n/knvw2eMNdDPdI7eQ/iIOv0CqVuzk5NsCxdxu8HoNPktHfTCph9u5u4QtgizqZM3aGMMi10R5O+aLOFiAoDxu7PJ000bIoULs5gbYVmdDMjHE6RHOQENNDlaiYzVi5I0MkPV1XezjUgPKuOniy7SPqTywfTY9e6v/7lQZQcEkBBzThBO10bK6gAACAASURBVGoTg7nO5mouUU2/oR8mU/lkYbIDE6xNeP4Em/idXaIdj5IBmEo0HY6EXGDSsdxxMUgNuIlZIvsgyV9Vk1mtFwrMt6ddpnYow6SMuJmLSR9EMA02OuFk/WqIULfahMKaNzAhojlL0QBVLDF2S+mZb2BREPtyVblEpGciqm2XeCzAAIQ0HpEkZMTZ/QIZTq7wiQY1Clzh6/xlSn85OKPBAdwdiPWIkrVNFXDhYxYW86NuVJjTZyS2yIBGP6efDDulriO80Md2EqlxgoOEQR3OwXR6YmkoKro8C87IkqLDk7lCLCdf+NjYCayHfiM4vdv6mB9eKEE288ohao+uC+uVvrk2WmqiK7hVM2kdqLBTCzWQKFFxFQNpSm923gmRExfQOR1jSvuCZIUmxTkDgEwSQa9rkIaMrd1RVjjCPExeVwVSiyxGQhKpV1c001lrBL2e1VV1OjG6oyO54i0FYZzA3IFnsVoEHR051ZgcwEGfp3MZ5sIA0UOBfiM89WkfHZOAy0aq/cjAwlQ+YKTVF3/A36CrE5Yzl0tQpwEU3GNvdgE6DY9pmFcdZZe1I7FEeHIE+qSx8aI0bon9gZ9yzB6jnzNcgtIJ15sgnSKJ5M4EJXc6jseUf2tfhPuRkKKte9Gn7SyE9/bztpOR6y1cbrz3nzb7d//IC3bvGIGnd/K5Z02W/omv/Q5/8dUbe/6ptaoPMOy7Xds8HEg29ZTmQTbphiMSkQNVjKyQpNYZJ/40kgO99WE56jWsMdV1QwcqmOwinpiF02wWUVBzAIssldo8HFW41jbnu0vRrRQljJJEgK03rAFaleoIsglpuNC+2fNaKTmHPWXtMWdo6kKjrUnKvwvYkRw5Y3HD9oORO9xHkGlMCUbmHUpfcby6LtlwxF02Fnj5eNOHmm4ggW7QkOYOe3gCQ1HEODpLwHJpoQrqwJ3LiY5DdjZpGzUBWtWmRdlY4XNryzejw9KBepPL6BDwVfLq6W6hAH94paC7wppmb56bwl01ylUut6DuBySzb+JMWmtNa90WE9HuXiDk5aqCxvlR1OUkGQSqBy7Wx9YYAq3awArsIH7id+T2lhogYx/bNkIiWHBq+hRI3uQ5IzGuzWq2rxW6MlALJMmUE5AiNaEJoda2q1MYQvlg2hhkNMxYPUH+TO5otTaMLXh6IczttadOLvdYjJVmBGWuulg4gHcSpaNWmhJYAk6i3+KmBP8xs2RhsOmwq6MHtA+3nl3uX+eMI4/JoQf5GrBaz+bsMANQsKEQ2H2R7xvLJppzifRDT++k8jBW+y0px2XjXMicgrvIPAlzBC/aXjVRR7xsbA80OAfJ0UtPiqV2OhoMXtJpQjbHwKU2PFL7hKhIjN00h2HWoB1xjSANrBDjErNcKsbcNLXVUR4SHb7rIjd1WYIzGHs4QHyeDKuFqDfnNU7tsGta8CbEiYb3zYq3N6wLJBNkTfQffC6IAUwlr5sFq9+wg3WxiA8YXKqFklxQS/S27JrslHzVN+PztpOR1aJ5v9n/8VcO+9s/H/bsc3cGVd725yKdXrpbH/iBG//Qdzy087zfkloHBghg4Z6cE+9MLpWGCOMmAE7xGPM8KYnJTW6smpPkylWKuoTb+UkEQPqA9KVgEsaRI1wJwHqfxO058ZGR03Dkouuy8AQdlfblxXWz9S4b7UhoEvGI2YgnnHggGcPB96ptKyDqp3ITnEa5g379Z2ksW3lWTitDB0NNTNv4G0NyRZTuCiVIrsT1Bw5Y274ZlHkfVpWqgzbaM3IMCpFb4DsdwOilAYC/MPfBip/CymO7LYzzhL9U19W9XZ3ribq/00RHq0Wu5/QgRDw+eLKYwhhSlPaSdeDTpe7yVkoUY6rbKOZR25d6HISu6PmKMnf/Kg5SMSlkStovYB8baJXqhqPKqF18B57tHdJWGDoiOBuApBPqjriBkhi6a9cwPLpGQ6iggzCqpnWN4GuHxX5y/QYODFYUHQwcTN0ii5WRVEtURjW1nfWQruh8Nvn3Gc02nL43O7rjx8qSzVgQdHJJFm/xGReWFNIM3k/BSiuQ0NYEI96VsZMGd6ZJTArXQwvfziE6gi2fLFoVNspZAkq40Ls+jkDclJQ5+wuw4YkGIFXZoUNDvym46IrA7mh/EdToN58rQcEjZ8cO4EM5mBjI3JoGyonsS2oHvYvU67r+Mok7jGuTpZ+amRtcBYIt3Wvo9YFjvpV0qWjIPqlLKHWIds1j5mhUdt3jJKJc8w+dNKUwRm8TUjhXwOSFU+k+Seh2bEtknocVl9/ZtjMSnIYKiwQRk7zDEY7cYoOKIYxO9nHJxF/CkPTdg8adEhOkzQhW8J3sYnKpPd92V6mOOldyc8ajqsdfe6N//ZLueI8/Nx//6Nv7wiefMLtNsz//P9/Y138tzG7eZdfotvuPf+T3HvbUU2aPXkw4ELR19apzk8xP/OtriVTzsHEgZfmsSwcbspFctu0vEZuUYRuhxvVCgwih9ePPnkCX8nnLKNbSGll+UoLu1CJ2RujepL2AA5V0qaZFEEjojt7YJfdbISgcWOEJskebIp2asRkSJ3wN+L+rw0Hg4ESRl7CCbmoHUZh11LbKD6jVZAg36hIssihEUDRu4MkprVquY0jAkEYKXCiqHWPyYt2UizW7Wiyia8+hLz1EFgHpm/4kh526KUANStU+kh0zo76QuiDgjULSORK8hxZT5JGOtBHwus0RFewmnKQGci7fdGHNOGJ6Nmpoo8nCg69TlEUg5HSIFEqaFBY4MLpVvjb+tI8NbJvAzLukKLoizfb0xauvyZNLzGeFviRulSiHm2Hf4nPX/PPVEuz0RTr4HanObs048HEsj0pIubj0kTEGwNJrsBaIVl2l+IKzaYbNoOijE3pHZafn0xeIUdSVIYUGl3JtuhOjoweAhMT7carqDYel/0/1tuC4EQTgkXgkAbr1FSecYw8IpeWWtBPBKpgrTVaKLu2qQ5YJvvDB1GS8EYKzs1W8jHKfPG2sh+yrAkkJ6yJWMqB0ZzeCsIwT+6vQ814uDt7z7aX15TQMxejvMsLsiITzO3nFax4u7WgkACqz698D2ORGDQKMhbqzYFSlRFkVloAU8JSxqO7gyJAfrEsHCBxZtnlZ+hQFFteHb04Ej/6DpMII6CFIpUlkvv78ekuwgXCmYYjvXmd7A3HYBs8W9LuSrr1ZkDpD7nhPOjYW3JpKzZJK1WaE4O1AKkY1Y6MsgmYjRBSBESCJOjZeUQRiMcJZrHwoVv7/E/d+Mdtm13nX2vt556/HM4ljO6rtmICbAK2iIJBSooKgSPSkrYQqgQQnRULigAOKUA45ROIATqBU4gAJElqSlD89QYIDQAoF2lSoilTUJm0oidMmjuPE49ieGc/3Pnuhe6/rd639DrbjxN/nPJJnxt/3vs/z3Pe999prXeu6rmUqQmrik0zox4FDaWp1Vm1y3d5nGe+/n/H6yzM/9rGIt38t4o3v+r0d/9/s9fBf/Tff2pi9Nz4U8Yt/b8ZXvzLirU/im/67f92fZTx7P642z/3+qBtaPH963DXnvkKThHDwRcxQQacgY2GF6lZvEXuI29geiUhxTbb0OwrO+sAVyXqzXcqEfCcDT2+A0osGH9B4s+69tmQfvKa1lUfrUqSEGkhG/37JIbKvyccLayZsa7i7FhsSmBSTWqkKso0COfJAX2hFTnAajHQJprvotUxBfaSijMax/UHj0UG2j9VIHFRIKuYwwNr/EPZs8FXQ983USVNlKdonLu3J6lBGKxtIBDtKD0JkGfgi9TVcyEKBMTSk7gVk+YoB7vI2QuzVh5xEqknlmtkF4a0vTbfedaFLfPoozACgGbNo8kxbQHcdxFPxvPYgc8cIqWVazHkax/xegdrB1FIB0MtAINMT+o5J6AF2AUbmRrj6Heax6kHPPpFG509PW3vduK8kA8lBHt4KDdenHzHPB58eoTpHZ540SjahVeKK4uGOm3QZsw4VjCCMiDfIOc99Gk4MtpIW9weezfLaVT40HYK8EI+mjIz2Mg7U0/vzXv2Ca/+3CTxlxB6zqexXJuo5MWjxqq+4IGc8e64cQ5wVqgyahntu5GWsGZhHJfafbYcx4okapCePOhS1ycGJ29WEgEF+ZFQZyGCsQ8N13L9jT8g6JLwoHSFNkPsg4dMRACIWCdLozer8B48fkmhmOdj60aAOJMRIjDkdJgFtjnXMtnHUHAEi5VlL8SRSb1iRZ8ZA4IBecMLxFrKF2pv4w2uHZ81VuGg/ubtN73xt5ic+PB7/nX97xdu/GjFffv6WIw9/6ade+tZ+8krNX474ro/i6/jtffCWL5enwcbxbvUgd/jbhtlF7ZhO5AKWfqbu95AgpozXGdjOvNPcOvv5pHmudWZW/liyELFRq8+CIYZVRVe8esP251U3XF9lpgZPIAFV8y80cSdCdLShWY9yR02yZcWGzU/ZdKgbdsvT5hZiZplYqup6YaREpRaOAOF5B2UQPWocW9WPFcAJSiF8AoHSgLozUCzqCC+FLdD1dRG34eA8anJ4eQIoxltemU2PhxlTf7TKSmMpPpT2WJcRnXEWlr6KZzLLL32T5WrfTeMiY5Dvpc0Xhzo4d0XLKWHKXU2em+D2hcYJH5P0YU5wUOhaw6Tmo9ygDV27ecndl0BYAXbi7zR6GmmdFNf1TNHNKkcEHkNVy/qqZ7ACYo/SDY3yUS8Dq+jlxNit+QtqECt0wHGrHoG8fobHB2Wa9StfDJNPRbSqbbLkJlNUSChfxNk5mIAWwizrptbgiyhtSQrHC/hF3V8t34ReXXv+TzFcLQnFasGVcu6MHhvcxr66drQ9+nCOUef6Ri92EjOz59dUZwDOkkYkFtKqmf160reyP4o0Ea6qq6U7MAFvOCex13MaZuvZ20B2q1RNbvybFFALBWps1cvVBSCFdldCMw+KQzLdWLsXHyRnj1LpBizPTx4hxMeai58LR9x9fQs+q/oTIlHYwxLd8zjygqnuUioNOihB+lhlbTlntRHG9IREunO6OBuY5iwoSW0Z4RLTbL4+7rMJTDIOkf/X0tp1KGLIdpctytFNM+M4LDMmwqYgQbGBBtnTkWsv2vxVcc/rht00WCzPSgwMO0xcH0u6uunECC+SMQTIqLc4i9Q4Fw3SgblvQTQaGKZN5BHkVejcKtC9+soYj8/y9tf/yvvxlS9EvPrhRaL63F4P8ep7v6v3evtL3+ZHXwnVswtZvc/bvF0J4m2UKHQBTm2ZOaMOR5+0YtSL2gFtTP64qRJc+W4+SZU7n50SKgLWL1WqN47avR3u6ug0bZsZSwdPKG1b3nROzpINoSwW/lXQ3asVJfI+UylOovSTb5tzz46fhROt0u+QT2mYRfu0bXIlbfEB+mCpgaKLioKxJAN0L2brmeFPqEq5nHimrLLT0AhMDSKHBK0Fek52qu/tVOhZgiNqIMqBrlT8mnYsB4NfQFpi9E2d7N0mcePN0gnpHJRFhtosWaNdhtoaOLvwGgG/Q230jcTXtr6Lbquz6u6WlJMTKABLTNSbKGzLNJKBylqkBPAgKWpYUOrwcQhltYoWAmiooUHjR9WbzKvVtBTGSmEu7M2l8ggvO+dPvLfL06EHxQT++g4SGEPmk8o9GFl+BcX7NrIsksCO7VhSNAaThUfK1+bg2ky1dnz+2eJJUX3xh4q8WyRdy06n5+T+uEBPYBoTgATiDMRpYZh9lfC5FDdjXRrwvaP2cTat5x3q9u3JultLo7Ega5aCQ1DU1Xbd3RHlZ3vDr8tE0VU3974OSQUXvJJXFaZ1oNX5BdmqHtHhPIMfdPbfC0y+B/HAMyAG9sz6MVQnqwQZ3psCXdhhQYILAFhBs1g+MFZqfEoykDw4myVApMq7GQ91W6GNBxVqFG+u5sre0LvN0ghBT7aqZ6mDAN4Q2EYIBJoaPBEIS7ZxCK3sOlhK2ydf6Srnhpbp9fvlRrhvDZ1At5HriU9MV/aFLkEdU7q/aqKm43cKcmcUwH5QC5Q1fTSw5nbYlHrUTo3QxAGONSxstDGmcspcVWUII0eqX0ngVpJffKQrCWk0sQ7LgdFQvPvOGm/8gfH+n/433oy/9r/8RjzLl+Ph9nvtj3z918M/+gOffq5v+Du98nHEO++8G7fbS+Px2fYWeYRfIVflhwI1Jz33HKjvIBzJX2DHsLlQh1Q/7jRLjLbkp5UOlU9lZTIWPjQ2zAz2UYkrZ7iwGDUPzEFZW3q9JugjgO/+OlNDMpH+QopKkuT7aBR1RD7UEpwyy5C5GMi4BsxM/XJ4eIHB0WmBLoz5Ym/vQ1purHJhmJrizT4dZwa3rI4UIIijYfhe6iZvUAtEeahU3Df2DsNjHg7F0NQ5IjKOnAjAhAMs6uyfa5s0XztjCr1eCzB/IuegXic70ECI0Yi25k7k9GzT8m0pcGKCLylJ3UFkKorD8BFqhEbHWAlRcjtWJdPvYPwkVPgGR0WtUHWngCMaZbMBxhm10U3uZVGNEiFazilVQplaEIfCXdKQtdP+3RWImuE0iZHJXVNzBs7+zjwUpMay3fVusg/pKo491qYd7g568A7199B47oHsRdSLs+0t0fmOh7XBGQAHVDqYDBPmIdUDsR1rd9n9tqlEBFy/p22qvixTKzxkw+Te6pCJlVtcz0KRJsaXIHaVgRaeMEvQXd8FRHOy4SivXSVYN3xkLIPMMwzSIcQbElG7mRPHVkyd2ScnPtqzbAStxizdN2R5XJT30p1HwlA8Sw/fyKlsuklJRxvJMg2PQFLTJRdVjMq3WOJx6zjf/vm4h40WJBT2pKoFUiDTJAafjR1RHR5rGjTWrcR8XVCU3fbG0aLzoMMhTzoS+rnX/2gOYUHVSqev77Pu6skc20DsPaRIEYJp4lAW6ZmW6HFM2FUu/iLN9oKNJHAxQJDHkBVMmkkccmXJJZAzAMyTczKHoqnGIhvtG7K4naXBuN2ePcuH119/9vd/4I/HX/1ffzby/Vs8jCd13bf9evhP/oP//PlmG7/D67ZejpdeH/E/fv4/un/h878Z3/PhT2gMLfmmxlgx2astouipcg64uZw0GknC6c/xC5N2p0HE0aqJLHJg9TRk+zStMEGPiI0DHutbCFcP9nafi4ECTZbPbTHT1l47vVqgrZhr1a6rs2iKieb5HcoHpnOLAxi7uo6qw6YQlwvC6HV+LSLRNfaNus12PwgxsJcIpiNx488jaBbdYVJtyj5ZAy5BSYUh0yJVCNrNEpkIbdx+XylF5nUG5GI2lNKeWSZ1gQ9S9WByl5wDw+Mp0Ea9ZLCqWRKM4tb2RIXQnhpTSOsdFVylqe7ik77OyNuGVZeYv8NPzCZSg7XV/ApRxMyuPfo0aoM4VUMwtF3W8zTNxQtdh0TbvGnlz0Rpi+RHfs/1QyUinN3cIfArLo7B/PyCYKoLoqNbNm+Vy01tnM0qlxWDIclB6yZaesj7e9WQxU7DM0F/Z5Gv6CcLTKnwPPGavjMEeNTCnsNWByoPZh0Vi8asptnhsxX9/H0OSSJXf76MWinrGAzrB2dRq0FuC1oynr0kNsni6LmmMcpbMMwgXtU3GFNTsAR5ARyOu/yhZ8tEWIjod3SUmpk81OvdQO0aKJDmtC7Wvd8sYG8X1ZMsw6zcKsLZ/1NH+560smYCHkAGGT1LaIjCJ/ODgZhrQIawE0GlqBOk2Mme59zlYPsz7dT0k2LXzfsAuosB/ztAdUSzn9Hrr+ZgrC0CUWKpoBVKPU9OkthGmprjZoyyw2VnnUo6b0yeNP09sZDbSdtUhqaKLb0a5WdHk0eIyW4Hy/paxaliEhk0U2PKxq+OuMo8Uu1kpzs+qOgOzasFvR2DJlg36dHQjHjEPqo1NX+62olV+Nw3xFPVb7z+1sN4+3PP4r/+9/92/Pzf/NV4881XnPM/r9fDX/jp/+LFZh8feF00ja89vhuv/ZFfnX/o+z/DyMupu7WWEkDuHbQlpKJafrXuNUyj7D59Yw4lwrKVgxllIoyqkWBcd2cxiypWdJQJiqsBICW+1RFYk14ZbtSancZlFsBIkQTKBRPmxM52F13WVjkew1Jcse7Ze5BkbNTgwlmaLnYPa0RB9KrP7uMur8thul6z5cOnd9OlBLDoTUebxTH3skdnavhmmDeK9Rak9CzqxDirUMGoJUW4N5WuC0J/I1gATgMC29gxSJ3oxGIGasLywpc05fGFENxd35C2rsF9nuFi0kQjDi7jq+SBn2MfZWPECU8RqJq2bk8eLH52aPAMM6p1mX4zx1TpKTljx2iCqQfUKA+a3csyQrbEoJe4sJzQTN0JtTrlaKoPn0aXvP4HCB+oZW3SsdINM08Wo/anvB3RJaKyFcsuB/RZ0passdC1WCdVu88iJsqnplr3/qYmYJ/1EEBel2qIm3302w52NnfFS8V8Rd0aibc468zShLkmTo/8Snb9aWkHNJ3ZN8wjDEdrlk987fCloKFRhb8EG0SVrTrlNkj81LrkDbycxAfFpygH0GKgrGgcUJcylcWVQpSAjG4ggG92nbAfyHQCIg/qVZ0ndcKUg3BJxQhJU6sFe9VFHrhpsImJjpoZk5DuWonFqnQKVrPvJjxeEHMdJNzfocFgxpeGzY9zcugQKFgFQoBWo8c6B8ZycjkFW8gdchLo8StotSecFUON6wj30T00ZL4nyQZHJGfkQNNbreV+6WAQ2VQvtU9YgQBK0avdOPevj5ce8upk/Ob/+Qvxzq98Lp7F80VFYqtp/sJPPvc3/aavZ/WXf+If+f6HD7/1Q/H+b+8cb484rPkgT/w1jz2xz4E6vE2HUn6NDvsgEChNNq9TeHeiScjzn+z7GQKQRbZgQBIT6PoLNaBcHyMJWlfPQXga2G0hiCTkjTO84aI17I5ThWsi96x3bKWBHVPJJ6gSGySfAYyeyGNONxDZPEaIZ2sHkaDspaLXXDHtJVpSNj8NbLLC1IPRwX8oKyqcpCme5CZD+SKGizxBeT2MMjyr2gJ8sgLJpI0uPaao9VUMUIQOHaEJD4nS7KTc46IFRV1yuMRGWSX/ktZ/pqcaIyRU2xyrjbpomWbbk/QYJsoozTg6XAGXab8mbZJgokeglzbS0KbggmXXCfHPNJkxN3ymwrhHdPhjK3KLsmwXktHd7eP5CiFmMnq65zCcQnkT6nEPbFQCbfCASRwLuwRrD+vZiLMakhOJ+2NWA3Rub3eWMv85myYCebfmPPLIjrE67L+UzfRoYWT2UGi9kRe+h6IlhnopdbvuQrL8OUtJyco4xG04ktZVbVRnmO7fMk1YZwnPN/wFQCnJxfeWnqSB7O+1yIJISTnsABJSYOlBnaTyW6YIoz4eHUxdXvhcZT5cce/r/ha9Rqn0eOrudsQP/QOQ3NsCxMD3t/8fhBE10fP4SqAj9T3nOlrJTl1JuOEzCQ1e6H+t3QxxBESQz25waD2p+bJUY9OV9TyAEA4Ve2znUZyKpdr3X2lnlR1z08PFXSEhGbZp0fNJGaLU1qw5Cvj4Ms7L52fWfEv4YyiB6q2xB6pezbzxjR5feu17Xov4lYhX3nrld3Pqf0uvh+/62PN/02/2um/N8rN4+eGlkfdrLPRNnPklHpgeYs5ltDcKttjSVeexeLY0h2fzTEXe1zJacrOIYmOH/UEFKsqZ38Dr6LQ3UlAdcwyOqpHQt9cIbZSuYABYLjbJrT0/8dMjAVLVAgu3FoNJbhBC8gkBTYuFxDeFDWtIkk+lYOimhpvIQl8F4KysnZrQWM04swifVjBplMqv3ZBdollPoCEsR69qdhpy1hDi1Q3p6I1UPm+adL434zwZP5WMifW5qTl03qbuzJadpePmSdU3F0ymCyUDJU90mY3AfnjuCEhWUErSn+vS3CkAfiAxPkBU4tYyU2s5vwVyH4OkekkE0MmREV14gDqSnd0aKE6JkSi2MNCj/ZtpK1uyDMszq1UUuKgO3STdNtOnLJp3ptaPFrqCCbEMq6/FuqZMFECPUOUuATx3j0gX9UdzcTjQ5MGk+ZjoJU/BRnIiBxASlBndOnUXKqZMvCV8dC1lZpMH75VbD7iyOw3wI8Woty+jDX3whI4StG6C7Uubbcm2RYju2PYiAhHXOAiqugX7pl60dxuICEXTo4cPw+RkjakogLmu4bFM1HngOcmf2WAioTYHrOoW8FlZB6QfkBSi7Wu83MHLPmg96EmG7VFd2GIoeO0Gg4SHnw3uGQISNOuKH7eGFzxpU/ZVfk16HRetWMXmAuc13V0oXtRUuvS4eJexs8wYAVqSzNAQqJvlA0yE0pEGk3IFM8m9BCNQdzr3I/fSZZIF2glpeOepRIU6E/R7zVAIZlCwvifj18Mz9OTvV7dhjg2X31RJ4jrCVWIhozblXv/39a35gPweX7/rqb3P41UpfDxGXy+EynogtRhrCL8J3k2ZOOlfeg61Picz52YHbC/m4fyZcQUig10hbe4GEdZN22epKoVr+VBiHjMgSr5XJIVVZe7q9x/WlZdfk7mQeLZPzUP1lCIEGrj1jZv8s1ev52xgUjnrLGQIa9GdlJAZZMlgV99D6tEACvVpPGCT4Oc8C8nzuFttNE5u3VOSnraVT9D9OFCgOoemJPPL57esDPAisjZHmc2Utmm57QaUMjkc3A7agzAMrwbWSN1wEBqB5GboOuCzbbg/akSiG+XRgkZSlVVw0xTfwlnPreS+h4IxBW0t4WE0t7o/rhWiqzu4gF0Nq+OM27bi2LAVhINfM6L0BCrycUZLZm2CYZbPV+8bJGs0Q6xICRi2YtTWgnZUjNT2tS0/FC8/i+GQapThIlh0wSlisfan6dJFCNbmHdIop2k29tbUHa9wvqikY4zZaZvO+pxSbRYD3u0mlapWgnDm3DRwDYrk9PfxQKFQswUnenlI1yK5yql10z1dvcc9AE/qsIExfp4bi8xNHX3KHzIyHiSdOEmxiwkzr+8enEQkMDfiJytXI+GcmyleAQAAIABJREFUfbCo+hm6PaXv4ObATmOSYekzC9Kv4ddIsPmYQNG7LGoBP9TrVl3r6UkRbjBQvLUkqn5rHUaqhi6D+Dy6AAlbqaeXupPF6CJDmfxAvOBLPRp0g0nws78/FCvMRfzGiPCqElnC/ioz1fpfRZdMjPLDs7GeoH3q03AK6XqnfAiWtyr715jrYdaosvCIiNzLEewUK9K2vuFK9RauKFGMu2X480W8Hh6/+rUX9uZf73V/FvHsa9LUyvBvI9gTlrvFCG7JDVkf70U/mVsh/N/QgX6NIQYAIN3ZkPbJLIAhwtES6mriffkz7t9u1oenDtV5sigc3Oy+fmZbSXtjTJsuVHG3PQyngv4+E8vSIHR0pFvGDUXS8QzmZESn1pvatGmvwqKjZoiN7Ix9NvThpWbzvxAQyvVl0Z2OQG+5SrS3QpE7VVSc+HyxIOmBmJUFSq1y4hColBgCFoZPVG8W99TV4DUk4jNoC2yWtlQorlqCiFyAOCEBBsjsKPdTeVSPCoLVOiDPEb5dMEENBoOSsJMbNbs1s6WUnw07V1umyufpi7s4c6sYQ1slBP7isAc7arrZDEzdREavcvltmolqpEW8po0pRWfuE5u/VKjFhlQrMnoqx8QcM91GNpWo8jdVSjROyHbvJV2yx6oexbQwSUnMhGYElkRZkiAubZs1JtBcBKUEOUm5XhpzLLy7Jrim1HiISFj1dc9LwqH83vN3vGLtbX5XNKLI0JE4LUEQelJd2/rQoSG3PsEFPjVFYVJnp+2BnaWKIlendBIM08YdkQ4PSeEQ2v/qi+GE760FiIlh5yAdthpgPh0zOBr11Lo0SqvZsJvIKoXMyW65yruiHS/BoiOsXHb+UzmibSExqhui1Ri1M7QBWUhFXQ8Dkl2LXG/vpXqapdtKB4II95qWnl9TlaoqqkS/n49rgP3fGqGmUcJ5NNvOOsiKOPq9Pn8Egd9D0TG7s1vhtgN5ZcTuGcZRKmCIXcBTNegZ9s/kCCyz+SrmeZGYUNOuXl59bK4y412aa3J98MO1r2/rMj29Xl/58nNODHab5g9+7/N/12/yuoLAO1/8cowHTQRZdQqzKXERhHWaPgPDcnKf/dZ4DNNbSVgX+tvjFLZ/glxUJdyd7gMvASDlkyDK4GA4vfl1dzVXdiQu87G9PVRCBlWg0vlDXajlugpaoXZ8UkWIJSmDmkC0ZobVZJyz4bUundJGl2purQ9w2PV1PIM+3DAu+T/zDIgsR5ZAXxx7Tu2xbLJxMo+nLU40nGSoH6aKNc/seuhb0MkId/D5QHOZ5QGJlZpgGW6ty7p+7wVq1sH86IfrL5vHgjFmF1ooU9JWafWD0cpbe9cbcxjohMzqScl2uRCTZIcqLTztlOmQr2mkebd96pe2EEeFOKeXgFoubbAKl8iAgFW+HjhA5exVwsQ92otMdAyvIRM8KMgz5WunJaWWzZ12FlweQ5J8oaYYHkQMOBM6iRADc4DCfLKyIe/Z7CgS9D3D7tqTOiTdTR99czDxvd73VsZd1nlPE627XHbOHxEYB1SyM47+j3At+oL4ea7t0yEEzhU9Z5a7aazYw5ZLttASGKfOa0q0bUBZt3Nqakx5LsLzlZQnR+98cOThTKZv3hO8xnBmnquLbTAPfrUtrZfY5VRhQ1nLMqQxiOO+ZXd/QDflrMMSGnyMiKJbcZSnwLl+ZcHEO/sfYaDHTZDETvfgYlW345Brdq3kYI22OEd/pYOJkuiMZfTOOI7+VTx5rtt3M8KcfW9VmyH5OevN6Y7L4DlAuvWhMQ673l2d9ERws9FG+MEdTDeCo7JhC/+i6tvpaueKDBeJNR/WRz824oufv+zgjzj7nF4Pn/yjn3nub/qNXtdlvv/Ve3zqj35vfOLjb8c7X/hqvPTay5tWNvCZmhsakQa0O+mVLDDnZzMi60bf2BVERy1vTqnBHhx06YZGfikZF8+CyV/CImoSZqsa1qanGHEVxSUEbwm29R8SyLKPiI4+Kyn+DA5leakyN39w0qTziGQB4tt99CFgd2CHvzpKxlFG92bjVnSSNZhwlUyL7zaBYHLOaD63vhRXXifFEjtnDOf5mON2KG1qwkqTVudodka0wu04Yl3fu5wcgXkmNS/AvNnx4WxjWHYoY3c64MEEEFVNNa2nEpkDF51jGMMRQLMtnU8wh+/LZHhBxXL6HzKC3KkuRFj3e4CGjYsfE1IKZOm2g+S8BSyMvaAOKltxigQTnlYckr1oKJrvj085y1LlNVGW1QRT1FFi5F1J8V0rvMOoro9JMiA3UHmXb9jKp3EVsrDaGRh5QYYZMHt1isy7TdqaikMAv+PJGQMab71Ftyw7cQOvXiSTQRTAo1glZJUbmB6BTOkHyw6J/HxPkhFapesIlzyBfEjfI0QL9sgdMuXqbKAieaLosZFE0MAMWAVtvHHED/IplrurivBbONu9ae2lH7cGcLkFljP7XBtwwTpB3G+rEWGiTBsSLSIVCCFDyJTsT8i34V6KR8vCq81qce93UZWo0FuUnaiGGm3xYs7fGmcFAVirD3qCk70PvH67AjCF2ObqRhC9rPeE42vD3WWGMLbrc2y2qoZqLDT2HinvOF3fbcaZZm10zXZlPH6lnaa/6n7ufGya2C5nCZN7oH64qIryED/ENhocWNHwclWZt0qTvvJ2zE9+co0//+efxZc/d7Uf3+14/pxeD7/587/2fN/xd3g9vr/ivS/+VnzXH3v98TP/9CcbDigrpca7bNrfoKE4JXpKKXc5MwLMCQzCQ/RZql0HY/XIGDkgBvy2AQZsxMxjGao0kANzNHwa6hoYfqQEUGhWBdQNC+yxbczgJLZpza4liBlgBhaDzIBc0EgFPt2HAi90X6azet9ZVmHoDnoz1m2YB9KyOqnKIa9TqifD4N66zYELp4hBukDhcah90wpatieF1PI9hXLL0U871MKcJ0vPkf1IF0D9hx99irKeHfQb1RokIEKigIA4vvOI9AOtJ5RrMxH2v1e1LfwdyedIrYeH+bP+p7PFcC07jp9IB33WWpozrLSrCsVGKzCIUebBcZUgRAuhhJCdvaWmOvB0Tmy3YzKt772+nYGZ0evyWPlB87H+vDLV0VktYdMAVgJvpUTS8/h8JSGysrL3bUafHmQ+sHw5w4JgLWPdG1doyxxHEa7yUHZHZ3Eu0Dm2plkvJgM79aJIMTttIDFXXAsOzjWOW6dFU5q0vjeOa9Qq9ablk39wtlTFP2F5MzjO+6QB6gNRQiGoosJ4oMQyBqcEXkxfLsLbAZPBO18tK++2khL7h5moeQRg7T3FgjkNePAOBTp45hXXoUSUvev1gvWXjfTYaqxmp/6e4eJzplu1OAA3payigziJjJtkKdGyRszDlOEnyJlOBERqhC+byPZDTdoAcNORVPIcz/gfnpXHOtNfrSMt5jVhOle0v77La69nPnt/5E/99C3+/t+NePn1h+edi8TD5/76Lz3nt/zmr/s94t0vZ/zAD37/fOXDr8TXvihBQV3brTt82gsyiJOnURMfQtUA033GHP3kj4asFRSLCC2OtwizS9XLdsU9AiMH7eXAdKdeCldyUUMlx+r95ec5B33nKbOKpe5v2WtrnkbxNBVUScqo3b2AqsiiShvOYYWe1ITjjoqeft7NDW/7le2iZDsDIh/wUapFhdHTPZrhnctVWHAw3W35IShzScx/E8y4Dp1Ij82ZNwQrokJMqWUW3BMkD9N9Ny+s42Ch41EJk0s9n4JJ6U6ztR8XrkuABl0xHPdFJvSKxFMHXY1P1+SLcE7Lh7tLZcZDzk46q4KBaKYKbbRQS4lMxsJPLZoU0D9H5rztQtyIObI5ITINX2FXtoGfKav3ZQJni0ygn3BOiRm96DqvZDKHytgzydweXOEncS8qADZuGUdSlsRM7Un+7GjO5XqyuTi1JX+RF27DLPYzPc5QfRNnukeeSVJS5rPypCe2VPahgd5JVq1NpDxNs3+WwvkuKJkbaf6S0d10iDBtCg39ysNQ04BN06PC7+V8tF53nb+UvQLb6k9vQbtvgOM7oah8Qq1y1hWQv9fAtP4ZXYyKEXfA4USIV3U/Rgl05RDhPWzqTV2SW0DCOXPRhdH69bmrQlKBTF+E40JxvZUN+7vOalNy+/ieg0FNfMep7bJcW5oDehco+BSXUtzq/Z9GIsCYKhWVe3sdctnOILqRZlTV9+9Cx4/dtU72/vYBkDB5a/2tbs2lVIapz5/HaCke5KEJcEap9OyuI/HKle/3FfHqa5lf+1o8/vhPzHj7c9fPfosz7X4Xr4eH119+7m/6TV/PMl6d78dLH36peOZzs/wu6q7KCdkzqIcxbkQIycOdQOq+7tKics/5dXzphoems0dU5411VEd7LJ+WKSdUJzWkzgfbQQ4Mg0H9ijs0g9R/1QzwK2DJPqD7tedMqmBtMItW9UIPTY8eSj0bdrlPVfniMB16fCPOe3xGCQn8OZUR60r0wVKxmfEqF0PrRDW5A/uz8/qMB+iB1K6SzdleztT/jW6GXKCMpySpguTbeMpIjF040OFux52DylPDJKQlCFdc2vN1+s/woWKpbI37vu7PTK8PPeXlrlQ7yoHQiARCnTHNauToPNcXHR5GEzWSsG563It6HJaQHWco8pTnyCuCg1xWT0+8Vz25aBblpP5sNnqhQXRORANKVphjcySeeWhA6wJrH9robHg0LqtVJjcu+FC2q6ui1s+22awHcQipzPiog3OP79O4oCWDulG8c9PzdKJ4elNXlQnf7Eg9KRDrA5crFKMIyf4sY7HRTaXhIMK2naGxEV6UbuLo5Fh6hxp8s3+8vHPKj6JkJhWFYFANqbJ1O4v0PjJrwJXz0RTnOmC5ljsXRVORS8hsBIWQsHj9FOGEnTTVCl7nFRGzdJ7RSdLqTjUFnzY8PBlLsHLxiZIB7G4cqDuwScL74dxq/a/uodRCWlaI3zbrZA1/ZCrH9bYHhMji2NcGY8aPbl45jhRnGzqtLmAmyc1xMdLcZbVanAzYttc6imHIslHfVQgEyZ4zaaiPFf32s4RETss7AqAEY8cjXdEyXemqe8xW0ydYcAcKdodr6gObzj2JtPL5VaSRPfTh+uHHx0sssV59/UMZb3+7OcA3eD28ACO1b/oaUwd8TRLUDOytCaFcY68vse8m+3IARw51tzNZkUTNOgYmCsptiTwFka7kaJsAcZtJNaXVO59XnY3MjK1yo3syNd9EptE64g677fIk3kvpvhU1Nyq6jJtGOig2rp76Hx4SC3pezK3lv8d8woVSpSMzObcY0oRJ2x5+FB4tU27JnDVBBjNNzPe5Tf05ysI2aawjZBrt9b6t045546UqkVDUgwD395/RLnYLu3DxA9oxW39bz4gJloUR0Eib1LtJRiNLdBztw81oMK7jznFrw3io68DmFsnbctWJfrRs9xO6JSXxqJKDMsctEBFvIAmVJX0idGL9tm8p3AMpVyror+j1LQdoQfecrKuop92MGsVZgdB/r9NbY3n0KUsVV8a6z1kzkZU4KljqJFlDw3ETo+JK0ycO4XWTmHPc8JA5dUvp3jynRiX5dMTjHIITFN9N4CsTn+yzwHm08aYsJvqMA4tZLGL1H4ZUZXrkhjTL3UrblCZJpzXaBbubPiEh2DQKLu+Sc0Ni+3sg7rpdlKG3AajUx9WBq02NlTS4rie+sN9FhqN1D8a5MSvl+Mts0Zt6fmUr7RbRdOaGlCrvYmLITgEya9Iv2sMPM429TnfAikuy5n2DftOjCpYurfDSJXmpLoRzEBJqbhWlxhb4k+l4BnNdkiaj0O6ZkqykPL5S8JWwkp7UV7rzexm07JAiWofcOlYBi2tgIEOtsoCJ52g6YZcJrj95fgAqTw745fGD3r9wb+ue7vs/kTNORDUDM5tL/b1mswUpc3JJmdS422G8r02yNq59OSSs8klxUTRdA98lA6v7Oxm75pxzafLo7fG6hw/r9qlPZTx+OeJDb72Aqb3jW/ih5/kiDO0W+kJWUkFlHOctHn10u4dzSmh2B/6H7Y7YxNUcqTk/RzeQjltoxFQLq7w/rBA9Ku/wuKQyy2miYc0tKbmIqbZ1ejBRcvS4mMDVogRkqF/MwlJGQP3qaT1gHrraae5pnQmA/2RrlG4jmihFouGRVlWdDnkNh5yA9ZXEE6BWXBrh3reFfhKEO1NhDrR8UFMJ7zsg6ngKCUXrOhu+Uvap1loZd1KB+cTC3blx4IMou2grJ/I7vQfeUFM7c0kIe9L4Bm0WuIMDtgXV88CL7ugtVKAMn20D5YGPZ6e0XdgcjAiX45r2iY230PYIz6keuhONly/BIlX6o0nLntCpQm82h6GySk7/dAsrnBYaUjo3GzA5R9ahDCwKX32P6Weg0zbJOTWm97oLdwxpwxQpWmRk7+aMpYkjB4joAUW6eYOsF2JL3UYeL59V13ZPX1RPshoWKiT5v36i0ZCFL7Kebg0e1BHVazCxg23fTAEdA4HsRmaeUGn3r4J9NHdOO7vc78mvK3oMzYrHokPtjuDGw2UQIRgQxMuy1tD9MLWLclFMi56di3bwcCD1V02r/7d9xtAfWTbcbaS+7bISmU1uZv2xQQJX6lWHueTzMrYMiM7cQMNXDOnTJJbRqXAzeWOpbGt8kPU7o4dcG35Nr1TQHXFg0egQiiuxG9KcKXHWra8AJ92FKdLpB0YQncwQSNwCnhBlFsRGwoZ2z4B1P8s8oR/+uUNYbXYpUNBWdnzpfq51uW45Hh6vP//KV0Z+3ydH/rn/+B6//WvXk3vvSUh4Hq/fF9OzMIZZWzmruF9VuUfMe8BQgixPqhyyOC4MYGwlIlJ52qECt0SKHOXeGXA+sqcopiw/3YdTNq6TsceM1wt0TK0GjRkYGle3ZF1QD32WgYmP+sDOEpvPMPpWKEEeIehYeJVTJEMaR46OtfJeDLkjuOVR328pg/EQ0Bz2wOjcXjFM969OPQrf3JhOQrLGkCvS1DrmuNXE9Jxgnif7eMrnYxig2I3INei0Sx806avhub+Ql7WZfTXyGGA51gAOZlG5MyV73iSMhoJoeV8ZoYCynz1sMxY0wBroV3Y0nlqoRj7EZnIuiVeOaqXsSybJMyVwQfK+/1o89HikumBr3JBjwAGcuqlL6p4mALj9oqyznhJT/ZUerUqWtnnXNmDE7IzX4WeqRwP/j9QH1F1HMVYX9YAtfQlYCbdwslwcBhm2kQhP4QNHWrDGbDCvjoNlj6fdwjOUMmpIZHnVNao1atCubgiWqJPd5vvjoS6raaMUS1jnuxHB30imMz5QunDcpBk/KdhiakBTyK6O39+aIGT7lPPG+au3mhtPI0nJKtO9+y2p1lHOBpqMzMbbhjcWF24EA93q4PLEp7NfRtbo5E1rSzjs5lIkPhuTESe1P+mVYxmIGEC2PoVl1kE6YYNmp6Nz4n4T/pp5WEaBcOyqv77T6kO5WkIkbWsDRW4S2tgq6cAMD8ed9CnlKn2cQDUpQdsi0QuuArazT4mp3BSreCmJKHaJH2ErKIANbnN7reY9lsHM0bgiHriCtjsswVCwju760Jt4UTV7NOpb21/T7rVhgSEXIo3nfo/rgz/0WuSzr43x4//ljM/+nYhXLnrHc09GnjPU8ju+0oXYLeWksNYqc611UCoH9jLKCjKlI49O0C0b2M6ra0uSEDH0E1fTo7pgk4ailJaH+4bmHHaBrVaQoxpsEzT/JjulEHR/86GeH3Gr6jPS1bBdd+hEO7IgZjVh8ilFDiPa5s3Cy4IcsxC6vc0vWL+KBpO9BJ3KsHW18bGuuuLJfss2vzLSUUenWZzX7Z1JxIpjyNloko2jkqrEuv8TOt5w/VIjnEKt25RZYNJRBhqebKAEiAbn9uDJgN2+NEbxEAkQDBROsC8FSl/KUTBfG40FR2skr36zGsnTl6YhthHiKyWfQjMMHYyxmhzq6YImTAi2DBHCkzxxca2JBkueaKNmINdkhPo1YR+3FI1zqstD21v9lqlZgZu+JGdAV7ORnrpOjZUm5DrebffVARzPZckvft71ZiAj/LYUBgsEffvrLIEfE5Rib4qVZil7k1VjalfaqkJi/5yRDqMJ+5xedjse3NYoXcpSa4LYnmrCC4m8tQFKW65z4erAnVZhlhm0pLpMk2ad+Xc8k+CbmzSkS2St0yfBfE/eLnyBVOI2eySriJNXO1r2xNtCujq0A3bw6lx1jMOHfaDcJbhmT2lRUQav0vcw7Iaa4jK3ecE9OEMRglgADqRbTaTMBpb7h9C7hTL/0WhEgLyOq9uoCTCTMnLs22J50JYJGGhvbqibp4k7IFiFQLhR2nhvWtZtMjNpk/5mSeJHc1kNAxU+tW0Mc0tloT5jKSnjBiZ4jUH+d5wixnKdCwP30LAxcJkVQWYnOUM9w3t5gc9W3Fi8s4Popg9a9FnSXRH+9vpfIZtB0OQ1HXhffTXi2Xvr/lM/PeK3tgD3+eMYv2/IiMHw6qfnxpPq3L8lk6G1upsY0PLCaoaorFbHbqoQgqU2xSpf++9vA9/VcVSiZMlQzYehkqrPbBXgNJ3qqr7hdbzfa0kSzplSKYlamRNNKtjSTxKkjjceHWRGJQiqiQrdiTkYDPAEDJD6cKpw8t2RdScnKmAkqLzl/4aJQV8his39Mze+4sDcjcUfWHSFe1TkiKRYmjyxyBBSvlizA95tKP0CSUfaRqtjykfTA/MwLdB+nUXbqfqXFjuBFfZrFFQFXZGeRbVfKkaI9aLZbBVmVsVARADDCU7SUfSJ7lZTmxFRsBQ4tDqL2SmBgWjGiA4beHPQjnU6k0aI7XAMTGLsbbFsys53eRozfrniehyVvvYf6jInF4vgTY16nDxDVIvcedmQJXsRnWtI1PDzXwfDAY3CCK2fBtiiScDXd7lhSn/9vrJseCq3sLhCkAmPDf0kxInGCAWQHyreM1m2Jb68FsJcyBXHehbVsIg5NbqSFHg/n1ugrWouZVbFvw0TJ4Nae4Ibw5dppy142s4IdO+F0sOxOUmLynSnEkBG0IxaAbWYp4LFGsw6z2pZobw1WF/P4FbMgvYfFPClyRjmWq4m19b3qWJiWdxoMBWemGBD7r/3iwNv4X5qext0WkJ/ZpWCsyfbuNMzygFq8w2vv8fSCGrEwHtky9wtfaVdNCbxxqbox7TTBTAXVEGKuraR67bK4PmTS3WOYahdKku+f63BBZV+uC0sPOUp8CBYl9Z3HGOSQIQDo3vuzTS+1yU29igZzKLM0yGgONdbDVn0v2uA7bjYZftXP/7x2MnIG289fxTj4fcHGOn5ZfVQJMz2zhwdEHba5n6NKyaqn4qy80phJndVXsi1/QVnQt67Hv7d0z+GhqLz+G+hUTNWXUwRwIH0q5C8Dc5ok+vtR64lOWxuIBVt4rPJKnY7Vgx35+zpA6FhHA2LyUtKKzqVerwLY66q8Tq/liNrJt1D+2zoryKPeU6eUoG1RnatME7zLj+poIVW0Ic20j3LEn/zhut4mW79U8mSVFYhMQDJKa/YF9fn31eOh03zvRIS6yJS2C4UvqrmZ9fkoz/kGr84plrntfAafQb98LlenMe1dPFL1ZD7Pe7b6SYywNboPuVK6sDej3hFjiObkQtzjs5sIiBw12DQleX/NwqNonGR+N5tcLzWyrRtKHxstcwrzaNEdxHqq+cbuzB0VFIeZh5QAd9VfaP40RMt2486O0WBqt8HmrrRP7i+xIWg3CT0lSqBQ5+oDSoWUgO0ayXUXoSQ9Qg75ZSZrd1Ma+EyHdPDiAA+lB1OJrUaTaIYcZNjyNdMLUhh5XMYyE2pQ68qezmjI40bh1Y57RsdMj282dNuGIcfXOtJd8kutjjMJpQzu3rafyc9Ypx6GxGhCoJac2nF3uLilCZOkkjJR5v7NYZmXuUwIw1zfyflC8e0zQOn4SP8ddk5XqEyoBxPAyMw66ZaCkk5l8XQGU4TWp0rJxpu9IAfklRHuxasH2DOU2HYS6t7aPpDbbi5q+MhBKnMj5sZd0jb53IHTUk4W6SuY+B8nXtaQrdk9hgYWXO2XFgJilteeAgJJyfT7m1sGkyEu2T8z3xIDQ49SZcp4vVIew/uUahZKqnrWH1Y8lict6cO18/59fDbX/rOzqZZ71/y3oj1uDRZHjSg96QxXnUVte773ktum5tsLAlgM4QtDVmSZ7X6q2XdJZJZlTZrEiXRwdivaXM9IylpBM57PdQFh6T1c0FWGrTwAKbl7AoJF/NpIwIanQERcS2jG/eDvOfvpj6D6V6+b8MYwZb67ftzj6ariOVGs748REKpEUaKQyzgqnnmsvX68IEBDY8N4ICTT6yj89gVQcK2OSn7+U0OPJMTbsDLYQvIIt/Lw1T5mKqc7W0w3IcVM0VIQ2oGvXxXnbcVWbzaUOnntK//JqHnveZbDCMMh6ELbYtsFkWJHzjyj+Fw3Jl0A2Oc/9fcZKq2IW4Hws+pr3f3bazG/UJssRpXGeZHiRe/QDv4hJOcKeB7hXpg0X886vnv8Sr3GkNAdTZtGZE4o7NHDIGzEnt8pCI9iCYEGwoI/jjNIyixDMnDBJJbJPwtH0inoOJc1PMXOcgtp1PulsoSK4Fuq3PfAfqx+JzYadCbSD+g4oF5B1Vv2wVZoCmxpGLBFgAtpjYyXsBxx0QpJah1/VQZrO/sfAufEu7f2BhhJUXrqOBpyU0KcFoBiZ/cE2AOH5lg/RdL+iTKyGNd035TVrv1oIaFQwq8CR/aPNv6O3MfzKtwLl9xZUF9ZiBnE1EAuwPVnf6f5Cnuw+tJoNdDdCWO+GgfhWKQyPakiICTZ7fE8eKrT/xGfGudhHDW7EK7ki1a3g2L8L5HEYahXcrEiDqNfkwjrrUUl4K6Zziq1Za0gmglpzAf+mIqeBrWJj0fym6XejzxeL/nbe/d2/8Prnmur4c//IPfOTv40EHz+c/9RuS6r5XPYszXhiXoDKNOAAAgAElEQVQUYjOXsm71WBVF6btaC/M+YOXgYb1SgHIIssQLF8blcgSbZuOnidH72O++zAqpXOp7XaOsp10UhHVmIxklFLQP6O5OXjzkq6TdlaCZ6GnTeg5nQW6oxwCR62Alyt8HojUfbhGtO2eP1kaYKXiztBYlStQaX6tZ2AG00sz6Q28g7Uf9liSwxSqTU3+VkQIzZh6d57M6C0du6z7k+jwMMmxGBmYNostbt1+gmXULmFArwRBeka5+hCyhZVaxwShy50U66Gh2Q7FJJvrraL+Q9uTIoewoSXrajcwM4FHMC42RH57Hte8fns5piU/L8A6lAp7a5VZ0Dfe8794uEYy7WnFkT0OGJ9gjvKD6bUUfHJ/04ZIWzA8XeZJpLT22ypprhp9a3L6x54phQxSDQThDqBrWGMsGY8yTTOeIOgBGMgrY3Xv3hUxdGOZZwDbVd+g8GG4KMqdBt0HA2wrwPhDrnYZhhHmUIaDsRf3CpK67TKlW7I3diq5NeZ2zigXjStinp7NVmXFPjlxSb1Eq7nXGy2WZ5NGir0AcRtdn1BxR87TKNE9mmuKDLjics+jN03cxw8jxcBawy0M936Iyu+qLYGIM6j7ZYiR6SKWFPN+FPPy63QvngOEnkaPP02J/bnsi0U8VNTvMsRSzjM3KzcEsQZR+CA+L+jZlVLYGIFYnystOANlfQ/FrLDrPC5NqkN408GDL1CT8LD+vdMOtHdyGxvnLWcB/v1XSqyGLDXTeVQSl5GlTbbCN9w9puIWFa9EiTxM8rxB0ZHsagYVH8Clbs+vwrEkTlxfSVcxu6PkFtlIe/q0/+2Mv7t0/8Bp7au+Ij3/8I/Fz7/94fuFzX4iPvP7pg17MEcS0wPLhuYLqbHxUicKOs2tDZ6lpKCreNI9jZfFQBGWsvt9AsvWslnrahkHq+8wSfGD9KuxqE9oHMyC2N7VMCj1TfkCiirtok4wz98Ad7T8RYiqWMDxSXK3c0/9zC3Nq4vR1RTcMM+r35+rzk6kJthfLsRggo07KErZ9q5MmDlJbVYK7lJx3lRNzCbbUeFuP6x8C4S+6TE2y3f2SVJJokue9Mpb0yCUD7uUuDz8vSEzoi+rgW2UFtiziCGpW1ceDTxzBcRHOchQih1rza/RMr8fKRdZcfB83V9S5kdjojlx1m00s8AMfO0l2NSqRKhoLlMelIENHbGk9TAQXVYNlDxUZLIv9Bo/1/Bjg55KsJhJkTZoRX/fSxuyc/CYO1CY03Gs9lWUC2fN18yf0CL2jYuuAo7EPwHutf54HmbITulUUUG07SvPyK6m0a2HJtyFxiSCVjV7VRX2+bYPr+VZD81o/Kn9LPhF22Jui+q69K0W+uNdfVOwtXs2qjLJqil3llqPv9ferOra7yXerLzvu1U6pocrheZU9LVqJ2w7MzH8EtWtFiCT/lQ3goOXUkxNj3x1q8Bj0P6eAv6kj98j7w2X9QoFzOOl4umDd9ErRV/SAP778LMO/oowOteTCJn3lJb9jw7X+bkmzaTAVcy/re6SBVelk6hHNHbGhN8CK18ITmLV3xCq6BzD3OuS3yuHuOq1LgkfFNvJBdPDquF+H5qzhe0IiSA+YzxnQQephaibdqjyuKO0zaEGDKYbiQxW586oqb8p2lZpfnFEBUcBLtRM2yTzKTNamg0snzLTuubaGTw28KwsqvlbWXV55JKHdnqm+b647ZkhFfmlCqr7kPaxpws1Zdl7ZPmqg/WTq+8StRuUzIcn7+ZyjEF7E6+G/+9//+xedg/i17ive+dLX4l/59/50vDneGu/8g9+K+FAZ7uo5XnHqBlY4rKEIep95MKksyAqqS6oCKBWqS3EoaGZShotRxaH2AkimlQMfX55lPQo9SxEDA6OsAlW8DZ63KB73RBNUQyiq8BfSW+lFhJ8v+BBaVsC7StsJ+C0fRoOTd5VNe8nMnE6olAtYFle9YoVWagi+QYF355HeCt4wOxzl5k7Q1TviMJN5n3Ptwoj0/tk/2r24yrou3wabJrFYkj26UalK4j3aMtyyM//PShBZvy1OSXkha/x/HQpyeex8KMLtMZ2qbrcF7LbChq/vMFGr7AxQZtpJxTQ7+J5AWH3py1hoTyBY6t0xQmkegz6glsh76D67DOsho+pgDzcnUtJN5JBFDpjAwxHOlISjBxIX3cmEZzDq0VyHcy52TziMi+nrbW2+kkbKMI5Wlmutap5uo7AsGkOOcUwBYbmoUXKQVGA/HQRwm4arFGlWN30LgDLD/wPAzUhIlLhH3D4p+EvBswDjZBRg3w05ZK4emltXKYFRJTwDovBCeOTnsz8Em9U2dsNLYjwZX3uxL2dZHg8eSPuYyGoJjQeqJGvkJr2RLOoH6wvIFJ39OAYoaTte+d5t0vDW3HBvvtK91Xy9MsU9yNyWBU0psYONtvvkxTZuzZuWIven7ihx0/n42U0TCwg7y2H2VYUQcEvJB2T9tbOwVcSX62ncGVSj39f8SsuxcrcnApQdKFFZg7RxUzGB5GaviDvpEOdL5aB77U31gkdazigjBHQSzNVZTMQonu3AQBD9+xJtjyRqDgL2ssapeqJYexJnFqiQokPd+FmBfF3F9OXW8FgPcyZs7Bf1evj5//lvv7h3/8Dr/ni/5EHxN37ib8Sn/rkvPr71sVfJCDNvgseXQauBJElPLeZ4MMKgpzAi6GbAdKB1q6bNkLNOySDrOTCfnyNF+Q66YBE4R3kZjnvKfGowDTJM29pG9ltTU4yret6PAj0n/PlVEzs2i7Lqpj1+pSBcVeVzGBlIe6WIo1qUur2khlQABRzt//BsknErM2HVQyZ6ljJhH8o1Ir7u2BrkUWGhBaeGs7sdmu9mG+PJNsvpddJYFGYo9lvt5mVeMvozYYkQGusQW6RTTTaUeZgwg41I7Hxi+vqUSMwiahC1B9Q4U9ZGSXDqvW+62KsjN3vSG9YmrR1ywK60FN7PvJX55lIZo4F4Y8nTZKBgUfNpahOrJThFiyqGnG4mot57lF5q0oxZCFbWEJfQHLS7VsYttR1WNSenNFRLd3JS1YrLXK4jHDWK9u0iM4dsd5aCP+3ktCNjtYC47SxEIJPZlOsM+/6MqVO9FsxqmrDYzxT1pdsHY1/RY/ohDSlRXsLDzTENRX9cQLV0brQuAzZibUjYkzf6OFr+B7FRHJWrtFzKAOuUgfquMjuA33eKP9UK0qeCf3mOhfPIEGwxDt+h7jwBnGn2EXMFZcRlMzU7ZSZt19sTD/6+pTKKvp4/mGKAT6AJHDlvpZ4SCFU6xDVJzQJZ960icpuSYOKhX6+AsqLN8peoUSJjq39XvZXK14pudNtxxbdNueHScTznQ81Pt2YXyeNdW2xOEi1HL8WqtFQeaLzSjrpxsjwYt8qp1Ku8DNBF9pDVcaGsa/n+Kn4tWTDOEjysgRlmQZvbCPwio00hMA6GAzLJFcvnvKkFu/T8RQ5awrrHpGKsV4Wj1YkUegT3bqfQEQY04NU3EkBE+6uyQTlFrcFEsZmyGd1q0RfapIl4eOe3vvtFvr9f19W9/Mo9PvzKe/FX/uLPxI9+9M3xR/7UPxH5TmpI47ztZ3oNYEgp5UR4DnkyH2amxPKdt6wwf9Xt/WpojhtMr5PlOfew300s2qYwcZODBm1+giU/LhN5QFMmTIihPIr1fDWAyetL01516YX0qJ1AH2ApjM9d3OpMmuJ4QcCLYB5k1fWzHTLzKCWvE06zLpN+xj4vRE3v2e3YugdUpTnmxPGhZtpVWjgFHhAVa7yWnFa6ZRyuwzdyqyHjGKJUtXarkxTlUhervMUOubez1Wx0QKl8jS/cz+9OQ3lQZGzcY7nccD+UImaiDxqoZWSKbHW2MJgt2RyJ/rjS26pHM6emWvj+yxZpHzf3wGxdjMOQY0ITkoZqpyXiRHNImWRGOZoeaaGG2DGeqPllKdhJs241jkL3z4jTwBZnkJ5VBKrzbNrTQRlcERi6y8VCIwOYs/ik9MuU9SfTAzfxqrxy19wdxFnQ+m3tvhS9fkNni6nTxZa7TSgkmdhnhG2sQT6kzmTKzV7fFwnhOgZK0KDcyFntvlP7VlXLu+WVoyfJ1fHFgqiKvig596yUT73So12EX6VE4ZsGkLIJSSU3t1X6txqccN/e3K6CYosmCx2bl+UThyg6N2G0yK4Wwy0Mho0GaDw6VpnQFDKX5ArRhMkF/lU1f86ssQaQoe9o2ysmsufE2tpEoh2zb5daVgSP3U/FLkyv7dlSGYbMgqu0XH0J15D68rxEk8txGUJhUp2mSc0Hjll5XNneLXTHmx6X1q3fFhiZEiyZ5q3qkYFL7Xastsy9UK1Jvh5A20ocVnWpBzyxVIU7TbzYN+xWx4JKicrLmRK+gk/exa7SwyHZta3ndBU0SjfxY1rqkzLvGzZGQ0zRW3iXFlOdQ1jhuo/C8bPUBvLgKj7k3si3vNpJczy+tElVMb0EXtTr4Uf/md9+ke/v1yuvRHz+8y/F//uLb8Yf/xP/ZHzPP/zr850vvxOvj1enuGekebt1G5s/lR5+X8S2u0mcaXtHjc+oWIA4qrs5ZZlVcvWQa2iK9Ci6uobFqlHKW0x40INSwnO28kgLFh7LVd+VygBnlOKZL823kYZt9Iw/o3GEcBG5ip04JhbKQwa/td5Qpsv0GJZ0jcycdaiUn5MMACohar1uashZ0IfYh/YSz24vR0F7TDveMN8GdooFtqde3IAWsrj+k/b2tCAZ1p1hxuWOLrDjTsTmcL6fYF/jZiIL5ecKD6ixJHTVaIncM+cgHTKmK485pLJK1iWxkDiXEs0HSriM2xMEZ9BXU1i94ZtQkwWGNDiqUVerEYdTxNsq6gySyD2QbJF42Ox0A2EXOC5G/0LaADvIiIFyqYRcmZZwZQB+y9sLofsG2pgQSlNISdso1yR9KSuP5TNp6dRKJI0DV/nhLMaMqlqvcXR0xuU4SrK1UxV6DVdVKJjlWt9LsxrKCU8KiQqJztoYUV9jazHVCK2IYqiIcLETneKDwoD0cWfL/dgejBstrBbanLfoBnEJ++4DNRcrp7px8GRFkhJaXvxvm8UL4WAuW1VZ5fNo137tjyVxzx50SNez5KVTCr48QBq3kWUqOEYbVkSPQJxTZ+ImWxQ1lIMUniV4Y6jSQatNJrJp/jeZJ2CZJ/xF1zertzc1zWMpVJV08Z4e+iyc72iH7oWX5NLjsJCvTsZFUYujt3bTqtWJjQ44xb8ZJr9UAjz1TdbdXgI61i939mLUkcHG9uEcXuiqMqqzMVUL5mD/a+6Hah205CFJcFZShMVBTjNgh9wN6pKECprKlybyRevz8A4KkRNdhCn+jESjM4fw2YSRkmhOBWVPQ+JVShVWfh8paiRbfXoe/DFc/Lm/Hn7sx375xb378bqSkS984RZ/6Sf/ZPxr/+q/Gf/PWz8xf+ntvxMfevOjOWqcXGDOqxEEVusfXcLd0HusdBRReULgAKJNj5yrEMFE1fKZoJUjaZYeevVGlI+H6axOT/GO0iosJqmGCqWtSGvxbpa9rKEHMh7cet2VHv2fqE/8/Yan5ZoETfxbdFTdZLA0snhSBKFpRG7Si9hvMGOFyWLNPM/0NNDVpghYLAxRzqCXNKnfI96tltBuxmlUxvJ7nFpBIfcaymShtH45qFDrcsgJNsAxfFvSVh0MBtn12xqmwRfqCa6QQicq1UgadLWRQ7rOoNLpTKRM0zlUA+JRtb5W5W9ZJMAdaW9LetJKNw6Xikpp5yJAwZfp0l1tgzWH5bE0BMvMqWLrdKbWrWtoxenFVAmjQKEUtxlH9cGSCYb688SM9pPIQxRRUGRU+eZCpL9TjaX2FLpKD4WEabmM23JNLtgQA0mxMIIzEw43R/NYtypA9oGz8D/nTk7xAfVHHo4AYq1Ku5Zr7f7ysIUY5vN6UEcqlFeTfcjzPpVWeWB0jzPxzKE99DLEsE2xles1QcJmeats1uS04zl8RO2DMH8ljCIyRnEUz3MJlAtlQgFxKmbey9dsenzO6JRE3TQnVKSiyLGk5XpkxDVVduLaMZwITAcf9RJhHwe7aLIjs2QxGZ40OZffeWcmKdIt9ke6B7KHFAyR7YEip7dhx95uuqMGADciLUjNgBNysrlbUARq2SzW/v7ndK6PLE4YSsutRNJxY8rLYwHQ6x2n5elWAiWzLULAPQObnZJIKYhwJo8UuLDXOVuVi1yPKDo8TFZ3flDr6rizBV13EQ7zRhLTfdjdRnVk11y3cYxzev6vh7df1DzgD7yePUb8wGfu8bEP/0z8T3/5u+Njf/LX12sffnOXWfLYg8a/4IwNFH9gu5UWajorY97sG23+Ob3Z4wiPHnpGFl41AI07GrKCiI1ZZKJai+mU02fv3S345p+yQGLBoysd+JzBA9/SR3SWPlGkRlli7oXHvHBBudL9XppWdPNnUuThCiWVY30MdA1R4OsDroaw5/mIlZvq7Yy8ZRxNmRIoqUwxs78cUTf0OTmYFIDmrQO9xgXLBtobgWImlygRgjRkOJlOu+oIn0cpr7RCDLBi81TCsDq+9owSUw3RteBgwJiYYyiWUe00mUzRp44wpzXNjBMr0XtZko8j0oWcLQJ6zCXNUQjZPjAFAznR0vEME8WkUXA+mpVtUzwq6cnjbnDagtZAJzzknIBr7lcdlGpFfhok9c+RxTDnLRTCmx25ErritvGGa4RHVbUSGY+t85YOPt9P2wuVLkeLFwPaa3wl1CPx5luC5jem0xVNNYbwqzSdhqRw2GoHsWpQOlqW7YL3+OUhvozgDU7FmXOuPg6qjSojs6lbdx/H9VP8Es9KRJiyjpkaKJFkIAWdaDcHYMj2iJxizKpZpGU9Uw94yuAgdeD0pPrArUZp3KoGSUVoVFXK3KZnvfT99Soa7CPlbVqItVsmw7Xg4qqowD55Fsyw6hREHgLVSohqFY+zVwy+OqQKw+VJc0U6uQMV8Xdd2c6OMOPAmmDMpQHUUnPfAtp6YFInyU41Q6foXnJpgOuiiQEa/h3SN4SGB2M6o8rbRHElFamGCWt2MJ1oIG22RpvGnGD4ei+a15phkktV3a2rS4+dJdHdTdTcs6y++s6z/cnPHl/A1N7X57fwU8/h9dJrEV/9UsTf/dKz+Gs/9z/En/qh750//KM/HPG16yQqhZQjnifMHNA6BaVCztWr1ywDmnrnvK3BSkKZ26QtoHdsFlyP4ayk0285VFoyFbYfEM5iWcep+9sD1beUYISn3pvEyXleLA9TWcqxXg94l7r3tlPwDDdfnFSH4VEtw+KOAUIiVZYAncp+mnYd5TbmWN05dEEbNXRCB2Mai082sxpGc4I3WNAqATDff7Ys56QbxF23ixI2dIqDCi9bFYDVwFqmiKgvqGFc9fuhbWkMa6ZGOH+gL4Obk6WZzoUjbDXq0W/ptoiuvhpoA/OlpmjQMhDlVt9nMaJFoFe04+mQciVaXCyoDP6RF/0ycWTfPyuhQAILPVrARvBBXcEan9hH9B2rUecmB3LHTBieCxyOSjtGuM9lZv4xb4n9QfG45JZsi8d5wBYxOgOjWz5Nr1RetapSB/UbJbJYaQpgUOYqP9vyXHQPR5XqzL5yDZq5/RK+bf08qAqoi9avnLjUNJqOODjF2HWkjcWOD9l/t6aI6+dxCft5yDBITOpgdWDONsO4ikdce7/OwVRj06uATc/v76oJAhg7sKY7+hBzfLS9HblKhsWOw9+d8T6Q0iFjz2Pac+NzNBIdKJ1LgKuxoPC3F3o4Foy6jg88v/3A797paTw6Oj5o9IEcDt2kaM6FSi+dH+a03VoLz37tw4roTD6Ht/gadkXw794xczKidIQPIXlw77x7+blZAd7lrc89OKnOvJRmTr6hDthCGNNySc9sWgxA3e992bzlfJjF6puPr7zx5hvx8sPL8eYbr0Sea/o5vB7+8v/1sef7jt/g9forEZ/9/Evx17/wkfjBf/1j8eqnno37V96Ph5df1UOQQPUiRWWxkjVURgnD8lTRKvB7Ay8MSJRKiAnEI4kQP/xgsXpUg/v1K/uAiLaOLi1WoTcJ19Z9Ny8k8JtJxzgkctCOawe1c1cAPN7CHAv9KlwRJWSGAuyKobxCi2gww1H6mvQ7lXRn0SO38PnO6LW63hSjXueO4nf2Ek+w0zE6UatXuXRrZrE2r0+Y7CP6tEqoW3iddzdxITQAhlbRsC33MbomHSl0CFoMnX3fw+x5cYVKfQenbU4H9gXRFZO58MbXmCD7VLkEDxiKQnC0IRdp32A4liS1nSvrgHpoJ04P39+Teu9wI7xo09OJsDpi+FZy/4zO2IGT5C3KekGwQnrs6AdOPb1HwEc2MgPGpT1z3F7/23N+pq1alFuoH4DWuFggSi6c6A+ec8xeLc6IUuVc0cwvasiTssk5z37gmHS4VNEliMUZqHt0PneekRqWlt03c5tgDCD16eZdFT/4wNDyrS7LtF2AmqAyKYqBRR200ZoIIhXmbpvq1rVlKAnw8OpcegA9XLDzVTquiMzPXsqGLQtF0lBMuaXiETnCWuzwkxUJT3Q4Dahxme4bdWBkuqnDOZBew3hW3/UOdYO7iXMb73U0HTZ3dRVDVGNqxhDBAbM5+ui29Th6F7MmYWvLjvMZOyB7tQfMLSe52d24XqPVF6wNkACtw/BPxf+80SlbTz6sIyeRkQfm1NjfQ9iKhs1332wgsoHGrWpI4vsiFjMKokDj6bQRxLceMaZFFV8s4StR3uV5Nme8+5Vn8elPz/h3/+w/Fv/Zf/gb8aV3Zrz2GtPSns/r4b/92e97rm/4jV4XZfjlh4yPvPl+vP1zvxZfefPVnH/g5ZDj+YTXU09aFJpo4jBoRbTLxdEwg0s3jjBVurG1LSzHtIW8xQxKRpRClOYl2WqJhkXogZKiY+v5j9N0/2JjTNR21ba4oVhNiaw46oA0Tnb8udmHvDRx5llOyOigmuk9mNyDmEj8gwD6n60p9FaVvrDaRSVi601Q9R3grZ211P80wm48Yqiwreutg0QOLrjBdg1omzcMGVy6EIkKKVMiFSTwBxqi609oO0EiFTSi4NcPE8z74Q0MgDpmr9Egx/0CJINhK8qyOCecEB2ZY8wjEGn93VUJXXyWmLZRb3trvs9K4sgAS68QIEOH5cLTvngF90zfkzxaOZooQmH7JC8oQww9n9vAl2vM6YJ3eQJTDR/LSXKqqlcClKivbvdtAuyw7mJeLancOlCyxln+sMG0bPryyrPGMLkEJE3z0aj6OcUqEA9oHLsPqLi7uWR3e3CkM/ADg5ANmx3F+Lzusx35YIFl1z9u09lryeGWp8RO+W30/l5CkETtFGTjSvhyL6qvszRnOGUkDewPTlSTM8t1D21gAxRDFJWyP1mB9XgdSAwbqWgADwgMrokyFNxsxNH7SXu5HDT6KUvtrEuCM0dO+7T1p1aQ2zN8v/5Xmo3TB67StlQ6MJOeCPtvghjFpOt3taBubMsBzJEC25PvKYaHswwDkqxUD7jx4l4e8TRI5WpVMYWZvc/dvR+DderKY5ijt2TMcv3hXU9xwlDs+6f8Zym+nuxTfD61Zmf0Ki7D2dv0aWLE88SGQ0cMfnxuO+4187h2Cb7TlC1dfve9l9brr6/7v/Qv/0J8/u99Mb7w9ozXXn8CKn7br4dPfvo5Yy3f7JURX3vnFh//p7433vi+x/XsvWfx8NKr5IQ8h/JAG0PmRqQGJnSXSqUGhUukHeEqnGiYLBCdLJLcS9JRTQxMITS6u/ObThyLuX5JG8JMtyTjCXawOiXWior2OEXmW4I4kOXRqam8ejGYHqvOJeUKdEWQCvlRSpbO8qvJb7Mh14aJyO1X4LjDht+j/hiNFb5kMf4XqHmKjAjK2aQwav41sHWlvEbGfpinQdei5SWClsYl7u93GwS1udWAaqbBqxpm99RbrzKozsCMM6niUg+uI2Upa0tOIXhybJYK7iR1mswnB9X+urdlXUrTE6KrpegqhVGMquqkvLRvqW4DDIu5PMhZH3A7Hhgwjr6Yq/YRKM6mSS0heEPWncfvF462xAceZwKkQUl5UxGYa/A1lc/ImxVfahpnJh5VBkQ/4IpcU4yOZZqC7KOQC9EKJOYX32enYiunB6lxWuFqyTJ32qB+lcTiWsPTOZk4WZQVnN2TQ26aVu7hk+ewPgRIZoiStrhfr4hzxaGHfn41fjrYg82AqvX4ZPfx/LReADVHUUMaSfSGOjLgJumTfTHAZzSnJQaKY0nnAGgpREorl3AvFj4p6gYnGTxanDVMhYkDecI2G8pZA2/J/i31bYPB564pDcqqOmWOvnPsL1hUFH5DpjQaKeYeKlyf1NKeLKXAZGjY1KdsrVdz/IRHymP61AXXg1gJvnd207xd7YEcI0jUN5qLu2WhgkFqhDYQ0pfEeNcM0Ok5ahB3hkFdEK2IjrXOzN1POgtbCTcgMQ/7TgUlS1kMu5x9UlxKebRHHC0NFHrvnXh4790vxI/8yGO8v9W/zzU7iIf3f/E7I+3l9fjeil//4jvxD7354XjpE5+KfNz3Z9cYSzwxGReUaFU55QoTWTXmeqkRiWuDOnISN62ybpLGhmIxsK7Zv6+plOJd1SjVYS7dgmYyemB2dliE4OzxOJrnNgLtVqH0JEXS4YWZMVHEDu9cIXFSu6aaloA8u0vU4pPEBzHlSJBHJq/GhDq8GuFfHtwHSyXYFSOPTmPIPX4ZJD2S1cGMjm0vICrPGCfq5KrHiiYz4AOfq8CtoISjgxtbwuNUCS2nsrJwT04bQvUotwIeyWDQmDejhjA270Flquwt1oSpaSsB5DmidOwbKP/4gcNM2D1W9iFaGAe4GkTChVXUNM16CsErRbb5GuNs7mmQyGAUXDJHPZgJVrzDLRgnHfA4Hk82m23qWWKteYyr3fka63+SfRZNuRS+WkDyqof9L1GIBNVCNKXFsPyDNhUyj+FVEeY/JFh8CF0AACAASURBVI7+NZFVwXVZ5VqnyKx5lCFK0hKBcMuF5qKhrxg6w5Ru9AnOh8VFNbAmBRD0tEEhr1NsZwyrxvJYZlpmV6h/suiIdP3XRqqyXIVq8yx758ThAppMHhDwL9cuF/8wrGosZWJkJOnfsk3VwWMaarD2SSm6uJZbUAEl4UB9uzpFEZ0xuNb5TMo2PMgOZRFaNmZjNYkITJq5V8Uf62ETSjRZkPUqRVrZBVj65sg0tFGL6m8lkJ1oht+R/FmR1GuRxkspoTDDvWnuppK4udHqOQ4Zj0PhGhPSuzl1YAi1QUY63B01amXjc93LvQXak3AMN6hWLVQ72ZWOFtTV0U51EEMmkcb5SAKNI3cvDuzV9rWjcVUxVYcp0sbhWqxLQzFGiwxGdf3UW98d44tfiPVn/sxr8eu/HPH6m698AGb59l8P8UvvPN93/CavK0e8v3OPP/Yv/uPx8e+6zXef3ePVjWSv7TRt6R74RgzbKXfFJn9KFWOTRMK1kKLErgYPRs+ST05VNdDuDowDVVSFYRb5tSCH5Isc/4KYd8YxNXZpDUO61WW2d0cC4ZAzpScB+58k/6rK1V9fG0xH3ruTaHnHtumlLPRdDMIc0Lh1IikTIdKIjCEUZWuqgpZphpKhe3DPYdHi1DyUjuxpToFWYM/4pUcTH5yAUkGV0gRxQ6pkV20vqWoWWJg1hjQb9ZLFYEPqfCGar6jYNKzCoTt9ugeaDodrMOd6EqW9nO0Zdg4AFYVvwCqq6RyD6Yt55EBln7q6T1sqkSXtqGrC5VbkWDx/QU8lYj9M6vEepRvj7oZmEh39/1OJ9zQ4hWO6isCij/T9CyOEZYURIXOriWpDgLXjYZ4IPa6qNVrwOqt1+RHHIq+EgcOWliWiChUXFbuHAZcdLLC537ovbWW0a/YDkzweJkFLI8Bh+gP3mTDWOqoPz3Ykzk9fH2Yzg8PD4q+WBA1QnOFGBmlNeSQGDwFsxrRUp/LJioHpYfhi25lX1d0HPMQtpct3W2Fw7Bgv7tFqGseyPOW27znwcRmvlAea4odzPIQmyn9DghNBYIMuEOtpHXxUm8NNY2DMNBT9+SxuQBjLB3NfKrZQEL6nNvFqaBZIRqIVAttcc8FwH70qd0d8WcSNYKQN6QuDYnpvXfmRo6QrNrTR1yO47Q5VQpmNDsJSGzHMuC4evoGtKqcnDx3FxBFiAGPD/6I4C+eCiWxS4ixGkDp7qv2vNeyqcQA4P1zKoce1/tbfGvErvxgxX3r4NjKBr/96eG/en/ubfqPXdaceX8r4vz/7D+KHvviR8ZHPfOIaxbM7ySuQmuteMkfx5FV5hvtliIWCZnmpNqJqJDE5Y45np4pA02HzqP77zIqe9NDkMBqFo1dhBPEpz8/UDrJEw/k2bBFlym4+6X2k/HXmH7gK+VLCWYCjy1hPNiynJZP3bwShtums369ERn2V0LfhKzYmjvJg+PBinMGooqUnRHGD4VHcGzJtyvd9EKmT5CXLM6ipXbJ6TWzwjD0j7NH3wgelQxWSlfR68HCYVvOaVFuj5SYV2Wg37TyLRFdM3u6VYMyCOW+Gdw9BcguXi5qdzZaNdKwCUTD+avSDscBDhFmtkGEXXFTXKndUrZkPJRfY2Im++Fa0oijv4rgVVndJ50l+T8QShpeQw5HqeImzkTI0QNv2PJM5kL6lw3ITMrvUHB1zC7W6e+nTofMSceDWtC+TIKpKF4bPwQmqeigduhJ3OcLV7r5hHkBT77v0SJjpg5nuwkGekQlEzcjywcVcF5JWcUrTtldLOXxjSG7l6zdb26JWz4g8OkoucFS9O/9y6hUOPCvxK/JRnQSVAStq9AbSmxgSdiDyYa1dRdU+1EhWJdZCVGVjsk1IS4A7SCPwJbQdmEL9AWScYUUNp63Q1eaeHOdDsOiLuayS6WAj91WErN3GVC+vpyEL8M0jse91VBtloREPd0jPwF0b1jmp+bwoGtuFlbI8wJnNDPSlkhrz3We6p+PQ25kwN5Avbx0SVsq6vWV9rQD+lS/P8T0fveWf+0/v8c7nL3nsu/G8Xw9vv/el5/6m3/BVY1bir/7sF+Ij/8JaP/zP/qF4/1GLdgkxvWrG+109esw2gRMFX2tM78bTUY4M2WSVqYaa8zOcbIxx6sQFsA8PCqtHdx9ioCh6zolQcqq9t+TQQdOF8lxDY1R2HJIO4g6zwTdsrQE1URbkokW58ALPG3IYNr+xyhG5MsoaTOTNBsll30p41OWczSZpRDNvxZBlSMEW3WhQ1lhPshadOmaPC9TM8q+K7mmnSbUHY/BggflQ7XN+HNtodPhPleQgVNFKg0SRLwrL1JSKxfG31qAVmkAF03JqlFAHDxABhEPVLGevra3nrYbriiVCf9GQEjVX8rYR1JjVBckjV+QH1tExC6FLC0yEeRh1ak/1/+456IXJaK9OmCnC0zaqWYnz/pC3CD1kYLsyud8fO4mhLdbKxOraVA8/KGT2nkeEdLUqu7Uo9xLSqNZ/nLnPhvaGjoE8gvhCZbN1mwUpgd7MNCeiHnEt6AGpCCJnZQrVyJpDkMBiClKwtDQzLfKAFjAzT9jgrNRjnMEelGS4xIAqAAZlidoWKU55Z1G87UD9pns6h76fZ1sEHMlzlgOPQBzMYvWIWFlun4BngG5LU4ZdVtEwTnTN6hBvIw/t76TjrOg4OfVJ7zR4C7RSpJp9vcns5aR2CKu7wZO69TNayCcbVxpKd09g6O+jwJ6a8Cg2No14DK65+XA0pLNxDrpbaKuYdJU0NIy1pwaEmuTGnIhPdl9z9rDFr3MPDu5BzcpylRVMHUUx7zgLycE/mBbj9zfRQC2Suot3cXyorZGHDaDKo90mLebBsPMAyHq+HpUFefgoZan8Be8px11rxauvR673x/0v/uSMz/5CxKtvvPTc04OHJ7MEvgOvSyfx6hsRr7z8Uk2kcBwwf2KOY9DIZlpeB8O+7bJFndpKSRAqGNHNl9TKo4pmcI3Me56ki6OPB70GO7cGMMm/1CgXdo9LJn7DCQ+ph7ToLizAcFyVj0q81vZtH5xqrkKpGtIksmWivi9gr9BlU5bRMX3eZL5jMOOoKAtyummpIfikn8IskuPYnIQ3b3p4D6PzFN474AyUu9cIKybrPzmMjChrnDEMXj077tTO1267Wb9HfMAZh2qxe/Si3tAiLWbzZAKIPCtsoWyIhQ+ags8xbavzdGjInNsucAEFCd0ATBVDCq2QtXbxIpek4rhxHQ/YFQig13Uz7/r/1ZSpU+Ke5zLKeUBtWk/M0gqEpG7MyJAFnxvWTz2cScm4DJGAGFUCdwWgCx0Y4zjEad5g4+2KHX8wD+O6Zg03Bo/1MfyLWYMN2nfuLAjq9KsZGfBBVp/5VHtznQ4P3W0b21RrBsPZFaGXqNFOiwbdU1CjJ9XrZRleYWguPoLrn1bcdJTSmy7ztjfSNwW27TfDd3DUvMCTcQIkynDIvUdWHfF7PdveMToRKkQIp3IMhsaKPrQYD+Fiv7MvWMU8x+a/p4n+cHPPPnP9/6sDdC/KNB4IbF96fkHLyvdqDKtAKqKlRuWLmV1ODteP3VMSwopsK9rcVg+T/IYneHYm645cV480/1j7hpVGjVEMzg+yjPKWb6WaHEs8QhMbQrJCSIzhoaNRnF15FZycOwoqcd/yA+saMEkl95gQAyZXG8J8kvnL2p4UmpvcPodmMIXWlMcJYHdg6L6S1Ip5HoehJPpS5AiMHBkPL93H/b5e+d9+ZsSvfzZ0R57v6+G8Fd+Jl5EqB81iqN/po2n97qFAOADUn8i5tJOHU366S8A9OKGIDgmGZ0JOi62L9V8ySsfK0Y20hfX59hzy6K2dn5cqpAYhZnfhO50ybbO5Rdnx7jy4MRrvLSXOpjhatmp3HIjhQwPMU/BnHST2n66vJ51mDaOFtiFDr6zBBWaNjzwfifED7m+FkuWWBdPncfVxV/M8VVREX/Z0x3bjYAqyfH1mC0iWpKbbJ2Mu0yDKkhxIHRa8uA7J9IV6jyqppz9ytBYkgKKmWJ+Lc4QDzEmLAYvwkMbhFnOaHztVrYkIU4x9QbXTMerg73X1JB2AEegBt3HgyPjUUOxoCnYOrTDf02Gjz0Z+6Gx34tHSXpP11wvFiU8q/TzePbR6lpYIBFKusL6jBAIoBrT9GG2jWv4DOFH9gSRk0zxFL5oRjDxvboofRBjtaAKsy0Jb7u2vc9P33LzFa2WKEwvDXUb2AEv+duwvGF5nAKiUc2kpdK+huYBXuX1Xaw597pEgnOt/2ChTvf7z/hzVbK1vPOfktKzqn2kpubRdkphqG07Ia7fRvz+OehpVL55ry3iPSPa4oXMvVtkaYDTumrDuzqhJnIw20Pev6dPjMnus/aLnANkyygOj5nJPWol9ZHl5tJGHUtmAsMH/D0QnxGRqUR3Yh5JGTsbRqR/0nYzedk7s6ju0rccAEgUW6phKIm+vLE/uFun57EOSQB8bgILLgIoCTPRUHZMHjmhsf642F9dePfETdoiO0dyT2fJ2Te3ZHffrGT3GR747dzLyxlvPH8TwSJ/v+P+6Et9DG3YFt7Px+7pDJBfntyosmBrT2e6mqhbkVhV0t06J/ki76gHcBHpQqQ0nBcepEo6rynzkIhE+FypLnxsn7lghm9QjA9l/uZg90u6FaZthkdRnMJIHbYf3eLAptBsyFyPEXQqFvmsq0C1VRgF26uo9OKiBNJ9UFeXrDlBN8/fgTWkjHnf06ONPQaGSSm9RWEtEVj3H9OZ2RFnW8Kl1EfRwT9XAkGGJYXRjuOrCz9mTpHTbkhu51U3zYLYU03PZHHeaW0LwHvVQ/KDmTe5Avmc55nLCBikAEhLhve/ttm0VzYHGEIQfhY0KUE3YnvoWkwabIvV0SLQXU0BlGkcGMCTdGH0ASFXSKVErA+1WQPEG0bF+dtbgWTdfOBURUWFoB5DiU23BZDQqUaJXMx9zqvdDHLb5JCtvTe/N5Aq7oV7Z9phCRksGYq6QTlIriUat8XkQSttlhRgTdnYeq3Nx3i98f+eKMyNy+tK42R5LdOm4b7Myv9kS/V1c20lT/a0PHCWgVrsS5amfY2CopPAlmFTJJSbc5p9a9rWotB5VTe87eOs1wq312k2yP75/umWkAl7PbnpwNdcwWXsVX9OJxji2QRSvbZ/KbEjo/FoHrLqhEepukvPZmCVykWvBCN/FTByXwJMO0URsEKddJZ++HkN0JMyDumxpLs6SZs7xv3Mflz19z5vtE+bf2cM/pBQgsUbrZU99D6wb5C4bBPP4kzGkd6t7IXMepEO6tukL04Ml5/OJIQ/yelb3izGR17/EkpuPZ7L0vF8Pj+++/8Le/Ou97s8yvvbViPtj9TnuEn43LaKktzemgwY+APM4LNwfG+XNNweyzbSphnhjlZCUemtrU9QOY9OsGylrvV06+ATs9mkK0TCge4B/VSDhxhh2QDc63d2+en/q9eHThCV2o6e+64uliv5UvURg7Ttgu7ZETF4BlTGERbvJ7Owa+BCkAmoHpFy0Q0hqZAM0VZBm17I4WsxOSlwhlIDH717ETUCYeYxyS342q3oxIfU22HjTg+SogLt/m5rzC6Rhk61RdS5o+qrbR76pu5muYFND25YqyBEQ9KeuL4WQnxKVER5r1TFmeLSNfvLGGaoFwqpBJ4aPJu3ZavgD0h4WK23WWYHyfgS5aj8ns9wOiUZ93uGRXXFMXjxUzzvVgelSwWy30lev0coLV+Rt6q5wbEaTCjO7ChWAO6wQCqaJFmrZP6Y8l+pS7nIQecA3NH6owEhMCBfGb6MRoTDX0k6dpBhTkEwlpUPzQ4oCgFnLClGZ65lMBgYg6EvwqzYWdO7iCdXByth/r/0vEG/2CajEEiH7wWFvyLjTTf8shRDo7d34JSkEIxlcwZlCkBqeO/AGskGrJy8i3v4gYGMVSwXBttJia/SArxBC/eT7m1JF/jpiilJHv6tzllNde3MFT3yZvZe8I4cEzzA0NBIAlJTTXSkNCt6N78HNWeTKN5HlnriShEwS6j4vjREVA2YJTquWXn2/NlTshK9sbYD0ulXocYVg5Bj7LQpa3w4jOel816Q4rY6mExSLUP4GOgkq+HesxjSgZ/RIPrmnLywB58kIy6tv01NPXsDr4a3PfPyFvfnXe90fMz68HuOVN17J+/urur+1wjAG2Ce2zbEpxY5BFByWIbFAAm13OmCSVAOrEGBDB18R/2qEAohWpxon/4G/pcqfJaVcg1J5ODAbjpOzolARHQy2nWy4bLBj6GH7cOLIpgg0Zy3S+9BeP4p/efwqM0R4Fz4k/TWr4RjhMqclbAB+blHz9ogRED/7cDlOmeL+hsGTGnwvgb+7E1jh4jx4nHGgpnY3rBdCTfeJJ54OcXz4AAUSNhw6fORz4qqVr330NVgK0nfKv8U+GF21Daklt4bZM4QGnbaMbtNFPOFlBMjRQMU0jvXnfKuSorq+njyy0vePyzenLksnbMtuze1oFdOTeSvGcN0xkD3T+U34NbXoda7BZAqeYiOSJORwlUXW93lw7MYcHI00VdmXLaN98tIS5vN3m40FrINqcBjqhVagL2lpDY7wtkwbip/PolOOJde8002fliazniEPMnsHRvbYFHyNtWsCvtZH8dCTsaA6MpOKVUtqHSsnYYigFwmnpQffhqtPUM4FipBNHg1HxVDpc0hZj11n7nEfiYETo3yMjCHQmsg4wgbWpXqwU3reVe4DGh6h7CUkgs94cjEZHctk+VdiqYFkq6dAjwOBtQsU+hN37FcNFYYfpdg1y6BjL5P7qMm9Zbsj8MF7ptq8i+Fz7IeDoG/SdtIOMRzGs+a8Gj09W+P7QPBSEguTnx3ek9QBeNI3/CDxyma6lwaMWFlBjCb4H3WVt3A5M88ZMFxGetT5C3k9fPQPf+IFvv0HXxnvffkxvv+f/1R8/DPvznfffjdeev3Vy47yMoO87/o5Wmk1B8kj1lT1IO/R8J1hremHbH7Z/vB5qmfT/UWjCG5zaLMK6rULG7OZefMm0ZvWPsjQI4czV5Ka/miB27NMudXQt5QKelubE4Vn8x3BARyFwJX++4GtQl87+Zj090NcdQWmg7kebdbeQDHHV9mGOw24NuqMluIORyzymKUDZQbafx4KwqliaLu/PgitqKUOM5aYooKlcKNuIdR/T6O6s/pCe4B/nC5ww6ZGx581aKrmS3Zjd0+obCcpw0ZkcSqnmjdJnaaANc2QN7FkVKTcsG6CMExXcvVVyix431kMSGRfMrKffYwnK0un4RPwRjnmoeIZDUJs8uASoXP0PhLEs1+LKe9eROm3csIAxMS9lFvfo27UrBEZXt9tg98UE4mgIvHwFIKdbu0E5sZGCQHEwuKQ+oYrm7Ox73HNvOXXDmbB9CGbx8knq2QlYInVfP/sk1OkO5iwN1OzC7Mu3Pw3l9Xi6tRXv1/FpxcN9xj+tgmuyMV4hLTcjFYOraRwspZSFnXxNTUrYknxNczhWQOl1cFiLUNxt/yQdeSyOZ6RCJlDmuhMIeYDbqpiUobqJXtm61w8if3UdKWwG50S2DvtCqWP9QDkZ3zNx5KJnFQremCDYmk22bU86Wh/Tkmde8p0NmCsp6KEVOZ+yf2a85StGz2mE7soauERHvu4k8Jaw1iWQEzme08A5VtbUZmmNzRDiG+uWhfRnJx4K7LN2guLSb0674z0KVtbKXZedapnPQNBry9Q8PLw+M53tk1zXctn/49fjo/Nl+IP/sgnioUjEkCpy1LLUECSILolYnthajcRsEqV35l7d5ErgCyXYU9ATwCWXONJLBKbzVWzv/WUXU/hITuAzwFNkbSYIw3WYROuEsc+qnQaIBhvrUo6aRb0BOvgynSmi0GfAnyHx0WgKJAeYsgmvUSEd9r9tlITZK5Jftk9mXRpVM1X+A8+hOndnmDIGSi1fdtrGW5HkI8rKZlystecB1fX2qLuTVqvYP6s1UPNp+kMzCRJhkUV5precE0sI6ljkIBNong02Sc4+oQMboW2/01eojXK7IBopidp8bmsrT0csMbH1VE3l8pNM01CZ44Ag3E+HB2Q9tGg2h0n0bUTKQW+dSJZts43/h59nQhxWjKekAo5GWgzJdvoSJiH22Yh9BHyX8HPdSrjRn6HieQkR7lLDMb2QD3pxPdQTgTLVbt1TzU6uF/+l7h+tE4Qwqk35YRRyUnnHbS21ENAuRo40G8vWdwNG2VqHCoLvm1cVwmwQZqsOYx9bx0oVdwnwwZMvHT88PNeRjSPt8knCdHo2kNIUv0MDF46XLV6j8Sk5+MNc+yHRC9hAycgMe0xsACfjMWqPSbG9YBYAGhgpoWpsxJs62kh74aNg7c94S2dFC7XlrTw7JVn0UitLwRliK2XE76wG8wxwApL6nksdKYblRWaps7080nysmklrWa/uhut7a1FZoc8pZbKYJ1MoRWoQbLufB1efEh5lXfVII0T+VgKtvOadmYbT4mTbthhTilJN+S0d/u8X9yJfKGmZA+vvPXqi3z/p69rNs1X7/HJH/3eeOvT79yffeUxXn5DGVjOm5zw12AYfvauHs4mh/uo7CA3bDNN7A/cQHT2iBrpCD/SNuacILUJwpvaaheFJ5lOO4vsmbdhlC84Ss4jUv3FWudh2nZYaK7+a7KRU9o0L+5U1Dw19cGYuWqFrxyoQbbc1emOIUoZeN/K+TcP8qmgSb9/Zf75dADTQSKjc34Yfdd4kGWZZ9PLDSibbUmY4OllTD9jt21SiUS3DIYPuFAySU0+4e0NHjwRt+KFFZd5RsKjNpsHlnmUYnBG/VeNSMxow628Uf4mMHuIjz7SJ36vjf+PuLf7+XbbzoLGGPez1v4sbXdbvqGFUmqhNg0l8cAQNcbogYkRo/E/McZgQjwQCYnGxAOjcsCBGA+MGDUIJkY0MYqoUSGKBqQt0NLdvdv9sVb3et97DnPP62PMZ7u7t9r3LT/o6up6n/f33B9zjjnGNa5xXepAuzWfko4s9ceZVzWh1qIx3Hq1fvCTy+Q9c7VTp+LNl3yhL7DU0tjZhTJDNeQoNU/cWzWW3v5SRqZxQQlBsSg+uA5+f+Jzqk0l8S9C9UYU9KB5Wqhlk2rJSgZ7sk3L4bT/W4r2RaVmKMKLvWmxB1KrPI3jOxSJiNW8Z8rO0oR/hWfFWKMIHBR0Kl4QT1qux2U0yMydjCPhTENOuJHySK+knRUtuP7VgWXyNoVVsoFmSrDi3Db1EheeqKT9NISGuBZRhpw6BXFpZZqONKBimgUYH22BVuk2CaWxY9o2TDpJsQ9p9CpDDmM434QEgpO6dbL3b751bTqOAdw+yEA6cRSJkKiGuTgyZpHx3yTG2vZJ+YlcghdFzgi2CQUqM9EpC4k32T15WOHMiVhSUIxD9eXV42fyF87JJhhKecBxUZnYzOZ5q8s2TdWSWriI0zzsUiqZUdd2yol8xrcxxhT18vz0td58/c3++Tdfe/cgxstXf/aX3vmXfrvP2zcdf/0//2r8xn/su+KDv+93xCNwNgMkScu3pqc/FxDdPhdr7gM+brNOBXxx5uSJnptOso0e1uy4RmXa7B8TObUCk0HpUXHmgjtF18oMZ//UobUd7Eua8yQDGQ7k4fVrThAXVsUBFxe/t0v2KdL05RnQcZCulxeo//r++9wwsqrAOXA9ztZPXROUCatXLljtubhTutSBSP/cjjcZMUhSamsKfsTjsLj5sNzwuhbNxaw1OL2vAUml6TNSFM2+BYeL24P+meEJoRyNA0JTAs+gFZc0lG9yeBf65jrUO2dYbuLndHmKFR4RaoCamoGsffisvDVwLC9DHlAtFKtHqAsUuSq1KGIkHI8JnWmnkIjWJ+49j9ypO9tFvs+hR1K7xm+0JQJKGI5tAhMFXFtl6DcvB0xByYbA+jzLjUoa3FkYElCmewJbI5XmFFGnYppmg8W27EpAg3j4ELDwgG2qCNXijGnKPb3hO2eTMXwz71yW31Ofx3Pa+G9Ok0/XKSdcj23z1sOqtCiYY4sfnFEoD4Kl5qoxLEx0ocOILqcOeUejx5Yy9dXjTCod+v2Ze7CdDm4FmumC+cnnCJJ2nLTcQTyWJAdDToQDlTIM13K9hvdZfD7EeAXo6QfG/dMrxe2mc9JbxC6AdWUyyLyN2P6oziic+fiwRyGRfeyZmDXAwEV/zX0jxQ4medpJayW2Srh2Bbdl0jxELvO8sldQsoHrUbQ2CT6CZahGhZsimIbbZIaAufVZXkkY0xivWlUCm2nGvbk3q+fd+bZxGG220p09UtR972X4uc9GfP4z8ekvfPZVYvUuPi8//5f+xrv9xu/wWXfE17/0Nn7/T/5wfPC5D+LNV3KRK6QTpxVnTlmjFa/o0aKyaSoBNcRyKIO2ngCM8hlHThdTkSTThD2/9sYwicBLpF3ZHq2jTaYqrzMFdvAJ+2QoyNKdP9gzmYYeDq+9mEktuB1t99pk+Fq7D44EaCmRQNv+8XpJe0ugIOZpHXsYTrLQOGTJGG5qQGonbmeyS7qq3LuCkOXIqspplXiGPtz4NQiQS5O0R0ovH345pLn0GPQBBLfnkUgQIoRnCT584vxqSqiknMWXWOLtcbu23cl+V7fstGAWXJaKYqi4jVx0qw/uw9hIJyDbfZSv5PwSjERV0jxxaGW8cOpOtoM+pJ+vv2VaVJpQsSI+rryJqdcEKfeim9MgNCKpVJNImlmrF8y/Zfu4psLfwfVeoec/T3iqdhFsB10TZZjcFSqtaoGXqeG8lIOwoB0rG1wUs3gyy28/qExewMgoELu2OtjTCuNW5kFWJPzdr+lURk4K67elSc+6FenPXiwL8wHF9XsSv/fLcAoDYrCYorJT0DkQnqLhu5HOr1yWerf5Q4eyGQhtNkRKOhPgQIg0sFCX8UAa/KWk93M4LrmBqpkuxS+TIBcHJwDvixDi1WW9EAsSoJdQGgAAIABJREFUTuISZ6JQB7XA3FoXEkZEkYVwoGXz/CmMy3shlX6h+qLjcyi9YrMt2VEvPzOhuatMARH5Hm9jlXawtVq8QjSoILLElU6WK+QfrvCl5zeE/5WSRxKpjoWpsSmdS/QU5gkkZq2ZeM3GdB3UsXYNEBcsErHKhjqShsLiHJ3XR8kinj9GnOKmsS41Qmd+gw5M6o7xeGLzGX++4gWyMZiyqvj6l3+lfuOPfHj9M3/yH4k//6f/UnzwpNkv38wy/7V9XuqDd6+k9u0+zzL59HdnvHz4Ya83LX0Zt+IvAQ0SyPExhWdWtiOaCiqkiRebG8FvKyJuq50UUpEEo1yI7MuNgdUUF2dDP70XZ0ti5NRa0sW42UdSK4haVgYcDGuu06HDXbS5DFfw7TbTczmXUOVpphg1WXvwTYiSWYRbhXPX/Emumv6+eQ6VPA0MM9pGQ6AC0hxqDo7Ko0BxYOTS+TiQQw8CGVEQBF2EpVABQPa5Z0pQrypha7+Tobw5OB+q1jmEaXyUrR/9uQBvcRNw/ipeqfpkJUeCB7FsoiuhCWhvc8ixqFfkmb19PhnY2paNqTiUOixupWFSctr+qqAorLQgOC4y5XWH9IEq2WpVqSEBjT5fbLr/5lOkRoZ9Oc3Ep/ooz/uYytV16iQn4EJWjCXKsmVgK4SRqXQ7XxQhyzypFJXRaQrkKhrnM6At/jmNXhVx5bJwTCU0Dq4k8nHAKT6Rm1P1GZ6iEBcmJd/s++crbqbo2BGlkXN524QIfmEJf2VScwylVfz1pVIDXEoXQr9fEcJSqwoW5iazh/9A5M3jGg1BkyaHvs35fKJwTO+eP79TkmdDZx8NU3BZ9e/EaALuoxqv7RMKPAf4Qo5D5Nx5JLgkwrC1XtKHv1pBS3wbegfHFInWElOZ2RJEWRz2SR60HpdLk6qYz+qlNoOacjM2Yxyf0VLhoiVs7YrR4+9EiHM5B08qRS/ev7Sw9vMr8UHRF1nttozJBp5AV3/9bkO+AKMW55owtr6vu+QDhiIkJn4OXKzDbEsBEXWFsBWoIBLmFRTVtKPOs9xwtA7ykhMiu/f9XNk31ku+1Cf9T/7evxrf9+P/e/zKN17i5YN3nIz80pe+8U6/8Dt+PsFGfns3cdr7UTy7tzBQb2pfRt133qgaLeEVms3c/+umQ7772jujMIzlHgXVrZzAUjt93bmggvU8cQyVw3MSCFXc607oeuMvU6qzNEe52AkWXLyoOy6OwJKVCYMyMfFiok9QQlsnyzsKi5uliWWGC1nWMj3uBqW9J8LulgnPrYwbHaimWHNQA5oM+qrD64Ghhz0QcVA0zUViXMvqXGUI1HFTml0EmxmAtvfOCEftiuUilaoJwixlXbhp8XMi+NR6QOAd1zJfJW4EHAlfvBbfh4Ww1ULoTE+Qcp/ZCS0q5SnPQ7hYKm4Nk7XoKxLkKBpXYq6xOw1FJ+ptxw+SbDHu3c9DTsrBx7pYiS1UzFdtOY/L7SBkoQch97ZSFB43ykctF8J4GTmdvNwCfJvaDWyoaFe89V6kfk06Wz33R3oU6fnkrfDwvtk5wgZ7GNBXASlG/Lo17JaSaRj8iMUb9Dw2kK50oSRTPRSTQp8PWkF296q3lIRHutLs+XOxbApNi9mhOUdLlyrxSlFVrGQi5lVRLtnlYoGWscjryo0l0SuqFnlfNUhD3E9hWOR0UWvDXMknqORWsUh5ISD+lPavETfjr8hYbu7KlDZ3SqMOhO9b++MtSUQKBWwXhjg7a2GMcIuZN22cBn6Me9ctildBJf9irvGoujAvFudtoxfiJBE+251k4WnMty8lniRqAeNDx6NIzcAYgCzo1mBxXD211eZXKfF9EoYqBngsjHu1tdyE+yaJoPh+P1uCQtOze4LBTfeEtFp3cXZzt/LqXuSGsj3UpmFRJ3yfH/wzuuAkcbHnX2/WNQKo+eBaA5KrNU2BSEYSGIX7dvzYV+QUBN10jV6tzT1lhgZaCvxQJXX2ttcp08L3N8XhzcWK7Yf3O0RHLvyd9wLpjc9/7wff+MrfebP+6B/5K/E3//qX4zPfPdD2u/q8/NQf+PFflxzEn3XFV7/2lfjgg8w3b95E1mfW9uDYfhhSZiYblOffcoxT3z4h3L8WJ6X3Oy93S9Vfhh27m/097YTeemYi7yCwq0fCIvNeQPBSFIKUS42M/MVV7EPXDl9olpkHNuTkr1proigyj5LyrzRm5AchjrVEN3KG3qhXpQ2gu8bWflZQGsYxQZNCZKyrejtpr5hCpNi7WTve4gFgSpFpng33Qm5SYT7woVoZOvpZvC/3oMW99PneApHV63KZMmBsaRqGz4RuiVAZ2mcBpfopBKdiqVXvnP4SyBo1Zwqa4LbxEEniFhOCAdn2GyR4sdvLldTykCulzHhPC63ukgNbakTTKFdryJMxQnAs1frUC+ikkeTDFOKI69gapHvWFGrCDFSKk4LfpxrcMHu7F4FUCH0RZwlIQsxyJq/01di33OBxU6Xculv8Pe2GpQlD8QTbj4CH9JMO9Ojc9LFOJHpGGLr9/pFj0X3Vgpk7C73hJcauh8CfMgFxNdwb8HpHa84xCl24RjpHpMipmRF5zuo9l0jA0dAa+b24c9zWbX1W7VNWEqJnFHv9aGfBszbc1a1MCWZzdp7FsUwhyLtFj+JRR7mI6jg61OGCjDaNDDHFJkjLihcCzDJNdd928eiWY5fcoVcaKTMO1Ht6P+soOU7RPCBCK0eS0L84tP4TSvLPJa4lCYKWaSPNAYVMsX2sck2YG/d+zbyBYh+fi14Yn6SEQ/aLBRtMMsbq64TMyPDa0aBac9iT42K9svYYA1uu3e75iFQqnZzuW1gaDZwlAC/iC0u/50vuNgh0sKtkm4McdNEHcWhXs4aJ1ayk0vwNFnGNgtOTMO6054ONmFb8xb/8+fg7P/PFiPjUry0P+Baflz/xL/0b7/xLv93n6k/Fy6dX/Md/+4/VL/7il+L7vuu3xbVZlfuouUlIvfpQ4EySSMXUecYDlvLoZHkaZpGJyI7tvrr9TWqG9iMhIjiYcVuHH0SmLlp5Afy4ERO7eqfrkCAJ4fmrhCHOYZ5LxogxUiLRlF3gFuVBsUokWZz7SbSPqrNNKYqbqfXed5cku9E16WBVxb3wUD90cj80Xmzrpb73M6TFbb1NYaXJqNYJEmVReBe020BDeKI9LCpFuJOY+8PCuRi8OL+2iORrNBNAStrB5ZAfhJahjntmW1L1WuzlijwC9zAP/EGEzj1yCq8bIt+oIyb3rDxwSceWH6FS5M2SXLIFI3iWFf3Gbz4/qDZ4eEM2eSDI1oWlXNR/W6Yd7ce16mrlaWvjJpq6FBHzipmO4dwXGkZ9B1WKl3JV1KVLUK/OHYbAknIb01Dgtbi/LB6huxIgorzzEs4HtUiKSiJ4tMflFmLHs1mzlwZgdyy+mMmk+C4HVYoYsTbHyAhNgk4R19TcgloyLgDGrzWNwKvS8PXr+Er15saXDOQHgJmbbABIqB7vSv7+okZf61c01cZKTpMxdQOTJIr3JH8/MXvGDKbuDAuIaK3SBc5kmWyvWWbC1KdFqjQq+helX/LwGuGLDVhcatACvEVuwX5UgjruHi7W50olvUl3EnY6ToVmOxYL3E/OwumclH5dScOjW09SZcQGYa5W/1oxGzLRK3drYC8ptNALbUw3THA+X0n2OKcChLi2E+QQrf05THoGs7g/hFXoL9G3ZTFIcH9gJkvzU4vq6bq5VTMViXi9btggWrx679qLDaQ2UQgouaO19KKCDoLJ+IZpGtDndiBryd+UXyjFGYGMk/j2rI9h07R8C2gqlRgQkhHp8/3rMfzGFuVDBtxf8zDXenlSui98IePv/MzjTfPuc4OXf+3f/Jff/bd+m0/fFWvd8QP/0Jf6x37wh5BZi16+kUWS45ziesZ3fymA3sUIV2pDp0EzNUct2eAqJMYwCQUPYnHJQdMiVy3KJz5sh+r05n+5Sb6QNKD65OooIaN/vp6IzXK/OgTiMOJqZlTjFSqQRaH3tF+reY7B9WTCAsaqgvc6+IZxakKxL5Xi9TKrTmLcPBHL7ZBFEWqMdqWvAoFJas4Iu8eXknaJwN3ripEoU0phagLfKgWds0S4YUdokbEncqyCvvTbhJiNpw+BS8iIC9dXOyHN+iv1xMkyuKkaUpZn30dIhwTM0P7gKC+AcO51eoGVMAXBW7Glk59Abw10p2886XlgxZxRQpQ4eoyYVgWzlpxvedCcWuUBEv/VHGZIDhyWSe89/SDROSvAsmVfNQOk4vMwRvpkM1kTC11Ecl3DEp50KM5YJ7gh1AethVgcGIKo3shSPBhQcTWu1JjSzIL6pXuU021clurAFpYaHHmClanbu9hREeTKeZay7JHV6dVAmKMOx6cZ0NguLbE2npJKfksteF0ozxYGMfZoBe1wsusOsusBy08qU1IvHzQt1dx9PZK0Zo6G5z2pPeL4uGdEg2eSqbhPS5q7ZVpQHTFxC5f2CCi3oRKRqcZWRamIEOWdCwjNKAi1tKwoTB/19Q2cRlxowwj1Wi92+l5K8hEttqir+k/co6LWN6foCISKnSXWIsh0xHZathx4IlsaankemNwt5J1b0kYzuYq/qXKpt7GuRoXwBp8c5p7VKJKa1vzQd43whwtzkpKxiEocrj3uprBJuh8GyND219PkTjWpgF+E1kGh7LN64FWe8Xgfn5c/8x/82ff37d/q8xb/7Z/4iR+6P/e53xeffLVpyn+BqYB+v4YnPYixz6VuKwukF49mYo7xFMS6XTQUinxFk70YcowOS6Qu91R3drvowsxFVX3UiETBS/JNoBuK0tLpFi01IKXqWkFKWa+QoogrpJB4K05qFQAgIg3TnISwqx+aPgUjNSlvsYc9hJA6Vjs1+8YR2b0B+0BUvfhV94LQuiRm1aK0ID3RMLsyv3WoUrNCgXzusj6ZFc06/X4ksW2ummMKgX/cuyRZdpa+aAJUUDMjelyp0oyxlGqdwmVKDlntQ20HZIBjTJdWW3eZTiL6accFBvAdh+jrCIGcZrqKiLqWZQfcjSuv5WRFuI1jUSWWucSEBRVslnObgP4srz3rhqLJcmlLIyWMzey6M8nL0QhSOKntPKM2n8uW5SJ0G3Dn27Px7poMTBDEoJ1Om9mosfrnoQilEf/XTEXSY0VB7a0fqHFILeTmkPSsUBqUAffYB/+ibA/n2cwX43pdvRVRsQvTmIUNABI6k1h9vTDhvgc/eORZKsLqO1DVEr6y33xuo/VAk0STGti7PjQWzE6ozk0BZozbgaYh3giRdMO0wAeZROysc3/tLTVIILh8DaYNI9eRVcmitm1yLrU8+IQziIN5UI3lvtaR144JmfMObV+cR3yePqAQiGXFFgMHgnr4+EHUN2oQEgMl0+4GqSQUX7eBN+Hx+3QXDDV/uH+I/a1N+dBD8eBgr1U8B4BOlESc182AYxazFEpUC6Daa43sslzQJJqhNLFJd6JwMIX0fobF1Ab+hbBMT12kJdg80PchKDkEDc5yV3POSh+SpI3pAkurZBQsGlPL+7JRQKpz2Ey3NtfsLYNyjWzje/m8fM9veve9n2/3eYzy3nzyJq4Prmv1W6utdlAPTl5B2v5mV7SopNIjVG53/Mtkypi/KL1RF5WaIkmI687f9D6rbXZpYQZz7ylL0LJ9ptSVpQNTxgI4hbJLkIQU59Xaac+pm428gnkPm9hiKoTjLOOq6wW3O9kcdGKVxYNDYUrTNB5bCtB1U8QzFbY6iwinpGAbHQgoNpyUWd0qVALwwwBVFlzWVNp+DkU9N4onzTWyyhZwclzYMc+AlB0KRq9+JM5NCapmhCZTSqXbcMgEpva8Qh0PqIAWi8EVWoJK3Ph2nfyGH17GmLIvEdeJpfSWdnENs9FXgt4cZgffhUBVtk8pENjkaHUxXVqaFWgSWjFQOdONPMt9f8Rs+EYHWgehNTRFha4Y6fyvZPrnQb1We5V6nXsuOBNERBAbA/q/zvB0JjIdwEwyaGAXsnd1Gi2G79TwGvejow/OZce/gUM4X70gPHxyvjRCMH+U7VSFnFBZuxOjI9F9P8h1yRDNlRFrW1WnsmQRl9EryDwzbR1pDi4PT2kcySvOUUpF15rwo4iweGZdBgs1BrZaHlHQq5imwaajGThryfnFWBwAGxn2m2Jm6ekeM02cdNoXU4R1FJ9LrLMZTwmQQtyDE/i226LX3uecj9ZL6plFiTguJ6QMxK1H59QUE0RLFZi5Tmd7T9vbriW9nzdh1Ev1ohIM8ObVOmFopJOVWMXM4o42Z1jLt1ST8fW3ksUlzeMWUq0IzhNRLBT+x7l58fBlt22ytEjxSlMOYC41oDgDSvrSe6mJuXJOnOe5f/AegZF4eZ+wy7f8sAheJWG7XqSa7pe5idNiWcwQIY3Akg1uVplNAwzNTYUNSDQntzSEtyWbLbzowizct3b+z3iyjjkxpzrpLcEVsOyU5WnZSFfpWvwcu1tpeRlp0rC133bFBo6NzstDX8krqRCw601V/altpa+jKWmQGkaAhvTdMv2UpTm9jXVfO21L/nYJdRqsd5Xg24KMBI61koofgAVrw+CYvENOn2K5EkymbBmZX7iMpf7PEyluhH8O7CDDE6LKoKHD1oysFI9OYmAXO726oaKgrdgzoZG9PpxJwoMDpL47ahwuBWTKEjdlZsnTrwVTi+8ANOCCTByHYI/w4qJR7AhLVu//upBpdol5hOc/PH2NwLvNSMpaaGQzCatrAEcUfRphO9MrtRmICByqpsQW0h0bBy8fusL9uR9ZBMjunk4JXd5QqEBIJE0tQerPt15nkJIJmnJpmlIbcUYSccGWItJJWuQqEkK3fJZOKKqAkKGTluRfTqoFUijXkeGOyM8MI4sqJMBZcP21a6GlTosMU0ie7hlVU0E9IlgLp8VKgLQazEQedeuA6nAF5G1EWQKCQUx5kiRJkILVaEsnYJ7R3dsVEzq2BeNuGl4+/ssarCS8f9AqQ99NsHPrlZaUCY2EKk/lNJLQW+cRIsGTlSV8k5bBSJQcmW1ZoUpJtDyFILOsQ+RTlWGS7KG1w7mZlqxZlbgo6Gg0TI1RzjEwsbKk+xoC9gFeqC707w9pIOiXAgkKlSO1J85AQdtQ25QUvk207yRYqGDPVf2wQxoH1iq5/zlY7iWOmRuxHfd/rsURpd2X+vD94SJPMvI+v/1bfRgonsT3+fX7wFhbYnYbpIfGxyV+UGOLqBpNwqGKUxhGwaAYjw4ygSk2QEGH/dUYiuekA+skqCvizRWm5SS+Rx7tfh9PwXYLY5z2hlSQXk1PbZnTjQ2stWkDTz1Si73skFutD2qOTWJVIfeXavVakg8ITiQaFuYwBzdPNU1eQawB7+hC6zg1bMyYJRXPRncxfDfbu+35PSKJQtMik/1D2YRYc13SrqSulg7i4H8cJnCT9idRDISt9G8XnQPHZ4kAzBY8OUAVHrPGMmA3amOSZJgtkHm6xOLcUAh9yhSh1eJivQCBw9AxW61RU1rnpOk7uJ0FhyTy7/PK822GDF82aWSvpnvTa1oT2zkkIM53wUSakxurOM7ap0qk9bIbLOJUvZac/OVrd4tTswBie5JTu8/LYhcwqCgWFoQNEWM0htnk/i/5xupgAc3ugHvQH1P7DNbJus+U3nf7hTLnFfHz4pUuYqTKJDApDvJVsskjMXZ6MDy7p0a6kJqwqh1T+ydMK3d7xDi+j5/F9LSYnldzRNe2KBTdFR5BHjUP9MboZs7JyAd0aRYkzVDCsXich0vUIo6zSy5sQ/5FKZ+VPjwREWKOX4prLPAspXC1f6A0zC3oRvmA20TQnkCgTOt2qUtcfE2R5uufj477U+2TZAmoRk8f90KSO/R+MMN1Oetv9XhFbZaJtggdXHdO4cP4AjGjvUeLqvAU8ZkvYJnm3qlKC8ytW0aAsHMhVeqJRcsZpEhBGl4IJ2BjW6kskQm5/iG6MS9Y0R6v88R+Sik/xvZKo+5DPetZu0bJuCd0Ai5lKqawaIRrT/yz5JJGz55NXPskqF7rLSdQ71aL8j193q1qyf+3D6cbgbHufXPFRfEHQ+FOFb3h1B0kl8Ou4tPcobhHDhnD/PxR0MvJyvHdPPHJkCcgU5IYYetmbyHCG65LhoGmMXeiBiwXMXOP6qo8GtgCoHd/Z5+UJoNxqrA2UyCvOOJN8qaWYiPrkfAu6JL2JMfWXXtzbXLPUORwzjg/HyoXNRkMQ7lxl+meanSP4AgJnCqKYY2y8cUnphHeVlGQBy1W428V6UkEtH9J/CESnOqZDNrJNIIjcZKrCLftnDYplyGpFWwWT2FNjoJjYo2hDg9shl4yZBlg6psUH1mZphq+6t4WiUsExPS8SjziwdVCM+3FU82ze/gxAvLHeYvVK+wF9sU5By2ijWTk204bh+a/ZjxbJj6q30Skxniu8+2B0noeMhpV6s3xVNcPq/6b5UhSwNrdpxmMmRXN1I/CWg1iAyyTp5zg/4QUuaLPt64jRs9P6x+9JAfwMVwnk0EVJpD3CzMOgxOkGJtZgs9KvTU1jJ+Mdm2LOB4MKHgW7U93XrxAhiHvpzS+MB3QCBEMGwlw0Tvess++W3kr9LJn3+1nqjyNz1e3zvdZUgI8lAubas2rTdY9xJHQ0EPZwP/Zv36ljKlT8QHWnXrpuObFuVU1ioXape6YiM5OYvZ3lxdv0IDGCOxKhb/xEMyRf6FaoBpHeRhjqdBgICh3TJgxox08le6Bs6RbqRPTSSMmiip9GuUpgIk8Ojd9FLVBaI5LtFP2X3q5w10gqLPSeJVeTlMHxWfh7khXQksnZfYBaVY22k+8v6kC02YLMJPuvK5LYpPv5fN3LxlZu0GMDXvhiN2zp3cOTmomjiFKQhVAP5rAWx7vOIR/WR68baDCqgTI5QLYFeIvz/+iQjffkWK2f6+BSqUUOXM6OIJS+XlO0bh7Rrv5arqeoNmtGvGQ7fYNLuQ/JYe34LeLeIZ0aHEIi1Uipw+0YvdfvQ86Lx7L/vqdGrCtzd8HYAlDGb0QvG0FpfQP9+HSPpsD1Sxul44iNY9SfIjQuAY610vPWgmF2msiqAAskGEhU1UTVjHqlPMmQnxU9CF6lVzVVralW6TYtoWxt/aYWllMCFtGZugdMeNNVyDHu4e7gDpWrbxUz0KM5iZTzCejNMqVQijrCR2BvbxggrwM3GiL9ZjTysFwYegg0XZS4hCsFnudh9q436qTbxVY6+bzVG6ojjhX10mtnrQgrhR7OsV+PnkCekNIfeDAIzYUz5KijHkuavSXGIEdCAaSm9zkAbsSrqDh90wiAVZM7a6Yw1rUVXpVRb46EKaEiHbeonYi65Tpnofrc8QxnpCug5JT53s93eKqLq6vfe5t2UZVFzuzUoRybigQQWBSh89HlOeTzg7jlBkLDnsWeuUhL654sR6HsaUWFONLWVqHWbJH3fUgzeByGNT+AXO/VqkXlSeJNexyrpxWj5zIjILlkrtei341AFs62B9hRNnfdNvXalf8uIXm+f3wAg0yLoV6drg29TW1etBOpg8B43uJiK4mB08h7Tn5n0eoryYuAIKc2ahBhEXDaaTF+gVNQu08B/vL2iRz661/uBe3Y9yOCesgC87LU1Zpe07bJF3QGlzU7iyu/bqXVPPfz+flvX3zd/4AZR6hyt4M/mxQ81REWJFnP2hZV7G4VnBPpjKOu6A8DX3HOAW3BrrjlicW0Qq94HKQFpcEB5iyb59/0eQ8SPxnjn43LFnQUSixpRPYTlXa87YH1yooTwGIMp3yLiI+AshNTkpoUnKeNu2xQIclNEOeMwt68WUClNr+S4jJRcmP+/Qpp/5nC6gnInM8/z46OGFJMJ8Hl85UqLSWEgRtDoaqMT1R1UtSp+3yDuojNzx3s1JLzyPJoSLl4rWO3n9zQqc1WySteZSTBufEC0l3qNjyL7xTqUmzBeCb3t0uBREFATa8FDfTRMYIHZU85zyGqM4Aj9fFh18ii2qEy2gX1lK1hOqMR0sCYpgQQ2MQMUtijxuuh1bJlnKsOS3tV6BoHZYNa81H4sBLh0BDF2iJ6oeEh02mkCiBPXioyqL4ANI3kUo5xXpUDa6DWdQxhfTctceToIoZQyNiDB/RE4nSiaP27IwlxBTSG1GDLkLHQke8BZB31aY62aYWzQaYWVH3WNPvnPhHc23tfkVtstirEX1ib4+0sf1SctIAJ0kUOV8KmXQZcEvptiQqmUwKWAkNruWpKHdaI13Yh/hbGNoi84T8mGACTrJ2QP6EiciOTxpak74fESQpoHO+KITgoOIkF5PPHQnr3oA0dwdyyIK/pTQ7CJAEE5fkfsULvFNkKu8KzUo4IyKaiq2HFJL4mHNEjGsJi3WavuYEs3T1c9HPC0SDleqWlULY0XMkzIPdjPmyoYcrcqVrO1VCiQE3SzMmJZOa4uRMaJdbSAscn+cKrmaAaQ2/LTx0Zp+b678L4Ho7a+3df17e31d/68/AudVCQ5RwVIoB5EN2rwRVSsbwlBbKd5Mvdf/C5YPFxKIJi0wZhTI6WBGXTs6luHxtDu+22FreKkc1IcomVRdDxLEef5uTeY3/WSCUZGrQUzsSixn/3IPeS10Mv6qsVarYRUBUevxc6r0xzWoprbpkX8l8uYWRh4KLCgxsZREMXrU4nF0vbsUDEcU9URBABFWHSMlWKNacybUSDTbrCYwICcDOc63RrL46hORIVlqyg0pHxcpwn1j1s8xmCJrAPJSIVhwPXwNRYnkKadCrUkc72llnLCvN7aHCWkfXIfSt6uIJdVkqMlPqyyowkUOknZeWhlMO2CH9L6GcRgc0w9BwCPkz2weRjRdmNBp+JCE3qX+cKeaEs3m/tz5Sw3nNSklcOWvg150dUfbT2/ic2wjLqexPzfIauCBwjk5LcBC8lipazigcr29pEtORdy8im3Hi/20xAAAgAElEQVTr5XNkDmuFcJGEQydBCrsGd6RcbSEXLLdDhyv4kJcriZaAzLODqmfhqdtjSzQm6+I7dDgdUrjI4Gi49wdPsiehZN4i/GCj0KtdAM8SOoIu5P1N0fC75DJxM1ExvNYBoS5K7xbrHX8rW4C0FmsN78S55ey/zUFedOlXx8mh0PPZr5OOyGY5E9rAcDoaChYdZsULOWQ2VKvFCQjGL64Y22OnWj+GuJezP8mkzDakapHNbGYyyiUmiOcYWtKaUXWUkFbkq7K0SmqFGcrA+QUdysGK/JxxgXzSx25Kjs21d2RrjaJnwKYPJAUgw7cEhh0V4Hv7vHz5F//ueNOs+37zEETe3LuQB7kNtrPteGGKB6PXWhZjp3+LFG1BMnK9AeJESqpa6xX1UXtA69rM+BQXapMeUbVoLgpo6tqSd3sL7fezyK0rMDTUTaweikHg60Dhmiyd+K3OouOISLUw2ON5jqFapS7REEJ51BS9Zyn9DVHOgIJzAJ7d17ftLOSZGqmMgPMwBUCJ/t4kBGKPlXrm0ikP6fiEksVXVvM8l1eImNH0f7Fw6rLtb+nkw/MGPY59bMn1i4lvrVULE9SMaUhxYfODU+MJwTffTZf9JaYCWeH45is8SpMCLhSErqsfwRkMNa7WIKMECFr3rKcReRxYmYrn5U2se1G1zMiSPpKfS7gFTNM9LydFVBUXDuTg6G3xOcQlzMabDf8snku/S+dawRYnrUm5jqxWyzDpFwKpyxB+hb0iGX2OeIWUdomeW2wjntnXmtwtbRnChJ5rJpVGkr3gXhNNaGdSQt0RPsFFuo3PNI0FGbHnuYsmEMRGsKxTqiLmty/1Fmd2vpXjhtx3PAA+bUiik7ihLT9z81xC92ktCRHrflXNjCLb5JN9fuO0Tgaqp8o4v8+hR6j+qJtY0VXsnz0eYMWQOZMXoQmJ47QGC7cpck3/iehVjRfW5XzodnxLC7RskQTGV3TP1lI2r6xC40UpJ6u5fopKPSMN6j7YtrlF39fuYJ2h9ps8K9imjNLAlWxWgaI8G2yJGxFp7QWud3DdV5zodOoCNso3033BeUhTpJU7nsAvUp9texXiDPF5bE0UirGG8NKErk2Db8Odtc4lIfYZndIoUi41aOXZRpEZ7fZ4pVzVDbQUx8W38AozFbQgYYTz3Pbbowx695+XP/Dr7k1T8dWv/XLkh/Xhm/ttXB9+emvib0CKECmkgZ9FdeXQjZ2dlfCARa/81PRfaE0X9hLddR9wjVp5YVOvrXon1tD0H0KcY/G9FsLPkuzItQ8Ai41XDo+M7pLYJs94XM1GscnWSioGL7HnBz0sjfkgzZmm4BLWjp5+8CwXQo8xQIg4L8YbSYiWGErPycI0Zt8mLPU9vulcRaGvj945X8PF4KXqnKwLyaFua7QSJxdnBW3+NJrnosEdyivVlH8M5PCcbmx8emegOXJhsoDMOEnF0UTjFonLAIF2rR2JGbae37GD6ELalpqmEz8nMG4ASZRWRbdnrbcNWIl8TrhumQEmtv/z/y7N52J+FY+2AOjmEg4iR0XymiglDFg5ZIqW9pWz3D3fjzoYM8KDv0HIP14pQfD8o1YSiBmCokMhmHsDmnXq/cyxWNPIWvQYeL743mYl0hIkmmP0JTioOFAZYYHsPOOkJqnIkStqLhypfIemC5jK8UnsafhrWh4hDiqbi0tYu64v6MXhJGxcRAbPQGIk9svRK09ZVPLH+HwMQypN2V9ZF5pTzdA0ksgD93oBpQGC/cXLvxxDTyTB1SuOKTGMNQmLHCqNxWj5p/QBRNvQy4A7lpFkPDYK/Bbdj58VxdR2tpPbEfgPpPPsgX698/L9DcK0fw8lrJ+NTQrIkj4fGmllD6bWXMwB4OAtKkuGB2keY17KA9i9GYiDoirGIPSMrxi26MAZ8u8Joluex3IhJAxJcVdoz+2v8f5LClSu0EHvLatYN4/TSVs65aijsDG3tCXQq1RObqx5YNWaDZATR0mvweWN3IEfL5+1MkZx8H7CXsfbetvxgXDc9/F5+Vf++X/1vX35t/o83jT5qTv+06/8sQ++9KUvxvd9/new3OoXtgwZvcsywldSLDfcBOB0ihaF8F3hVTdW2cI451YsbVgMQC6Jh+jiQVQUEFIZgGJ4ebzDIRUXlKV+JSuPXE2BVWw8aWfoJJZnAgvv58Uv9fd1Bi5Bh0EdX8CMZUFutW1VdzpJliCmRQGGNqm9xe6nx1mha+OCQFX63l83AHHYQ6QfTEzvmKUfm7+n6DN/1zedIB2H7fkdI6QRBxisilQ/r3JSwYBV0QT/aS0nTUGydXBTQXMQz4MeJgkYMS30ZNuT4POuPSnFh7eMFHmKFF/V5uoGlUEM/2LCCQkOjlfTOzWFu0PoOjInwvEKbBcfyIwCBq3t6K9GBR295ph3L6rUvpL1yqUJawfjofzvFU5PWpKY8epe9vbUuGH4DBK9Ss/T752S9T66CaYjV4aq8n479ytaHTw5YOPUft+W6kz5XarWtfQ81vcFqKNaxOib9UvZvURYYen9F/oLXq+tY9217rQV/N4yPL3xKmHRGyj9rQEC9o9AfofbcR8Pd0j5Ts04dXfBxVaywSk68JtFGZJNP+DAuY4mhs+Mecm7wMntSTxZVkqmEzdcpRlvVsw7t5qbBqj5XldTJRupXhD65P4Qd8IUISZgQKIx3Lrm6S1l9x73U1xRz0rjSWIqY1pmLxwqN1hOKh0xgv1FhadpQsqcYil5oA6ELiY9DitwWzIGKOtUEA120Dk1pIBD3ZxEqfAHTFzK6IwWZEoE29D+SHu2A47wkHFdCFF1GFSp3neB1bW9TOqYjfYK0vsBvyivPXQjOOBe63qPwEi8/Dt/7t96f9/+rT59xScffRzf9ZO/8PbHf+fvgVl6l98XcMA7Z4nzCGoTByW8NWJP874dGbZOREO6GxoTZOBVnj6ZsZYHMltNYEulUpuZJaylSZ9zYzEz7WQR1/QdawkfkeaJxqKC2v542lFMSE3EizzVx53Q3llqGibVnQcOIZI8Yg9HHbacxNRNSlYU29VoVKf6+L9XKLaR3p0yiyfgzLEAxDHoERyjDYIAjVgOFk0yI9XrUaqnKoejgT7f4y8123EfcuhxNtXv2d9oYQExxYDjqASrXUtKIzEFIXmkkBeAvyB4l0bItyD9GXwlaXVfNyF/H1CHqqkjKSdGdwa1aJJJViiVcl4sEEcxROo8MrHaCmBKgdJsie0BJiSf91J9vAsxq1+hKYJXzjQm2TA1lCU6nWmwiqeV1uHwAcQJgYf2BIWXm6NHLwbCDv8DJJGalV5Gwm94h6QoQcLEKa1lU3tozlRqf09rS0eDrgjb+XGmSQ3QpBU/WDwo61tb/mvn22Lt8iw5pjlj5uNUnLTWCRm1SrvFQdSZ5mPUNbVOE3YZSmEKGvVI6vmuBLexqzMWTqISH0SlQ+BO+2rXHJfWwzW5qxmeQsV0SB8V8ZEvh13p3B0G3CgCF5IG63JhF66x3NNCZbUEnUJUWhyAOaRrVa8gbqzMQesWmpXEyXO1Nq80uI1BIGFak/pIA3zgq23ZOkTFxx1K6KWm6mSmVMcr9m6Sn2Qch7zuoOlKtE1HGoK4Hlaiei5nKQZVeoVHWLonj/dCDUfHZNPL0i+sumWNEOIaPmvjAg7aWoL70FoPdgUO2XXrbF390cd4j1/72v+/4//bfV7+ws//N+/+W7/N5xtfexu/8ae+L/7+3/H5uL6RER9CMuEqY56DFoQqPaaBhd4YOZ8a5VATPuefjI1agavNM0375/PrVWF7X4RYr2zrMWRQEmtfps4mmKASYZb644q6tUhW0MmlKbbGharyeqV6t/v31KAjmiTnjE+La2iDnM5X7ZJgu0coMLvwxjxCoDtR8GfRE7ThFI8MzXDB1xYzWBOiSJlVZZYpNVtWSOwzuhI3kS4nXWx4ims2x1/Ox+UCNDAPtYPuzbvkg0/53YNfJMHaCeQMyuPfdSqxnNv3lZ77gWKo9IuNsO24KIfBI+ToDKezZnig1aE1BLN6xkDt+t1PIziTvG8CcPaDt8DmHsedIEkpu0mUBEQRViVCTwDs3vxc0bVD1IDj2p4/vfkC5HMihJA0JEPjCohFsVTqVU0BqmTXBoRo2t8HyqJnVIcdLG5b7nlmzYQj6aKCFmcmMJnm4jCF6uh5GeImntrHPTMKC1FR78tI9lEaauYhpOArkgd1bCyvuOuUazpBxvsoGbZFSy4mwT2EZRcoHINgpwwpltYSKTpd6mRxzyv9FlqllCGPRASuOxLFeBUvNMLivCZ6lv+KwSichk2GLqonazPXMJVOq7QPeDCqTaD+mnU0lNEoh/Dz2UU8JflkhQGBDHoJshthyr8EMTibdKlIC08Th/gYpu4SUpbZlts0anW7ickL1x4LeTVR/hHFBZ6BQuKhWu+DhRugMS6KGQf+2SIUVqleDKUhpIJXG+DnvXK2MdoEKvyOG6UZk6Wlg2VoK1wjsCBf5FOukFB4CHIKaGM/v/3lzrg+DOp1/sAPdHzl5yI+9z5ce7/7i7+e3jQdbz56ie/5v16if+Rt92/ZKf211HshoF6U9HreTJk4GcYHtwD5Akcipz3djjzbrQx120YxRJdXcH/F2Gf26UWwP1JwlT6lYRfwoRQut3R9UIszWm3+LXoDQY2LbAO7njE5YVU4lHb5+YHwapueFJPQ+A13GU1D64A+wx7VTdI0bmEv/rRueGhyXkPGks+anTSDo4YAR/kwkiE4pXkQyvxs89bD11tOlhB+c2rtdfS7lfi1UdCUAHN7uMe0dk78pAr6FOeG45aq+0vv1yTD0FAjF5TGQ0v+Qys0tBMoWpQuhSWeld7KKGP7fCcX4YHXixgrDlpCfWHBuDaDqHJQKFVqizAKb6Ukgw+mpPdrYISQJGRIsQ9ZAsfjPbbLikp1v07lkJyNnI1WswuNHeHWFWvgZnLF54c7FrRMFeBckPDZ7NdutiCplo/10DMwHTm8Q70+TjemLBObmUelzAJx7FTOs9FeBqGLULxtRkVX0IZb0wMZiCino4GReFEDXmVv2oV6iCHU0KZ1cr9lxdlzJpjuMuxGyfCBl8Zl87gtbrHD3XQ+Wq7Irj0bRKhADgUGONypZZYQaSjPz4+BiFuXUCgfNA0gJEqcw+nZyWAOyWycrF3kHXCGUp4pXAbcsMPYYipVICdsBYL9l649VZri2COW8QbJXynlnqKT57zR2X9iGqZ9PY21bI7olCp4sa39g2TmfoTm6ki6wxpQqfiRRCXxxxAeLvgjxepBw0AkXBq/1uCOhzPB/aBXVPkXsijlEYf8iRaIB7p/XD85/TNeMwkJ1x5BQa5U1p3mkF27rVtFq7OvfhzxPd9bH/yLf2TFx7/wuNS8+8GXl/V/vge85Vf5PGqybz664+/93b8zvvfDOz5eK76rCnOwz1Z8BhgwDlnQf8jpz86JALXsPQpjDypz66XtELacDR/ycndN2jcoJS9v4eY8gLQr8gg4DDsLyQX+/JqWQJ9hb5GkmFuNsuSqHa7O8sZIedglSXERQSA9/ikYe+J/KOx0aF7gwOBBuSkx/nNimLrtkPxdyIwLpEnafziebIOafZMXK8XZJCWkPw/+KjIk05ugt2wmX2HHT+ntmPlwlIstzZSEAI/iSRkloY4A4NghwIszyuKQmID67LWrpQ9tYBPhuBmnWSWD5Cwd9XJOhRHiFAm/Oa69DvXWcs9WpXZaKyBDpJUmyZr59tBswgR8HnbmsfHlpUv7pb4yTXbiqIDnXIW/H1pBQXNFV5yp48h+JvtnyhV5c3JsKL3PIXU1hxrZbUFtKg3SOZI1VyjdQqEJ0+XBqSD4/1TuG0IfPBOYz3p0W22NbSoZcwC97uwxfhjKOJAqj+JoDLw8axwaywoySCaEPb2DlGUUbY0UMo6SJp3CVy7phDZzMCMcDAIpQubQStwl1shESh9QiFKqq7hnD6etuoW99gJfFCbnS7lDdqDouU0gAidThdHel9fB19U8MAn2epFzw7zZo+d63t4JlxgbYIrS0ztIv2IJqXNwf5+AT9wskMgrGEOxg0hrfRUf2Df3fNV9JietGeFg1bEoEw+jh3I7RE3VrOUxonJJphT0gblvM4LaSa5WPzWZ29csWmLp9XO4YMasiPaiXFhtkmzEJPgcDN6LGCYY8iqr4cYGjaE4YT0Jjlb0iln/WCZ7bcPB2mdUCR3tuOupxz/8MOPtN/Ltv/vvVfz0X4349Oc/+DXlAt/q83L/ugIjteH///p//qvxk3/we/oP/ugPRnwCkxHYWCV4FPtfrmg1KHietfrC9vfYw9FidaQqNE+pK8BTnnep1Loeclb0vQiTE+5LyiLtjHIN2U19eXkQILqegPdqxQrUGZlSBFqpqYx0QU6cgbWmCKv4VEr5K0wqM/KqHkmYo8I4xppnaX5F5ynjmwPSkrTh9j1vpixDeHsa/Ave/atMxwEHgmkdLEzhO0a/priMT2MuqTJzdl7mIC4OdfjbOv1JoKRnunmyFmtSUKFnPqiHQPCLLi6uwHnV++aWRl9IlncEBeb/vKprdAh2psEBI5y9ie1O/0pQNUAYKU80iBTYDyAAKLwOAt6Wgb/Po3pLwHCK1aSW/Qf0P3vUfzZCsdh9mbYHfuiqgDuBePpcEvt2FyUVZ6zThA61esz7aJv9LBEb1YEgFTFVK4t1n8ttrBNgpKcNNts2cUpWvMGBRr0xweZ0vpSMCocTUjCKSnYNKXBpzSziyaKd/ds9fmiH/xyOsLXglfCQXBafK6bM26jJo2b7TG7d6m6lcwQkb2uGqfS72SDAujMZGFl1MELwPJ6EvKwzLS9IuPrs/VNHOxQ7tFBFFCdHdj7kE38EhdgcM4KI+EhERKhCUSVWqaS5sgxvZQFaVgUx4a4tfMedmIxZFsHDllhlIn1rhhFqfAQyWEJRBVCE2oJSSomJEvIW3wotS08+z0RoP6cPdpfCEK14UvuxXlo/9/ZGx/ACvYzS2f7Da7Jkm1R0g7XaGs2Onaru9aNS1eaMIrjnMVbLwHhN0gtpJa1fBcaUdzObRMkvVE6h/HehrK4UQ0vbj/WqdCXF6y4UZAS8ocKSWXJ604c39/zom01SfLCDuwteJPWpDzPut/n2v/gLGV/86ZCu6Dv9vPy1n/u5d/6l3+6znlHln474oS992J/+9IfxyccYY6Ypw7Vzvq1Tt2hQJE6xqM/7WS7BnOOaWW3ycIWkXeoIYE7gZehC8btQ17yHR7CEqRl55ZaSETY8XKRjoZIOs7VbEYWuCDsAXNrwQ541/rZIqyAHVfHc/uI4W3B25vwAw3Ut9nAKI/Ec55TBMS0g9l+SsZ0UExA2lry9QmrMehT0/7v3sKkJqA7BRabmWvB61IEdmjCijI5kOUhELGoEmA1IWYIGGYgiXdlrYr3UD0f8rkAsWn1g5Jx7YirG0RsMUanRO2hLnm0QgVE5BMRNNofnMEHmLNqkjF4ZAW2Ikhu0xs20dcENkW5Ag0Q+8oGTrS4n2MrVZBavLFmN6pxxao2XpJXSTjTlKZ7XBrPXYA6vq31GXGZBiMpPZnazB7bWRQNK5dfiLUhpeMQ8PWa231wuyddR57tJ6DQU40mOFpF6L88bi3ir5+wmzMIDaPGOTC/uFlwgKCDL0xBiTCudAEXLKtwak3JuKzKflTqvR4MIJ4C8s0TqCU1Et/8WV9Z1DPmAVyZZAPOyUzIhO+vdf+/y1sJcCaCPzYp8RhfKouhLaYeUaZzgU3bMgjl7Ld4SEO5x7G71LfYEFjO3lZKQy1WX/AMiSFUTlKcUNaxREwekR1T6xnRUcjDJQzoa7dBufiWYczSYpL9wgBR70ISpJd2rUYpe6cFJzZQrvsHUAqAlmqtqd5a06gg4S9sJD21PyKxNXwJadFMUeYkwrb9qP48IjQrrpYOOjk240nQgD75AkXX10TlKYspJ6FWwuOaIOuZ3l3qFFLCQyB9dMiwNLqE2Yf1ioGXdodG7XCwy9BKb7JfnxuuRAlPjHi20umJ9/lOfxBefLs31Hto0P/SDv+Wdf+m3+zwL9uOPPorPfOoz15tP7sh6WVvybI+vbSyx9gBuu3sV6luji8K0vlEt6Fk2BWr2YtRgwu66pXoU4gzu9ck+LPALj1roRIbYMRVAGdS2WBSS0j27+UCxl/1/m7qCaBnkaQ4vkQcG1St0xdo5QQP7hXqX1CfRWUVxQSdSEREoj2x0tFaDELCAuJTgxNMqLeP/V/HMG2JsUN2L3S0KVu/TgNaAi8OjlUqy8dvAoNkeHR1yxJVMOn6GN9CEnqV6KtQnYvRQ6G0iooiQIBjA78138Yn4LBanhLEOoWcb00BaG1E3d+IGVmLM4U6s3NL8UOATh9JFccvGcz/I1HpK+UsHW4sTc4QqsJdGTMY+7Up6u1UCanVmTIYkg459zOGxZYF+hpqRMYezJZSXSIi9YWYA8mk8c9hEqRgSYmj8p9k6KOHNRcLNPgCXg3gJoxMILOkRMYlQGGLSkZlbQdAcoF9l+HmQOLNMzcKAJjYLtfGR7xdaC7WZoNgMbIsuvPQm3SWDPQyJ6urMy62F/jyfW+Kq6Liw+ZeadaLsiApe4ktH/AFjq4dTEnsC0O+HD5UF0PPsKBhqrqbYF6RLUPvNE0BoFZOqPU3ZdizZh2RtleUtYsVX+AzmI+1jv6i1uTRhwjSjDUyFbBg5EqsIx9Uknq8Ujgn+ur8giUVaN+7buUj8EsdBZeBSfH6t+M8yTDuwrDK89ytdutiHwODzE/BunQ3HOOxRMEmoXb9Bf7KYHEEnp+QjNf5lWaiDZTiy61n6pEGCiP18yvdSbOXR2VnSG3NGGmL07RRbgg1y/TDXBrNdOn+AAm0FltCVoTxot14F04YasEpan5YinbFEWV4UxuR4XI32lUMVdvFqCo7y5+kYxXYhtmN+7jORn/9sfPYLn5kJyXf0efmj/9wff7ff+B0+tT6IDz+b8Rff/Kn80i/+Ynzv534rUY5n1qo8oQTxRhB55AAtSnWrBkVJytnSoNrw2ZilOnJIqIzjtxFuPzPWSTNTRnMbSV/hWnk0JIQnJutuT9oy8Iw/vciC996yy3S+NBkEC20p8JVNRI2b77u4gyy/Dvu94ysfipEZuen+YC7IIuMQaHIBxj9+UYAVGQBSgy2GVIO+iyyVAt9Ts0ApWQbk8C1XmmsIYDTHQV+pTSvTYJNVFILWqU0HPhLAcEI3VeH116vVsjH8q77CpsTXgynydEDGhAq9+SOL5TFJD3sJkKiqrckGfy9FKCFIHH3Lic5NtX7lEZQ6QexjgsLf776Id2+SYrnj/d2WtGaXm5ZHoTopZcQUgtfUW1tMEQVmCy8xueXRMPKcAeZ+VZ3t04dupOH1s5/RvWkPdx4kIDa5hFhp4mvGw5reuiIuYiG2oBDsP2LNfXB1Q0h5+vC12VuQftOWktnHRAouoMqGOdaaSGL88PcvqR2KIoLOSHrIucYTlVne7mdiwJPZhw9Fp6HQsvEtHKf/FiUl+2kJMcsDpQuqz3XECKqbrLyI6PD8A7NGGg+c2mNviYcdNRCd/5Z4qV1ihgtPScfSTWxweyFlyxCpiRpa7adNQ4/cAi/SVNkliTklERZ/YfdgIL6akWbFgQUs7OI8FVBxJMXdFk5VKNCEOyLiEv8HeC7y0YJ/sNlTuUgyVPcey5Lc2KYQGe/AYE3OEHqbWiiqfAO4Uq4KTBrSsyDlcHZWe2gR3n6yYSXJopeaac2WKbPo/ec3ta5F/Ch5YiyEcCZNT/Fl9FEsZAT6k2WrEmf7j+1dABm8Y17ozr4L2OfC67yvj778cf7m3/25/mf/5D8af/5P/4/xwZP2fPBufXZf/tbf/pvv9Au/0+eKD+NX3nwtvvqFr9y/4Xd+/36jPKJhYeWDM5XRe/ZMzkjK2P1GGS6cATC25jjAW/Zf1I0SLT631YsY1EXVMbmiAPZKSSRxNWrcRMeMviqtNGHJ5AiRIZ9pfnaHuZ00p4Myv0K6r824HRJ+aqKbmjjOLZOsrcqo4Jk10iUn6wo9AWm0pPOD1gTD7oIW20wttcLgWRB0wYcfX6ifouCJepsxUkS8nI7nGq8bnLTcyLv8bmEPDzRO72oph+vikgfN0zhpjuRI41nn7nN8X7X1o3f2V2irgxGt56s+uSpUXb+7AOj4oMJJsSTdV8hzdbcw1G5J4EtdlUyem5sfsiDtRpkkpHQwehohHd01oj7OIc/+EJRBU0RlUge9wfOLnBvskMIrHRN0lHhcU4lgamRFYJl3YWjayK1HGfqU1OVwYl8hhWvZ++MjWZ9d5Q51HFFXgR/W+Ez/ZJIDWI2V78s0BqJFPE+Q+XRGqhfrfSXmSZhqETrIenpfZjcjzSY5guC89DukdXegDTbnSzTF5MmAF2JRUyCIbuauJbkbJzYOLJb1Ser8c3Yq+PxFQZHThcfJcFYSYVp6ikmu1f7lkItWlORXscxnM0LLi6Z7RCDd2pLNozdNDvK59oUXYFEbFoZKew5/xIkY8By/WXljNDBraT9y6dxWK7EzHq8oWhoDatgqaA9TmyuGT1Gvf+io/EdROEBziaEmolR4JJbsP1fiSbxhgYjhX0iKt4uIGalSACFYCnMLNYAX2+blo4CTtgdthMceW81MpKjZZzINvRigw4r2tpucXn6dVMylmz3zZeZCJGLdK37lzUt/UKv/8O/9y/GFH//f4hvf+CBePngVD3/Nn5fPfvaz7/QLv9Mn10v8hu/5bHz5U59db96+eSIMz9gCba37bWLwETR2MfTKyjnLRaaZGHSV34ccWJqOAapX6RrGaM/RLdDuNnpfzyAZGqbZcstVlYWWNI0X2mo/G0O8sUM5RlX3U+mwSn2MqRbr35q+oRCBp7bmlqy2qPrwLsXE8N8vOB1xiTbzfs4gkukW95IAbW8WKnzzEOOM+ot5SdoAACAASURBVGlyI5WoPR2NpkMm9LN3PlRNp9WixNkurde+Cggkk6PrkyEMLKA8dRNFwuvdt9TvPbVT3E1NK7/08wtpyRSpeUj0FxV5Uelv7ZL9erA7aU/0cJBUwe0xwfYp02ikoctBFf0CZLRao5MPsA6+2e4JFhKOhcFDaFXUWNTs/2vJHgwdj+dvsLjeJ0m1rM1btrMLHdlH7nIJPrmZHmyaGgbGsyQs/oD+SQpQa+4zSNps0jzR7NvXz/wt6eek95MJa4OmvSeUl7pg2bw0pLH3EwkPZSSeSVyttFML3ahDLAkq3nBwfEu9FoHovvf+EwOr7SDPzEdtPWonk5VVRTimaeHRlesCn3Pwxj3o6PbAsyqW1CFSB1aYaNbyrtqy7THj5c1uZi0ddHzCe9u+5ZqS+zvPCqrJEbG98EuXOQPEZRbQ/BytJKzH2m/rsUTahI+L6fTdfP4FcArdVD7/0vBVycaT/uEbWwRR9UYSlhpK6pWSqYEZsqQc6Z4B4ZTkPS22XvdeFteClY+ovZrbbpJkyjAgOor7MV0pxubq5cqklthepf7FLhWpqEwok1yQY9BbXfWSYMG+jWuvX6BS84h3HcC6ERdokdsuVh9BRjDQIq6+4iMhpxqVwbV2fHV6T5WEHf8Jl9Hyhv0b9Pd3JrCThyc+p+CIKtHuc6+XVdtcodRh3Nc3Og8hbPlm2nGlzzpXbstaDBdH4duIHPp7muwqle17Le3u3MOZGWQLC/dpjP6GL3wqfvmLn7z5o//0X4mf/Wtfjs98t2R432Ey8r/8lf/pnX7hd/pc8UF89aNfjusnvlg/8KM/zEElzm7e0TomRdnx/Ka4GyIjtqTpjFIUrQqGBZWcA2Aei95XRZ1o3JHSrDX4XauDQymLXEclU1I1MQcdtdyRbbeaCLgh6H703IFibA8xDGq0O70+AdeDJgYyYk8uYnBNSERTb5W9BmE3AIUXK45LbMmGLBPHex9TL0hcFPsvi9MGF5/FonGF8zv5HwNLcgGQ6nK61COAI84aW0kMZUsJ52LlQQs/c9xyTKy6aM8DchwCKg91XzvNLRYn8GsaMmLpoCgvtdv2jTY5QftYAEzPVKP2MP4zffXsb9MnzQjED+Ym8JVNO+11hqxxyGzs6ZqYOv0glSpUDNGAcmvyWrS2IIQo7YtBaGShxIcsiqCeKBAIwIYWagViok474O5ajNjMKVKcp7aCtmbBdQjSlHEnCcBXVrdcE9gpUV1aBSU3D7Ggn48aVFaVSX8dUZqWpsZYZciELoV2UBQ91X71QEQsjyMBGK+ZIIP+LxMYHfPXzsJaEjkQWhTCJfU76sHMNBDzHkAbq9VTFTUCPRHe0JKDXHB/PmknM4PU+9UwDNKvTcsiejAq6qyZbGnj/kJL818o6WLh0uhw6+9vM98tLN3hxNZ+paRYsIShY0HLHyHakzc5LsccUG/1nmx3aFRFfG9pA6195nWNq7ZmuemAzu5iEh5nqeaOPLR+LFbGUilaeu/PAXyt5f3jJvqSONLaatX7mUjdY9+0/XIZ8Vi6HLKw8vwocPqkUBhSXJZHsxBcAhNsWM83CUHi7+FBikz9uf7afHrkrMSTW5k7whnkujsIyW5/tDam170OeT16je43VRTTu9FAW6A9AHR5wfH54bXivq/4b//Xz8cv/MwjNPLhO88NXv7QT/2D7/xLv93nWh9EfdjxF+NP9UcffxQffva7GB/3m3u7f4SIf4ElxvN814vQ0NCMd5+eowSVDzCOEb+AP25us0TbMfdpMsT+GyhhQzWGMiHu7ORSC7JMSdliXExBo+th2LVrLOjJbH720z94dt26lPK0hl92UFsLbRTqz0gTrZYItntYbj10FnMmeRgAmb01SwTq6BLoXWRAQfpsJ/OcU1NKxYmUGkUtJVyogcBNv1MMsNj5+3N1N4RfCUvgukuTRFBsfoq9woTL5kFCqR9TkFTrOXXeNxVsV5Q1DEGydnOS8XkE+1Da3DYyYK4Dgx4TtNjPPxngxbnHmBEAnu3c1VdcEr3nUELtBt5+/pJDEudUXAmomZV48PrlHmMppHKtxldpjmexcbAbze4uktZTC2XWbrAx3V17PatxJuUi7wUeegQkmMxQnUL9PIlUkR2zxL5V/+Ri47E5kVrkw84wbBOTB2XlOuYSuN/IEscCLVKEbvTw6tpkVgtZWYe1L/A5RSlqwTQ52m+NZpVGnphRNBl9SDQuL6fWAOtecDeb8NI/Q31Z4PgGmgWTNZtcDqX65FO9F2cyPdOgGWj5YxNhhcF4ynIFzp1ylXah0RwE3SxeMXIJflD8EXhx1nN9SU24nH0vu64kf43DHyK4tGsGlkt7yJTiQYsjwxycNSOJHKmi70ATYeYI4TaDTmYAyBCRYWeZjsCXy0Zta84evN9DYWehH7Ef+U2Fp2J4eroHi/ZEqUGiQ54HbzRUAXEuxuYXpIs/ch/k3pzrN8btiWPkeRfTX5d5C8N4wDWpgDTrI1IWpug8L6IcJbusDrmRht71wv5KTQapIbW5JSIFAJeAyU7k1KqAaSinyfylEsIzGxKCH3AeZbx18FphJR6RUTaupM6FcuqWkCYV2ZqodMHifqum9Be+0PELPxPx+fehwPpn/vv/5N1/66/22c/wiq9/+aP4vp/6YvzE7/uRHe63IiVg5g8w9N+YsNEzJ5KaKbPc50jYyyPd/QxNZxdtiJi8z8CF8nDM/Eot031Tcd93XQP7bPEwMZJDhlQp0ssRnaxtupIzB8b8cSNb9ZwmVhoh/JhEak3fHGrXaxcKLTpZqxvFETkEJk9RyADBrpjP9RcNfZJWvynKNM9mKSBgJ8BWHRdqzdSNAwYpoOpYcm7SozgtyU8xKo7itTULDRCeXU2B6GvzxXlqcKC1NM+AAoDDSuNzyxZHY9xYit0NUHXnbivvtKe5lFiWaPkKM5BU5Og1OsYXaYbPjr0jdV6rpIM2E6J9NzDNZCfbig+sOdAFN9bdJBl4dCnu1Cg0Mh2x2IgBNCwqokwZWfJkwzq52bTMgwEEEz6OE1JWDa2xGsa8wBolLjYvFbUPaNiq6Y97YJwtmCB3OSlAzKHLliMC6dPYlNpvIZoWprQXdgvsLoWP6GCJOVjUwZHKDYnqApIoqa4xLrQZH4ABudJmoSyNcwowxZOl9gxt/njItcK8ciKFj+AONrwCjn3OQ3kWVAoOa1a9dZqfjTjLk2dVjead5FjCCJdrsGwxQUQ+7hBdtNE041XgK5Ce9422AqEzkioKUkn775fGaDg5cST+EGzipLuNSzOGn23SRZJpoD9vjaBQbxqi//dgdCH6Lqu3EgyAq0POGqKCrCw/sMOJRS5CYpkKPc+UbQ9GrbjGQuYBQQ6Oor2AGx0fYuvJGsCJo6X8QoKKTE+Hp8WmPhtJecsbPVg4UZugnpJOcLmpz6Gd4+Wz+ZOLAJFsQGtbflOeRuXZIuEr4amemySww3GbruvZdhHLg5ONoUOpDNbuN3otVP93XIwda5+4ypffz+flv/vb/+X7T0L06Y5f+drb+ME/9Jvjh37481kfReSHUCe3gT8H2SWQBPyS1i5S5gzqFEG7DB4ljDZPLwJZA6zcFuqV3nNYLSHE7ZT1/KaLbTjuhozDQuzZsBebjIN+B6X8QSSp1eKFa4oLNkMXx084qqPsRAkB+B+jgxaifqpvkdfeb6B708AL3EpUMPVUG5VQGkQGXdRNsMl+q50RIrpe6OKo1AEA2worDDGrJA1dXUv9hqSr7HMu1khcELRYZnmj4nzMhp6nt2UrJKiwA+faY4h7SuZBHBfA9CWpoFYxclHCYo3awX6rG5C899Za4wRAmLRdODGKsBgmHtHQRaQTChkVp9Zn1PE4cPZpwcWSbr261aOYhOCNw5vHMLRQ9v1hlxdoh6QjAGZnF1kVrsmhYRHTIky/oDQD6Vf24BHglimagxM4KdLl3PDWXZpCYDgC3rPljSLXxZ3VGheC7IIJb3TYDaUGfBS4A2kQurNm4VRmYsli2pkBrA6XR2bZAwDASeO39J8rsg8YRc6RW7Vk5y1OF/v94/IgpOGnjY+emaZElgftiY439p+F3qRDREEdoppPlz2Zy++z/QYDAPtTcqRNee+g3u/OPK9WX5IpOHhbmuIDL1Ys/fb9pNKMIol9ZV3gPZL2hv1LCUlEHxkkq28dtkNfm/sdoZHy2CgBwjCO7wVGuCq9FUY3u9mlSJgRk9BWg44yOcmUQqAygFJt5DY02j+PVexzt9cVkj1xCq3ueIjmskRB7SCXYz/EYuZ+N0mYO+kkB0RDUQU8wt24BYlYBNGr8yUxBk6ALptKklpc0sGsluWxGOfq3dXSbCK+FmAm1VjF2WDLFYmzjwGkZ6tFsHXx3DUboLD+xEEAq/8sTtpPGw4PYsUwVYVwb0iHYQN0GBguQsGrafx4d677oKW/+7Tk5R/+ifeZ67z+PA/ma79U8Yf/qa/F33r76fzFn434zT8Qcb3kFkdENsd5NDKQivqCKflK1IcgXLdIVGyREfYHLXrN2H6pMmex2fKDDk9qsKmGhrAoUyrOsKTJPEBBZj+HEOfcgyXPf7jWIsU1NLogFcqeUDmyHXZ5TMkzhBYBe7jWad1XdYElJ8dQ8fBD46cF1M1TeATr1tQEQd4KIW0RMbEsyzMcIRgpfBQkbWTbIkVpSmNwiV8sHtDbH/hqy3g8P3+vPTyjYlUVeHMcQ1BjcNieL0iUipDOSGtQhjkibxZebnjwLPY4ugHe6ZMvLdJWIDktDVixTXmuhx/567tPEUPcEmRPi7/vIhcff/UK6Yqo6FX4FjMCHgXNmGd1t6VxY6n8Kk26NNEKM7tUuqTmQkohUhV2Y/Ue9iWS6lBXO0K+0c8TuT0rSmd9a/4Hiy9RptgyyOP5y/9cjydlNDpTP4vzXk80XUT95SqJTPjQqUhYDaw5iL0edAVN5VMwQbVYZmC5NSeBF3pM2W3LAxrDaCifKMYiAYETc9TSgoYuFQOfFXtVhlc50ri6U8GAeh+trAc7ZOIPl8KI71tzUyQdYZOtvBUSXVYBwEYYyaSHZsnJdGZ2FPHZCoWpUTlvFjWceFBjfeaiFxPl7iSeZSJ+u0eorkKIB8r4rNvZSYUGUDkwIwvH9FQpxeoY8ZYcqtWS4QnOX3MhlmUPM3lKe0O9Xp2YwDb+jfhN6nqIEoUzRJwqotXm0m+F5RBtq0K6j5espqGr2mj/VplQYtAG1DJhKOKUOjIsN20wOLDUBoRPTFPgL4Wyszfqm+xpSO/u1LJKrWg0g4/1TClygynCMZbtVtDut15YPk/h+PbetrZnZHynn5ef+YXvfw9f+60/z4L9+Ctv43/42d8VH3z3J/Xpl0fF7TNvqVAKapEkvnReDzRnDVW9ETYnlNuVod4yZik48ZXTJtagnFMIfI5VsKPdssVYyQOmlKJHkjAaLHg9fxo2JFNfL4SbbGh+iXAndpaSgdBXM9Qw+HFyURdFxXRxTrwWCaqCIzUTnqfV38TuGR5uW5QRFlYYIaAi/c2DWcwCNifMkyiRdAl1sLrZXaGawxb5J5C80mJTaAksJxqetGTDB2ndpmTIupMcuDwGIijTXTX9HGBLMN2VOpnSPO8oz9YNOUl8PMzs6WHa7MEbsa0JO+eysquWe1nqgNB0sVz2NAgdxB7aaEKI8Im8dYUT4HRiSt1dKZA6itNPjgyAbjUZpPfl/lv79DGJlOMVoi7gHtP3h3nuS88/QgYEcZziShVTR6+F09nDD+U/eIpLjQJPhKcuPOUmzcQnRQdBaTkyd9HTGRQao8s2FPRqyJb7k+fNrieLznbYS0czEfPnrDQoLsCFI9hwW1eoVGg62nOmXyKkpNZ6D7KfcqSzWnPH4ajSwfkjCAqXXiHuQtZJ7j2UV2lq9WrkAxHxdih0O4b7c3a6EFGbqLeF+8/HGRbBHZU4kfNTtR0TcYZg6x43mkzkUiYz8rHxYfbv8JUMMVxo9HNWW8USdyNIyGn9zX6RzYjsFXQypNV0xQhfB+jo+Yo92oPKyI2O4CwC78yD+MR6t2lGcgWMj7iydzObucCBJsesPhLfIViY3Zb6R7YlBrmXNx+4PbzCZZzSculRMFrdoYLhcKrNUGHxrOGXRxRleIrvFbl4+Rv/1fv8+tef+17x5uOOT37/T8Wn/sD/EfWZr8XWmL0TnQ1FdpaT57i31PyHQMRDWPx3FajBqQx1KNJMN7PXifiLqKztt7LYglvi0GHJEP9QtgEDG2y+VDmpCX2q93GxMR9GuYtFculkpC2kRgt3MFxl0iyzl2PvmWSOWvqFecXyXUIodbHseeGOvp3IlbWhWqIBStdDXHVtqqBJQovRp/F9VzzSBnd61tWWLVHY5N1sozxlLQh00g6lqptkCdTo5OYKJ2gSxCBo3joz4JVN/nprvqNNk5HIPe9fv1KhFUeqKTXhg4p4+To5ZLp1y0rlkcRKJ0BysApcCkwsxpN1f+sbeSJK+Dd1YyIoLLUPmRLKxrj0TEISo7T0ofoHcWCZ7GS80png1IwTWVTQEfa7bWlstR2QxD7E39hZSUkVW/en36+BCbcWNsOEeTx1QVaRxNMOimzEh1ERgUnBsWPjnKpqleTIMHUtCt5KCVUvZ28u7pK2hjjnTkRtWZDYlRIwF9Ny//iAAx5P903ghERlYV7Ki0V/f5jY2AkU5paGGcyw2BM60gZ5WjB3xyzOvC8lS5yHS4lEMvd73tOVh6iWSQuGa7HGjHbt58veN6LcRRvOhUkwCxNoSOfi1rwZUvxruA8vRqzFKRLNjJCOgwodJFjRMDWmBj6SjmRaWUgbhJG9L6X+NNsP/ZaC1qMiJ0cCS4J8imdUitDhwMVXhgk0U2EVKTXNVPmKCks9q6Bsn5zFiiJ+S9q6HIO6Ruk7uRZuzY6btqH36w0eph5KArQkp6IRp6AM8X41zf1bfaP7lCHBjIo+8R7MHIVkGV4f2VB9A3V3Va43Tg3fWVYwn5dP379+rr1v376N6+747W9/Pt7eH98fozq5Sl1RBvpDTpenCXRdMMaHNFrZqo6fnmwdZdYKeowJrRAcpWnD5Yy9VB4Ev0qzMGO2iVYNIRFcwUoJAY6cVgBLW5BwheV7CHjXTIP8PEJIvchOjImp0V01DrBBuFTot4Ln0ynfrjzbBHTR3wYrAn2130K45BITTUCNYgWP55DZIKlrrFbDjWrl2KBGWcJcv6tfrVfp2MsNJShlQVdANw/kMEU8aSgIlUu/r6d7b2awameWZgGFmgk0qkmY8YzyWevJrJ5zMVxwsfYK8pk56I1Tgmq+7Lbx36XFRpuRsv8LY8byia1R1CiZCWlg3Yn1aJO5tgH0R0AKf6Rjz9PVLc/6pswFIRlIkBiCE+tf/L89NFOcyQixs/uhE+SaSs6lu4UwjV16HWnukT0y/jsGrnnqlBVauPFiGVZuy4ymqLtaRfsHU1OYvqg0BGdtJ7IQNYtcBQEXamXaRvIkRu5Uhe2L5RmNnaBe4drwuYXCuAzPNcqyNHmAUsyV6ZpEXtlxXosurSxm0qfOIEnTVNIENJ7gCinxsLkXELSH+D1/8W3gSO7aqQYSMERLGqknFX4LfoNqu6G1LK6uQnOxdmZZw06FWnN8sBjw4LyyKNE7p21aeTB5X6F3paB4Vxx/dJ7KxpyZy1FElqIrjDL6IixS6WKzRFQDEKno8ix8j+MPnJdTM5Jkps1K5tpKyVkbTBfmipTmTiVTx/BiCCpOAYSsaw/Ercu1J5cWw5MJuCVQvdWlwbMvk4iPu9lP5cLdDB4Dmd0cX63BirdXpK6Bz/txjHv7Xvoz/Lysevfzwr/aZ13Xo6oSbz/1hYiXX4rsj3YKiVkKV8NU/50xmdZgUqHgLXMmcXij1FSSz3dCjP9o7XCPFHbLzBZiuEzKkSk8X38syJfQ6OFTpQV97I4UdiLaySS5c0+v5lmsiqchY//agXR1CCk+qz4Bii1iSqh925uT8Zgh2CAkxLHtGpJ8UHCMQZBiO5RjFUQURnyT5yBTjlYxQCCW4adyiI7qzRCbkX4jwAS59atJUGLchlB2Sm4odztyjjz2BPcWp4na5Ge5pxjKSN0li1Dh/OmZmwrNMkJnpdXZ1fM7uyNanF1eLMGGz/Po+25776S7+/PPJY0INUBKxzl7cCMTs3ikiDdaNJ5x0yUMXXBmq2Vxq5SGt5mQeVLx2l7kfF29h+rLVn3LwJRjXvZkIU179DgAgVB52oR7h9Df9AZyd8ENHOm/Iogu2/BJXV7tDtmENb2TJpMQ2Qcq8NODmZtjgVluGPRsLL8Y934s35pasJXyPcJXrpFT5DHUbbPwgdqXrrPHf1aMS+IUyolQ8Db1Z4U6akRuuBqTOfRo+SPqoXcEyXxVM7yhcmzM6TmiRC6VOVO3LI49TQnME3h/6TJCmhKPKYM/pLOY+u0Td1p/d4ETKznpwX8bMoOsUNa0JdnJx4DNc2v3PD+htp2en9Pm1WoQf2JR/TEgToCrOgamtABu757hxK2wEHza31pRGxPsRdldVkJLdnZxtLuM7fEIylmh6RjPrMNHiCoyzliUlIH3j1yaorsSVk1PEnizYJ8hMsnQptCc1zevrYvBSk4TFKcUH7zpmX5cFOl6HznJy9fffPwevvZbf96+eRtv33R89VNfy09fb1MiKyFYPlmSSLtA7qXNTrMKlhY52dyCw3JsbzyIiNCGEz4MKan+IB2KXNnN9gpW5aOuHIwoYZ1BOfdRmTPlXhOqfbRoJstfsTTwKNW/8tga9RSXVMl0pmiKmIVUW+xMs5xqhIs5IJWzoA1qGCfgUKZLVT7q4SwysFzMo8YDpQ8fHAp1Ns+1dGq9aBM/lBAHiM1st62fm40W+tYQypzSy5O4JU22sWOf41BxOpYPZ+LzYlk6gVKFYD9L22ylL0ednFZDYageLix8xuMEXxyZlQceWzsF488NXFfMLOysCKFt5vo0xF7HLt3LjuEPv7E4bclvEkcgD5k5pmPKOimMy/MgJ9klajLTtPPIpEAuXpLZBiKlUjECPEj51Pn86YPfwSmbPrJ2DhIKXrZziXQ92Wuf9UOCeAsL11iOGvE9a6eGSASU7taQribbfXwDIE9N6Z21hBpnyWaHMiWd9MnOCaMIVVm6zLJcoXsNqv1aUeAixsfmE3kRBNl4XrR16ZsdAl4ZhXC5Ei+mFCtkV6A8Su9W1zT2PaodzDa1SZQTwVk/aIFZQ18c6MUAKz6rvlBgFcWMhnQqtFhSUD1HmCLAIKkOrUEtLmSkYhId8cMZIpkY51cbPN3gWGrH8plznNgs2iH/TP1Pu6XEANCS5CxSUR0DZp2rRjgun97JFLg76+GmBFSbydTHDxzjxhT+4IJO1IclmqRA5iUYg06WYFTzXdbBjNPkY7cIYeq4tc7TEVNVpgqvzUUPP0S3rqt8avi1vcPPyye/8vX38LXf+vM87zdvVvy5//DP9k997nvuH/7JHwkOubcxKz2ogUWwnzjfoNdpshc75cX6vDhKtQi1JMdNHDeBza9SaycEoBkiJG4i2FJNcpXcKiRigp0Kfw11TKWon9Ne0rXwJG0dTMJOWnJuqGyG8Vbidct1Qbpkk6JO2NUUienYOD3JjTPeiaeWB52aO4A+I/O1FuzLy82TcKh0DXSMxYRPYNZ+tMwrgRoGo5NO37T9xBcslpOlE1xkmjC4LAUGctV18PZgtBPuUqhVO/+wlgNuwoVIE41OveVx7AxrfSh3zmOlkoS3+T8NnyKIrxv5jllj7cvYcfOS8hCKoz4kDHj9l6CIybjU/Q77iA3nBe7ApekpPGIzHZUfinE3lH6tgnAXS4IgCuyLLGw8TyH/MDYrnoNj2cx0PtPL0uw/ePhP70NviUmS1giGP7a+Xh29QWXGR0sXf2EJw8pjhb5OMAWmLG7vOpZA6AhbqoiJulYY6XOYSj+9CDV26NNyxGs13gj0q1eFR2YAOCc+HYLk1o1G4uDuZzsLJNlnU96oUZAmeOBSiQbkUGZHB1QzR5pLVImmGi/FpmY1T4qNWNPGK0vrww0qzQulMWl1h5LCp4ssEA3r9SC8KgP9cFxYeCqr3C6OYK+dI/Mto1s9xWAjP+fbYSGijARR187R8I7HwP4ampu5aMS3kP0iYBbZX5BEZbe25iXNElWoKPF9cY2mKCLCp0TZSqr/jkXq7sar73ZKhHSjSua7RxBvry8OCiVNlWR6dpi/44cX+j6P5B6Gzt5HEqLPy/rGr18y8myVN19/G7/t8781vvtzH8a9lVQIky85/bSc2cb4bmRV221imSqMl7mb5in7f5hyeMvKm0TFFw0rJf6i8VSSKLgAlUCbCu/SlmEsmDlu9QApkeMc9XEogQejFhLA3wt5CTTl4RUGkVkd1zeV1PgWSne0zzl1CskvYHmN7IXfj64MSm1XgeGaUeMzpBRYcx4atgbowOoFCEqYr1RXaAh72huzvG96R1ED4Oqi+hGzc/Je2P8OUfs9ybFaTdJvGls7qgvTsgYlkX0HcQC+TDrYBKzzC/OIFinZY7DBg5AdDRKIiuDJpoCUJcrRBl7g5wek6GuUpCEVRrmR9imkXrHTRslu0DDGWAlbf0nFB7Dri/1kziKwoUFfejDZKBSs4yVpXkFei6GlAaewwVYMF2CurYXQnMsZqzGFLbaGCE3FoxAwKSNtD8SJpIuSDUEpQfZcxEDVPBnWsw6qQZrYksklbqBSGc1ykBtOvPAmVnQx84EVE232hc5Yg85F8xg/Pt8ApfaJD+aFDsR5JfTWGkOymUTTRdI+w4qfvzKni8MUy2muF8jQP4R/ruDkztEPpLqpc+Xmk2YNPyM3nFZWVGlyVukXNvp1xuCGWe4X77iIUg4pFBQfg6rloSmWoLqZZY57kgBlj2j7LK1o0UjNSu20k5NaGiEuNFkTyhL09orSpEsjZjtFL00mhiobbrYi0e8ce0t9vwAAIABJREFUuZ5Wpck4rW4Mi1/l5hQgFMtaJ2CEVImKUt5cv33MzfF99ITp1l/nn6nwSleXwyYI8gysdH/mLbBcSXxHLepy+vKoLAQmG1Uqzfmvvh/K+fsb7n350b/nJ975l37bz9uKj9+s+PkvfvTB9/8o9KjBOr6DDd+0OBQzPnU9lqXRKsU0LyoSLFVq7kmAIAFeRsu5MtU1gY4Ugy0EmD0ahfe5XDWyPyLRKMHn7LoQpjbSvTiPSa+2UMtD4fHpmG4HKu45/OxiXQYfFfaQrum5JzPYfW/2jmC4HQ+KnOLNoyiUiKYx9Qw7EkZVEeUYr41l+NyMyvaheDiKTANIdXulvw+iWvuAuFN/VzRR6idvJaVQ4mVK3CDQyjIR/31C+eyr1rhxSDggVM7iML3DkBXTpD7eZxhRbX2vlFT5F1gUOVSkWfJgR0iZTqVN4WVkqyU7+Ml5XBhhXzFNCC07qdhRrVo+F7wHHCj0SHOnUmdi+n5Ec3GCkR6CNCdWR+oiExsbZHkqTMTgJasPK/3qnmK73+FoK5fYQDXJs5C72CWYZuJjMEqyHVRhMHMY5PT5kKG9GOnTQkpNFUno9HCL3o/oRvulzxWwhLdRNFd5Ltc9CwC7SBGdZDNTxt/aZXozOSfKNBjahzotHW0txER+2WSXZfISPM5zdknx2RDh8EEWpQAOv5bt/lBGcVspNInp0Naj6mPL7RLfJrEjOdvJhiiGIYH4mVMwrRgSKjmkAn9x9dCWd86ziPukfFjKHQ0c/9rMDCyZc43FDo5ScO35paurlG6fRnT3i78N2CrJUbLJvX0n5nhLmHdqBJ8tZXhfch8noK1LfkqG41J6E0JrLVemJDtCOxozlYghJ7kQ6Zxow2p3i6NHmZhXwMsCBHZJVBryyKnKkCciXy3teJT3hweWScLhWfYM8vebZ3DpfjKXN/dnBxt59xjJyx/5F/7YO//SX/WTj0nvp+KT/kb8Z1/8E/3Vr/7S402z4CdypsYC4VsaF+AmQD3KXFV7DaiCUy1MOG+h3YKJCAHUxCNz1UgjEGAL8evYkOfWKjVuQodyCCqmTq8mzYSKsAJkbjtEu0ajc1utnwVL6gjTxIoO/skMTuKFdihB3xxyW7i7QIxy2SfQXOlm+KheGvtg2pEaNwshPxQJ5bgn8oTm5A79gtu9DzowCeQ3I0FbXb1x0UYc3tR3MnPVg6FM9dQvz5Mm6SY4D6LZmLqC6rk/LJwLc8T74LtYdwiADur8rjny/VW62EN8XkdxHlWJfnp6AZqxMkbcSgA7afGrc3VbDRyLS/VzppJNxR7bDeoKrHQ66RZ0gNGmtILCCbKK0EEvkeVewAF5NGssN6CI5jPIsWPgwiuZGI3I3bwUUxB58KCqHFv9W5dWx3M2Z0uYGw/9kkgyP3rtkpPLoCBZ07fh1Q4xktiSIW4mJk4TdVmcy4cDJZnuHv9KL03DkgTTKXK21AMJuGG1kK7kVCBfXodLZKZLKnZhpfDNK7uNUeL+KOhsafKQ244IEzEJfIq00DlfyMqk3ZpUcFOZwhFFUe5Kx2Zw2P9snAr9YFNo+okzTED9g6OUg8eNns3/o92qnD2NenEKT/3cANKg90pCHZqWaqtq1B/xDz+HCe7V80vCj+CoraA4W0emOQ0v58Qx24aUOI/JqeooqtVKGZXD3DNnIRNX8nKCZsutWzZJhgHZWuARMdmbVCHj4LQMFXKW0mD0x1aCBnek00mkKo2CIvPceO/28/Kv/9t//L19+bf6PPbbT3D9/n/gy/eP/Z4fRHdrzUNs+iLKdluPMaTxrHlLBDMJXEkzznPWbg/0crU07HmMwTNo70i4tsW5Thgw/Rfdeccn8vxg/S6lQS2nMu4p2eLo+sWISLbievqkmngjBhAiu0S0W1QaOhlly9IZl3FOiLu/Lda5oq9Kj55i3mBtcQjUyAhVULYype65Za6LxX4RRzV4azE24YQKDfuvSCrapv7nXNIhbMX22bNn74P+r7kWK2e2KOkEfDVr0BTpFT1BfAfH+UkYfL47q3SlxNyLF8qFoxFouhKjunDHuSigIU2BrdgoU74M+YE7+Dvl4zcvrzCL6qqg0el2DPoyMWglvz4d+CLa2YcErYT0aSYjbZaj9pF1ZHg5WrczxtUeYmsP05f622KyUERf+BiVPLOcpJTDuCoO7oMSj6udz3GuySzypv9MLrcc9DhDpYDzxMsQkfqNyX5sUPp90B8bUEw+2Sl+jgltoN+w9zYDeWXRPSFNfpk6rnuajuTN64VxIAVa65Y6RlshTEo3z7D569IrpRzIONTiWR5LsmLNYNAc2ddlNK01xYZDt3xdQKtTfV3pcvB+hZCkEZRWwVAAZsDCWFY9n8dS9kZS4aQOU/E/tBoiPe99cEFDpqxUp5WNMitcH5mxVdRm5+2VNDZmWJhV6pRFfH8H/4nzhSh2iXVlS2gilN0pKKUekyZq2vFQq/aMr7jlxRddoUI3BHh2GF3y/Kl0a0jt4Smi/MSDvCygcmqm9D7rNcs16A9YGq/sfPucj8UN9dFH+MGvvQdFkJf/6N//s+/+W/9ffP7xH/td/V3f/WPxjV9GgLiCEJlYT0pzb8QDiA6ugIBIKVwHOYDYCnVjw29/250elzjVxlJN1RzBDpPM0+Y1WJJrcnNP2R0At6y0tdfUtuGuggmBBuxe5UKOOcOF9P/voz5TuDmOmfnhdr2yH1IH1W5QFeqcLVdaHGFeR09Jx5ZllPWIUsOUQW4f2BK8KmnxE+wsHswGjnj1XdZkclHWKgo3YHUjmLm7IhBIR+bygGbN0Mc8Phql9/wp/3PP7j0pD9cxQjrbb/pM5a0KH7vN/HDVKN1PQQW11WpZEmX5AAgliDIuCcRrqC0oACixcydFluWpfiOh2E0S4Qs/kA+VV8uSIJ6cqsW0sqj9oBNSoWieAeJXzSCUljjS4EM1NZMVrdYhT+kFBY2dLkHZ02VFRxjKx4WJ5UeUO3Vq1Lg6GAqQoJfdFCzldqCEGbR+VoVaLZtHmFMPNdUZ87x6rp9vkT/MLIJf6Yx0fBNptgU2as1iGVH6uNj2SlbFzeyjFc9M+TSGpEfQVytV58LWHu25XhulHWPo9FBC1seyP6gKt5bK7QN9UvQK0XpDDFQO0eDOLUhEjo9Gz3Tt4lUtIdwzQB2kJCTFuZqHudCvMcLG1Sgl2PpOhCJCk6/eaHz+QQTUlHImRE14iORWFamh1CHpHK7ELb39uRwXHbkY60VSYoscyh0eUpxCh+u3xEAyYn+cHodNazWHh7QQ54hKT1hpC899R1CW8QSm8ljjVLiOkhReTpKvA0UTO7iQInf/qX5At5ywiyzs+78v4pd/LuJz78O197f/wd/07r/123zutxFvP/nk/+bt3WJ2y7LroDnX/s85da9q99Vx0h07RpaSEMtXiQB2x+7EwrFEJFBAESDxjPzICw+85AUe4A1xeSGREJGQFeRYRsGYYGwuCmC1SJw2xBjaHbfb7W73ra7nnH/PifYal7X+aqpzqusUn/pSdc7/f9+3915rrjnHHHOMeP7FZ/LRWw+j+yaEpkk/2rcqyBCMJTti9GKNv2hSPQwg+PhJzPE5Bym1z4AL88lciP1UGdyyYPMUgvUFo5L1gkCGT8MmFj5e4GWohPWvrQB9BxkbLc0CodG2rlB30qWOhxQ0Wynay0gBKp4KuXvockv7aJmfdkK0TDX2tRJH25iLWUBLmsl5tw8lCqus+is45OjCnHpBKp1U7s/rk9arE6YWxiFtbuIFmlFK714//C0gtvhBNKPC6Q9ZXSuv89suCGXFErfFVPm7U6QDR4F5HnXW3RV1FnvbzkOA2moxqVnSuY3hm8QWIVnZsSB2hNUhAUy+s8YQ9HjF7umMnTHXwie2dkkrzVl/lPRgSHnMB08J+pjEkvEU69slKjkcTnDakdw5YLOACHm2q5XJ+OoetbWqVtKOk2B+wTPUpsO1Lxbs8PSV8nwhaALelkQPcvdacuVCwpje3d0wvf+DTlvI81wh6zJ0O3G7mvvQz0eMI2Il1DgvYZk6S+z5M3zujMXDMkvXhsJq2qrg0SpwRuCgqDMKeuKWAaUFObNQLkmKHojunsHhtnngUqtXOZTuMjOCGqta93Dg/JszTOGSXiMK+rQLzVglOs9JOpK25A4U33upYjthUZJ7FVw04kuNU/KQZR9OIEjuOgcO7m67EWZYNKkgJasInIbcahzn+DVMElIfDJ8ugjVkf5lw6njTM0bkG5LKU1wQusX4nlKMJpK55sN8iASFQXK5IdB1cT3WjZzHBJTSoONsYZDewDVto66fOOPV1zs+/B1x/tW/esY3vhAR9x7G037dfPRHPvHU3/QdXx3Ttfe7/9wfjY9952vHm3/4MB48/zyKmZnBDylAHqjoRCQDJehgt6QyFxlC4aOlF1pNaRghzXqTZnsMj/9gXxTHLwfgrNWdtW980SUCTFOi11JgCuntjWTGK60CKvc27YVJg0xdFwKqhHgWO0TNdaMnRcSPGUSFSE1mt6A0ylpogCQOuFShC+6+YlJLwKPmWWmysJIlCKjDkN7To0o/Fu/ThFbJwM6DlfoQNfuM5l8JZqD+qoih6p5q3FQcEt4f8PrhkLBJC9xN3e+MeBiOgtnumKM4gw38SI36NwvbgY/RjJ5HrmCLSYmYyb2k0EaulGMuIKVb+FUkY+zAK/ulfCVHpotEHpwzc5SsRWZVr0R3nEdK+7SRIjS1c0HeuTqV3BLmLvFAn46lZbJkqI7UUiGMpOkEJ9gn4e+lFMpN4mKUGZyphob+1hRbbPAxY39TnIxtR00KK5jr4WriDf9YtfW/ndqRlI2oMdR9nE6JHCAzx6eGOlZOhaTjzHZYNyRiUiZPdxo3yjBM3g5qixmRULdq9JCcS4szgFEky9C3TBAxSAiy6tX2G4u3MUx2EjdKRgsUPCm5b+mhlHPci4UHus/sgo8DPJIuVL8dQs+INwzEX8uge6+bmyXLXbVNcj3c8IZcoog1vPLZn26nK9HbWLkip+FY72P5Cyon52xQSnja/Lweu5uuEB+qmlKkHyKOpR6bWU0L1zEpYC1GDyGlR3kGN2Vtbp26dOUQ0nhKTzakNXhXeSogbNIBRpxUo2B7fvuCzQrTDGuyjAZHPtYcs6eKXI6gcBlkaFlEIpzPzPt7pKaWSLGUgcq1xuZdf/6Zox8/Gv0f/CdH/Nbfj3juxacvlnrztf/rS0/9Td/xdXVdbjt+4z/7crz0Mx84v/uTH4u41bk7La+PvkRn1d+kkiqWy5iqeMPvDcHAoWXODJtDbsk85HIv5aHM4rrSE5e7uFSMk0RwUbz9sXxm6HkPmEVCXrjFZ4tFWlw1JGmHqA7w8KuHP5hTMUjBmC2fKRPXxaZizuOyCz/CkRVNuxufEaVCJWH6Dl41w2kFguI9hu8ZgQvaWYZCzybTIq30wRpaq7oE+2dIzJz5vML4ANI6ZtMsxHbloCWQAuUdsSPz7Py0Zht2HYfthmy446XJOCR6qFOWpFxOYfQ6QMkQIYZ7HSCl1rfwpw5Xd8Ej+OrdQN9Z0WZNb7QPaD4qgQmEzpqDW9e3u875PBdfcVIEMOGlkk1jBVHS61aZlTSTbmXbSVzY2tURb6NsWqS4FNH2RD7omVU86NIM3eyl+qJ/12GEf4ZZgwY1paLuxAJDgjyfmOWvuQj3rnmxmtOkA+ZqcsNJeTuteGia5SW6k3guWx+K4X0wfrSNiFT9QqYqp/SDKtRO8mzC+RGF7Fv5VFgmjJu6CYANIbLgZOXgjuhx51NZP5CgCIXZXkMPkxWfckNWJ8gkiFwSMmYixbZQZP6M90+1dzSgNxbba9lRMGlutbxwxAqJYPnGtQAUgfbYi8jtoRB1Fvh3Gqr3dwwjuMypIe+x9rcSV4U9J7Ukl7V12Pf0oXSmpotJx9pY020ita7zpFe7E6O7Qivx1wf4HVNqf6R4d6YyB0ieeQU5Sg4aJTSCIxXHxfTFwjrnQxkY51U5JQo1RHWliTKlcWdeMfQohH66WxMbzDOU9FxhWLKxQ9jhWLKwzPrHtMqRoFIScRlx77r+x9Gf/WzE7/xOxIsve7k9tdfNlz79j576m36rV50db3z1jB/4sw/i5pkjHr/aKyXjQQo9Wi8RjcyjD2sbNiH0W+uDm5vw5Az2W53sd+QCtTJzSuGoVX+IE4IDYq5FzVnIR6CatMOWDesirU+uwfR5dzql4kptbG5Q8QcoxjOj4WiNXNDGzw1DotuTZJZop7bvEiMuPU15s6Li1paWVvjYmOOiD5p6B6yUn2hdWd7ztx1KxtbN/ZJUro8Mf7+NYi8kY+temSUibHKYwgZQB5IHS+jdHvw+oJSiCJ9g1ZEnSM0p+gCHnHget8jDmTIzspR8bteuEK9eBR2k1rLVh/P0FItlNexI22tyaQidqQ9tZXElLmORRTccXlyYrdMR63oZdd0nZAn5tpY1H4ENFuUovMQFO9YhIHlG9e14r7Y8xpA92wD6eePCEc6A1+rgaWjKwcUKq7uoVmrKR8emi7/r/U4vQxfpHkUrjH1JxUOH3kZFuB7g4NZdyviEXnyCaaCYzFcBBs6IxKopMWMWe6rb22M2Q2uQnMNrXIe63y6FYZrQXZxiILm12ILKTTZAB9GWA269ahHmtX6R3NcKiPiaOCOH15d7TjPEICAHW8Nqd7IV1Jx0HFphwvDcy3OEGis7jli3eCr6SuVPKzq3Z73eAVGqqOMwtufjtRybcL6eJdvXc0meimUMN85djV9yyRihEn1OQ0TQ9GMbxiK6okql3C72sTODgmtoWLYeW0C90+pmCr5k9QXnlpMxb4q+81srKeVj16zc0OezIjEyKZkLF7DUoEJteJ5RN19/teNjH+3663/tNl77/Ws5v7kyy6f0ujnuj6f7jv+YVz/qePDyGccDmnZfbN15blO7XU3cIqmDLmzzdL9LxEhM54Njd9QiK7KXMRliZK6L8VqCTEoLCGYtRXUi1uBMXMtznsCCMVvisCHna6yLulAY1LIsdiSfuCIMVbMVJKe0wijBwqSKWGqMwhoYDPT2YDioqViM48FK7iLbUyeCKASbwhSmKJHTxsb+4EkLy1O1iRbOgdpwTD5bZavRQWE07ffZPSvF/lZxvvYQntwAFFjagWJD6NhhPloUieR4a7GjtZpCzV53MBKNodBOK0SKIZjrLMUey58ux7wrSF1Y3NmL5eKuxXUNBzk1juLFntt1G46WUlyJLwO4QfbzxK0piNOwbpZFPoIFTZOZxtWyFJTZSaeYf5ChwI5hGwVf+owlSQYoiTd5XDy9QQN5zhW7Q0iLNahrWeNGrjODrfyauEGZoVWdK70YKJ+rGeqR7s2kvgZ9aRtZ9uzqj4WBN6xSoV5l1EAguRGcq4uwd8ZIrmqhc6ZJcyyn8X06B0b4B6z5ulqGZ1QTXQkY1ONaMH6oINDJNkZ7ZEXTlvOmojZRc1PZJNsoMS7XC7K1EH9OVV+FhiZuRXmXoOJnKEE8mTRmAXrZW3OEbZ55gNTsZYW+Smv8/zh4f0uawEqoapHqGH6KFDtDffhNyHASnByJ/RJy0RnyWFi5hNiT3F/sLTeZnU4SJvtmtJMkmT2aTCoweOYThYkEfGfk8vP5lhBUcWrVv23nKE2yM3An9bfEG0JmTOVbLE8eJRWabGTbA+RohWFn5bMDhHewqVLRCUAwhUEPppESZ7vavIVWrah0CspXrJhyoGiXa35Limy95S8Y1hNuG6FTkIn/fn6FL4c5DYp4VcVUsugrGtzEvLBn7ke8+VaM//A/PuLz/zDiwfPvQ5vmtTeePtzyrV63jyP6jYzHF3JwIFHVIVOoOWksPsqTIUPkJtT42OSieM7/h3Gq2XWOwdxjYpQSXmvW49hG5RSGXmSw1tRZjn1N80ntKCHm02Yit9L2+pMz54g5sO/Wz1/dt9U/kP8i0XEOl44JVNZcM+B/HHA5kePc0tvjGAzZ5Ub2SI/BV8H1F+l7Q9PGLA+r7ILjaIrcuYj3qN5r5V4AIJMMyDZvF1acSZHXss2CYN9UtgJBOOGgLmpinbJLYgB+5qeL/X1eJ/wg1lRzC5BvWVocRI8bPuYwWku74AUPbvC2ioR2tfBoykLwhrWjUmD/a4Q9xZA5Okl20ZoC08XhXQ2EaIHCKfK0Z2YOOwauhQfstJKaoZyAn4ezA73ujot9QR2FzHEkbV1LssMCg3pQdD5y83rC8Of01qeGtJ5PLqpdsTFCeYtU4qkmjPEnIUmplpgeeZ1ztYt4pOh/DZScfNxFA+IIO/RRJsIHWzLPZqag2riEJ+n6WtMuY1mqtcCtk5lZcsnygZTn3TkukstpWYmvaTgahWAezCBBRhD0X/qu0VPE2p/tCoaIEtYip8GmKkeYaFlyGNrl5TVCxHcvammARjL/kKp/YtItuEePn+GSvONa/Oit05FwbKCu0nCOxjvtDgEuQgBt0it6tOQacH2D8DJz/sp1rsPqd2YBc0Jwgikch75DrjcuyF7F4FiNLAqGukXbzW/F1yUbnSqUQog208lBRFdPSRIxaYXAYE5UEa4M9CWZUW5QiKAWshaV56cGgQaDVaVFPWmKI8qfuTK923p5TeO8nDdgcZe53FTzCj9kmV08YlHOz8V7716cDx9F/vzPj/jK569fv3nqucHN935PP8GPPb1X33a89lrHvZuqx+dw1staisdrSGdEOQNv94LEPaiONptGBGKdJs5mWSamrIsmnXGpMSLXxxqHdElKBSCFOYc+V9P+BoY1deHhUhme96BAj1iFXoUhvng4ptv7Qr5QnEMFa9CyD6GbkUJvUkiiIvh8ATIdGhMkimxclz1zVr/qUeRi0i9ZiZCjcsg71mDiWJBILPPfSHpNNDQTpdXtAj9UKYydjoj/lU2ujNpm1KaSyyDb02U/yBhmj1D0w7CVenh455SIzBz4HLz+tsWHslZPGMhzXEM4y5sgvYAG+/m4Fj0IVuYFn0uz3hUDgAsR2cUDUYT3meSFpoAm2gJx69Zpg3x7R2nVE/Y8NiEqCtW1kMeLdYu3h3tqMyqmB0DUUyvcPaniFxjGrN7zTotIIHz6Trhwy/ABjS9T4vAhlg91n9TI160bQqUJH0du/mwqgxXqJQ7Y1kaZpSytmFdCVEsrkNJrZh+HgUH79i53kvbSE6dEcYlpmrZJMDXD+i3qqJKgmMoSxXILt5ZD+meAD06PNblvoevn26s5FqI9NlSDrNGEPtQwILIaNsxmapN61A+p1YGfO/DYDQom3Lnn0iiekiEsuPVtMHQgNqmRF9U7Y28Vc/Xj+Q0F+OETIIFLbzJu8ykPGUl6E3NawKluyIh0W58hIRYm0oTZ9PRNQfTEmqKp1ycTn1SfTzoj2x1ssN81lztYHLdRcQ5T1ArL+sapuir5/V1peq5eRVNHakRtbIRu57GuAhVetIAZh9iydV9PdK1WSpgU9seQxej8yId7JiMvvPz084abn/qxe0/9Td/pdS3FR29WfPJT9+L/efl+ffGLt/Gh52/SRT/un5qaDBaZS/wv3S9BnZIszQXXVy71KI/croUIVzcUYNdBUXMmbCj+zod4sgk5CY05EeYRQhBjQbzpBTVnsouukHj0AB1CM69uKJLRjg7y2DuN2xtSXCBjldLB4duNlac2J29UHSLicYm3ZWuRaQSxg2K3YdYh0pYMT0Wwu4IGgA6ySf4kyK4mt8tk76b0TpLqkOiq/qaILSRcDTYLgiqCkDmc73r1N9pa1k7l/JxmYSRN5PTHi356EDeS4hg7zYsWB5cRHnA41lr/pJec0tQTlER9Uy1UeY5AoH0k30XGHchbQuwkJWLgT9fErI8nGsjMJA8i23XpBzCEFWEXT9+DelYn+jOydeSEMcW9w/3lCTyWh26STMlgGj1nxXGBaQJ/x0pqbRuqnJ0/waUSKrr2pCSJw6HcYtFo8bGjaAZZpRG4KeIOvJTgqOgg8EkToHYxutSYINNr4hvCOiDzVUrD++IRraEHMww51GG+BTn0odrYtQs6tAMo+AWxD0i+hiJAy8Qy6WAx76+y/dVPMp9H9CXO2F5F8jm22U6mxCOkFeQ2wPyeODraUp5MSVsD0BT0NLAvlqh3Z4jyqF+fpHMUW0PIvUuHC2PcTk+mE0pJ120Q2ag1/u9anDt+O+4xkyu3PU1JhSy86PZAwY8Zg8ahp5EU01FAZYeCp+tghdThfcgmPfuHmgVcmx9KmODzu3VKeTkLp7Aj7K/Ytpk/xJwXOCX/BOAOKMZqaMelVN/BmIXHPIZf8Nfw8LKfBR/OCHYLqUdXST08oicUfyV2DeEr3EUzjLbsZdPpbxoP8PcAWNtH5f3rpNz897/yyvv25m9/3d5WvPXaGT/+Ez8cH3jlUX796xcJ5pmp8g58VObf0g/T+k2K8skRbQIfhUZES5AimYP2wvVRhrTI3qkUhrgq8PUU76FAaPcoHouOXEVcSC9RrQ4T86EwGnC7banhXG9wKOyht7xNhqthLanlVYvzeIoVWaRpjpkPdvyILGJ/D+mlKhMTpCCeEgLOECVUjuby8ksFXFRlVZo97LI23AXta+BfhWMIvVlJe1kAWl4Vxp3dlzG1kpRg93LWTKVl2VA7488G8cpyBsrvzHjOnHRmhBSNUrtl+n+NSt0Z89gGBe4qOPpHnID3YrpLTSUA5DyDhfW5Hk6IWUgPkDZRZ/rt4l5QcsR0lBldGbLMFfawUnYdlNlhFTVj2EFopHRMGf/Hs8T1sTvGtR0aDzcbE7eYK18CtDqmEi2Qag0yBkVILv4D1UhGOG0OOzi2YAZu/DXuYSnxOXLKrooJWUrhPK/bqg+5XIp8u1E5fIxS7P7tWoZOksSa7lKlSH4IESnqk4loPA+n06q1AadDhTBBDzMXKtVNClEO6ucUjArGGt9tYVdDXqysD9rZXUKAo3gEpTFno7ixAAAgAElEQVTHIDOcMUFCjWPv7yeEHpEbyeWe4JunyHTRfq22Z3uxNLknyaGihY9YONyje01TFdDumGi6Qg/ZK6i1g7Ddmmw2edo6JMgqDgrtJfwm1OW0TzuDYqGTpJluDHRdv3Ew5RK8kUM9cKYmbVLIggmcUiFjkmIaE3VGSZWF62dnnswlrkc9KEhSKi60neYPnCAqmeacIl8Xpqrc1mueFKkF2+SIjND8kvuLW6v6DsxpzaOe0olM4ss7TqCRJ514Ty7L4nlXbiPyRvyuGQrOu0vo6b5ufvAH33jf3vztr2t3P3qj4qWX/rf44lsfyxEfRZypEynhQtoOIx7sjpK7XTzRlE805MPb4cxgogluKg141g1togFc4MIZPSaCp85F5tChKqo3TDxPxRFxghB0ta9KGuWxuPEhghpggGS4ZzOxi1F3KNIV2/xmJwjyFGFU/FsxW9yxlqZqONcYNMT19IqKPYMXwIwHZw3Qa2VnAdFV0IKCGoozi0WThca1PjdhLa1ENiooSoTZdSJTkxqJzlJpNkp5EIrB0CdWda7ZU3a+dMwKQmn6epkOg4hKBTK5mU5qqdKUiGVKhJZ5QH6msQc1ZbHocZPF2K02XapkS9/UyRczaAcg91zONqrS5S6hdjvOBohDjIKLYE8GFRcn0DpjJWOlpjO5Fp61dHNZ+ouA0hSlG3vnkKB/T4ifEV7+wQTRUDEdmyx/t/uk2n+QHObUB2fBS0rbPSZiyDp2WPpb0VGEWMLarJxtpNLM25UFzXuOEk5ezOIKsk3g1iWbTFlL9CnUzpkHKaUCyYKn5dPC2CfBbxK8RWgOqXAPjh4JN2XmVD7F1ZoNzabg24EALHqNukEtZN8rQZwAolEe0NHhkSUB3fD8lbI74LM1nAlobDelYiDmr1zO18SVO1NNd8rdiY7fqNSjFTptmooKilWx4VJKOZi4sTqwyROR2pElelYmjb6r9R8Lw9+oLhgA2ZsoqR2SuyFFI9Nql8LAzlZhOr6QTbhv6fquu3hbLgoVB10ShjyWh1d1cdi7reigtDal7UOGC6e/ZWjkHLbPpKM4H4YQIxccCnu8hwtuW3xvt/LWTD0UV8LsyaTqwtx/A1dx5Khbc7hdH7x/r5vf/vz/f8nIjDa3Ef/Ov/eN+MQ/90L/wCfvRT4G/OinXlMfzLR0nX7AyVkG0gMrtqN65hYZY0ghvNR7N9csVI9wwxRN+OUowk0pqR1mN3PsxO3ZRho+t8IKbFf0HjbVR5NE/mYT8qDzqoKclpPIcSknYU4scxGRbYalPpjBlnJdjpRV21NHkz7c7qV1eJidIQFBXR6aroNAtep0cOoD7PkrQ9cJNJmEAwpu/Iar8bt9fm/NTraJAofRWOEgcz15nglojqv3BMbVBIphdI1jUsq4IFTmncJGDVPmftKASxW+PdZ3Ch3aLXOJa7I6FQyG+iyspFKryCGrpCG2aXasXk+22gLLJRd6y0mdN1qXrlb2GhMK9slSjSydEakJQHL/cyJyg72xlGgLdEa39vbia7vlLL9ziPWwO1GzsAfmq5GE2LAf3hJKwY1hBgNiYC5J3d6eNJrUxANsSc/v11CCm+vvTKSWM8M6NUvDciM1pWPDZO7xqQGRRhl8Zcy/kqnblcUNaVYpQgy1cPG9bdNnXbm5vXUUCM3E96dtTKZyldnapGBD2Pd+sh4xBVvDdS5ZsDMpzqk7Jco444dm9FPdlUX64HLf6BP4k6F/JawQNjNJ/6gVO5I6FOZ8KSoIEza+VIYH1uJn2FrbQv9Ktrj2oYJ4KcKcYShVg9YIu9c96jHX80F5AVhr59JBISQSer5jxiSMiTEwVa9nyihroxYup14K64uuHsKjUuWn5HKFdKH5thTVK+1ilgJehtUaiGaBZL9yhrG4LWsyDucCR9WUeJPxqzElxMuDq7p66Ck69Kq+4VRuqyw0xQnXrs3OscqT3hey6iAXe856Xma9BEp7YULv2+vmV37t9v3+jLuvxx3xOOKnf+SI557v6U1DWeCBUUQqilGF2kQRdduYfAyXde0mgFXC1YNlENLRy6F0o4hcCUNlQ4god7TR1aFCbSmGtOdr3ZBWEVDCXNsn12rG51Rt84mhQE9d0ahcdEWwtwi9M3/C8eK50VzNESPUrft1JCnaTASaeujUnD7GZsNi/0FpkIbYOijJ4EmNT2tj2vp1GRBLr0Elw9yWB+gnSq6ciMEnoajbZgtSJggjRQPnAWxq1cmMkUNTPGdJ/bWkvogKvBT1lIpQ62oKsMyy5JJ1VRT/lymLgfcckudyMoYHXRosmUp7m4O0vv8ddpnOzXBPu1A4omvFOjfYmVdhWT70kWphgpVNTjt3DXUUPEWl41+wzCAdiWJmo33cDWAHk18Y67AL0A+KB9MSZI+RHkQlKXWjP6d0wFMcpgjtGB2h9M1XyTnIypXy1gI1MSjP0QVQmADucP3mmjERUwWzBdyf3QvkVDOeyiqKG/RsUqmv+rzFk5J4vNgAw7RVPK5q70bIY8aqmhuVtnAodQeGHowmglYIE1Vsakq7vdkpkTla86bZLF06eDwMC6W1EKDa0rIafPyhP+pF5k63DtsJGsNMrzJCg4sinwqzUXM11GrWRgAkNv/igJDxFHwjNwLPl1ziXnegRZaa66sg07CSbw23M8S5JRUsXsy9wPZGAIIKnMfpKC8k0lgTuBmmWYUyWwqqzbYjW6AjOHIfjAG9+QAOjRqmShCSu9n4StB6yLVfkxqyQEn1ydRXpUnGkGTtgCC/qibaCWiT+bGpga4wIHBH8xF6sqQYNRwbr+dxSC1xfpR0u96n180f/yMvvI9v/82v83HH7XkbL7w04uHjM+K4wfFcXoNX3XPDVKIsux2K6IQIkSarWWFA1vNY5CuhupDWsRccue6nqz+P5F3r7FjTbggDpYSy5XIwv9SwYxyqNvXO2RUhP1GIIJFNU2CC7Fyk2VZyDYHqwWjFlYv3IkdhCBlp5Srq3gdPBaBtieHzDQrXNux1m2pNJ/hspEf3mnwIuXFuQ7HC2XkaiJMAjlhwfGmoE6nyyfCmJlU5CMjZBnPrkiLKfrDZnnoLS7GqJJ43reQMiCeuleKGnnedu23DBl3t92cqG1o0LMQyJOg01FwAYMzzkT1z8+Tc01IhF6qWB0f0uH40NCJgftV1tb0BSrZaJpvHWu68I4JSIYoqzl8vqGDB502sW92IkHx52rdg63KQSC5ZYoS8YdEvZIFLwdY/su1atXLwSknwhIipKhb24xyrYIOim4XhYeK3FdHUYxWLVu9iUTorJmZ706/eyl3rUs17cxmiSNaUkmbVt8uiM6PGpAXWiVAWgnEFyWiejicXJZBavY5UvVwOb0xCeyEh5ku32ZWUOWA6nQIqk2e1KQm9hOnaFg5Mf3Wet7kHm8x6bIuN1YWQBQqBseqHfbr6J0wSgeO2cmemuOvzvUDAASY0NCqdGUHWf9lS9iZZ6uwnUuIOurHen71fBeBNBQr5HQrPmpoNLQ1AgUVqEKbu8nb9hIQX9VMNpdwA2vIQfBjOVv6k82tdD9vMYZDDenfLxymlP8CktzVPtvplGVtyv8H+a4ReWb9wspmqQmZrkA05X09/nnd73Tx/Hu/n+995XVXX4zfP+Ikf/0R85BMv56tvPI7nx73rfD5WALPsZO+NzTCzw0MiutHcH0MVtKXIfdvFHcYh2wTPoQCfk9d8RVLeiAQvXkKKxAXIWB5qKIxgZXnlUYN+3pXeENolFjXHuc7fR7E7NVSSU+ZycVdjqSk+HoI02eJJiYuY4wA1qIlA08jc+vKUR133QjYQES511Cji+UJKPzIeTtOJo8UISxL71SKlSBEn9JsmWCJUlWjZIbjBJdfAAL25DEgBe8etBPCf3FPHbs6rqYmY0mIzLzo6Y3kWqf64NOgHqQ00mGtPljAPSdU7qd3qaX0qDmWoVAlnMq2Cn/X96Fw/I3tRsKSHDhvJHLJKlLwaoAIqQ4mwjGYJlfGnEwETcZm8N5+KQLprF5VmyQZFtdoas0PpTvoTAOSz8OGMi4ZwxJ/BKk250gxj1uRFt+1fxmZZOfGGs8XrrdjA4hA+hH8+r/V7XNTDYwN/VB7sXXyfyJtwG6VUc8YQS0gqv4ACBnkoGAYfCwUgKUpjA2auqgLFqJKmUDKWSLMuozVsmuZZssHSJcPhlay3LOBUPjfaefNEzmMCGW6FJTXDUo2/ocnslVGx45SkgZo11ppB5AdQfitR8gri4UiXJpvuKKNzzrb1pwIZBXAd7HdwrnF6WM+dSpkG5UkIQORwEkOA79gw8Y0GzjgDJEgmoVcn8lj7uPbSBsDg4Oz15hEw+LWCNnLxFFtmrn+PVAUZSth6aLnS1qDIt2EdWMWBF8EVrbpSSiKBHvYEsCb3UVhwK+0LljBsGmqZchFi7u8YRP6MY4alm5SlLc8baa51aZKQIKH8JIbehkRBaNTJQME5VJjhtPePNoLOtAW/9Az7HGlRk/cDIbl59LHn34e3fYfXdeVnxK//7tfjB37/Jj/2J2+iH0vJdC1htk8o0crMUZ3yIfDWC9cjr+LkGePydIZS01QXDXMnpIUOndhqfu6aHSoOQ4du3Vlbsi6JlsmbM3wTWMOVyaYYT3kJi2O7m4uzr1RWAE9lNlSsXdR8qHK6FuxZsGlZIsPvtyMZVbyJmmMY425hqD1xUSyGUBWhgNY8zWnqJct03oLUck+Npar3o3dhNp/itBZbosNZT8i2HqTMoQFu5TPM5YnKNLzMB+7u1v1ARjfK/RZlrhka4+c1tblJaYyAnOm+mMoikChbFKDVrJaZ6jL/ENorkHjJhbhC4egCGcmDoI+8klKkuuWKziWzPSITXwRndGzHPeFeNyV5x63EQBg5QvhUyyVZ+0SXu7AHOaY4Nur7EV9u7iw/INObNsAhBINNMbP5s7RWERi/Klc9Lm5rETlZYYC6RbOk3uVAJhNspL7u5vm/qOQ6kjudzK1voCqVvFJtLcUGD3wX9cA2LodYbJrGV23r6A9NFVQ5Bi78d7GyYcTBXieXmtccsSa7E+VZmWMmaEqpMsVBDwM1Qt9S3Vjn1E1RgslsGBRspZibZjByTq46YF5L4GwKCJAxpB45IOVsf+ogvISJQIE81avZzJw/1mbXdx18fKrcmBowHpPoS7L50A3NFCM2bAPuCLAxaHy0YoiE7CvOo5TScyM6arniqZf9JRjol/CPsgRh5T4sYrGnR7tlbsBq7WBpMhlZdjGZbtX0CowRav0Y+yN2DwG4lHsH1sJgNlebvw8WNnpPZ42+WRNnVdWPXoVb76NXH72Lg//JXjcv/NB3PfEPJ/OEb/d13ZiHr53xiU/9sXj5g6/Gw6+8Gc+++MBhHm7NNY0c5hAm18AgL7A5eraAAZaaYDuu0IhjIE9vOa5cpwaxAoC4WLNCnMXFGHLESNkxBL1jhQ1ipVmXQJ8gbSuXh4lDUapNGE31VoplvjjhO3AFkuzu9hxwyv9tkEaGkoDqQaCrd4rMrsJcjgRANZD0jNgkUqTVrHptKZoKeljq92NJy5PKu0TQKBjOjEhzQckh5Zbjkt5LfVCkAvD5AW1BKJYeW68IRQj6YkzOxrIYgIEhNFrV0JuTGRfbpOqA46hMy8eRkTSLNFbbojgYtpbJXTGU5ipIrht8xuKpCEn21g3eceqYSrJNy4+yGyDZyXhweOCJruI7zgKBSwTWdIKO7ylnEGmCKiFrd5ZDSN+S/hKQqJkj099UD5SjLvPzlMXj/OKSKETzWwDXmvRiwQAu3wzahwsqEkB4s1qov3pIJmxuX1O/KemE1Yyo9eTwIIpflNow1KfQJ/PEt2U7b0LFAryL+ixef3czcpbMK5AI59/I4axJSdxap4UAkyK1aO5daiZplMZ9EIx5DaFFu3qLPm6ysmfDjxIHbYttWeW5RmJzmImAlYTOmdJV8rN6Ne9SUWl503JNVtGvn4hSCIgVPOXHVotHROBYErgrXz22qi3Epe4FImfR6IIz/SH7UHcfJJekdBaLS+6Lw4tT+Q5OCSqKQe5YCt7SPAhLcLLewg3TsttSqkqWFHO6iQ7oMrRguAzb0m0SxXoHyt0Nd8F4OOjc9ZwDSTKYZAb+QQtAE6J8IjFSSyQ3iHZrdTJNVkhWr1MrWY2HYV+ma6W9+F0vxfOvfyNeeOXZpw6P3Lz5+pOTZM/KePmViGfu92U0+K5f1w25jYo/8n0fjhfz7MdfeBzPPC+a6TR4PtdYuvk8G7jJmtaEsi0c6yiTEWhSZnFx1iSCFKo9jdZ6SiddYUvE3TUnwXEPZ8TlN66DRyVyOqNFMqE7RJ51k28Er4w+BU9o1JD+XoQHlNUuRDxC5V/nlh3M/1QYOMnZaZJwwx7NnZcDdy+m1pO0u8CpYRaB2hWrH8E7wdaZGLGadEJpTUoF5oB8sPNw28pcrvh0dclzwGh7L9IKActK1aiAkYb3HykjPJPZ72g1aBQB52uETuQCQVcHSA9NX4ivJjQlnJgCYSaeUjjlB9QFBFCNTZaudWxNysVYriJhyRgT9FABscVsVqKz32t+yPlqGDpvwtZOjFU1Nj3OvF1iJTdurqD5id8tOUMxozJLYfD5nKI4eoMaCbk2Trm/KM5shYyaJ++Qz4KbuoyRcQhbmELUoQvD77sGBZDhTmMPJHKNTA3Xd0Y7j62luc1UTWW6Dn0aE7jQFR+jtSBMdRnUZaiQgbw85IIPAxL1rbuj80O5J4N9eU0Zf9VHUJR8ie81FYND+ActEzaPPrWGLoEjEfrVI1zMFl2/rxE5m6KrogLBzVinZMR2Mum5gi0N7TVKb+GeS+bYj0f6P0QaBGIbUjAfVla4MvzXU1qlJCrV9nSIiFCH+G183H57BXdqUa0djrtUKZ0S42/hplW0+ryuXof7uUeuvDNXa9DEJVelKuVoknYlfSmzYSWF6IQS9sk8lgNoFFOpUDIhEREDeb0tHpK402tYzO2UHsGkJVzV28F+vufG2zSkVgSbfSrNk3U8fv1RPvdHnz1/8t/9VDz7C5+O+9cuv3m6AzY3f+VP/e9P9IPPPoj48teP+Bv/7YfnPXxw79tLi87biP/m3/yv45/6mVfOH/mxf/ISuqPrxDjjyBPk1REl3HmJLjeFz6gsJ8xTFOWQk9acRjXVbsHWrlvKQlpbpjxT2VL8AhupZCOkWYuS3b9H/+i7NCBP4uK6pV7RlMyE6Mag93vMuN7t520RPzGvFHjF5xxSGda6k4PtWGCVuAAzP2f1u1dUbN3zfCLTmyWsEqeUCF/QBsjoeMinzQDgUGTXGq5wA7i3TZ8CugPCiEXBwCHwgjglCmkUYjRy4yxrkiZJE24Bs6IOenW5IBXcJUzWSmSpDTgzCIk54kmU9nKbLquuAWOIh75b4af84VRA2dApngDM6UA/Jd4NLg3dcKQYd+HibXcxocibrZd09HBUrsJp9XGF4dJ3TWy8IKmgwoxcnY4+NI3meSzY/fuietLWMtozChzQRQ1IjGbeIaMK0RaqlcA3V6bLYph1RRGFlAoOU02vW/c2dcVzFdMDDkQa2g0pPWRfJleawi6p27MpSEyLGWMsOu55uA2CBcqb0kqfZm0ogydjk22A8u4M8HxOw1liobBQ4kKrXtU+y3I5bimmbamdYB5zSsid19KlDXYKXs6iLiHSQIK3uPmLF2BCflo2Dnb2BIs4YL7mbTyXql2wcq0FHbE1poXrsZsiF9pwAq2/gtSVVP8cmXapN9OUGKGCIFnoCgbuq0grn+Ws2yTsUhuJaGlBucETolB4ej5WOyXlRJPGTGZP5o7uoaKfe/0wr8o7yU5H69Sz6OsCPNIBdqbo/IeFuirY2+Zdu3qYjMyiFWKKZDZxLIMYsDQPxdPFV5sR496Dm7x949H5mV/4rfhHv/478dxzD7bm5NN53fzwn3j9id7o5ibixRci/s4vvhb/6/98E698pJi5vbvX1YR5/au38f1/9kHcf/ZePH4tZDJ4BY9jEvV6M0rcsSd5l4lDMJdZhYapfeysnU9+l0lHes/02l6tVix8upEyDKTo1D79uCvZduPX1AMNYTCkd6moYnu2tsC4kM0UeX4B6cXe4PBCXPXxarfuJ3AK/NM9y/SOGQJ3yZLHWOtwJ9tIufJ1pTdNOCrZ89RodQr1mJJWlYfujqXVRTNQ4ZArYkvZfU8Ut3RCIxmM0eVu2CrtzUJJp4NCxUhTyQ2WD41ZqDdi0jsV+5fqCN+ht3ODSAGXgFv6JZpSW+WIbWm6wqamdEJyVutCBcTyGYnUswP8Ie4Km5GJef/2ITyP8aLKu9p12+paN1RogCS2FylCh4b/d+nY+K6kRc6U1ul40RKZaZ3Glzl6uxZru9ID8Cd0KtaPqYFmvQXfoc41L7Zi85QOE7tQE+CrWJSFscFuF8trYmFSLVW6qCW7mpa+iTpIxroWDUU6g+BtZXWDKbJcRKkFhHetBx8evdifljTWKyolabyhc0znPc8Thq+oc9D6xOmwlpT78PeQxVq44PUYl2nBPPRKLkWW+QT+cXdtHesKGYx7nbGLmTMI87v2E2u+ORubIKsIHCL0FIuR6ykQKSlsb9Ty7yMYpyHWsSb8Ri5Aklpwl6Jga96PQfVMqq+WWWEhmaAuDYpdd8Eywmpv2PFXQshEb0dsC5jquJfCwwRBR6mKmEdOoJl9bB099jjTAoOIQ05g1D4YntUIkQLualen2ZNG4KwtgQNIg4hN7Xjk9JfI1qyQbu7fj9vXKz/zN38zvvD5L8YzD+75ezyt180fvvbk73Q7Iv6lf6Hi07+R8fA84pkH64B80lc/7njmlYx7zxxUHD+kKHiw4JbYw4bNbhhGekcpwosqsdXBXdOVOemTFLFkBtZZOB+IXAMUJVA+YgBtqBhVH1aMENXF5g0tQT3m1j0GCewh2/hpnDSPWxpI+rO75TLHIeWgetBw5VBMdYYHHc16WptsK0nE1Fjc1jCc6FFbr+92hQbIwjgxZvpT2qlBAGFxDH06XBd08vR2qkXyq+TPiER4NIVm6DPyDE5JFZohGM3YTkxBLT5LGT5n75gPCnCROm9Wj9MppDKtBfx0bn7/yTEqNvV13nKUt4UXFN+VrvB9+JTEH5RJOXbRh2Nr+wHQcE4Rj3UZcT6THq4/PoTyivCB6SshSAIXkswqZnLYP4St7PcR7POHjv4V8YhwuHirYiuM979ExZKUQaqtMdjH8Hg7caYmAphUs/BMqZKVslXIjgsUj1StzGFTpRL90koUQvGFkRsLM58CKsJKf/izFaLyUlidfcoVazBGhdMwl9qRSnXj62V2sdsYgsSJFsxHctrb+2pk4eGcvPIxPP4ibsEW3Ai2rz6kgGGXTivnNrNuY86pCeZCSXyXlE6iHGK1Ga/KIlio6CdSc0uwT24Y+EOiJmkjQaCp5RsXWzNFuuRu6TkRU3JCADh9/arfWIGR77FsmBZwK22Y1OSOhGTdPSNfHDGnxLihQN9mpuF5ff1XY0RLSz9dqBA37KE9Y4B1ZdLKEfAAMYDULWBluRIkAC7bbVNi2LkGpeSiQ23opdYk6r1GodUmpWNkr+608GwmHAw+kgtXuVgpJD5TsjhnsU0+1Z3z2Q8+G/H5iHH/2GuSp/J64rnh665/+Q8jfugHIj75YxW//Iv34rk/9u7REfG3M+J+tHxZC750YwifSHHUlZ6KNrnoSNu04DwESvpxM5IjVFAIYyOFaTcvDkpwBnAY1tT4tRb0aX1qtRNSFjVriHzh6qSqtD959R1YKLiX24thIPbIsB7UZLOnaBh+f6tBIJ5dfiHsVYzBnQ1vmWirKmq4E+k40nfBPbCgbarwUXE7Oy251T6o8FsDo3mMniM986QKaRMr4eG19DxzORALsZEuCrJBpWwLiHJ1y/fkQytDpmKgeOAhqc6Fsq8W1RLY5CIBL23LcK4ajmLKXKoqZ59YvB+OIYorTxd3T+1iPemUXDEj2LROU8d6mdMKWpWaZBWO+hkUzhk3hnxQ50eTnj0QkWtKKQoXwP4APJOrccbaLcQTUptFInLzIDjnlGT7+hH/2rL8Ji+FPEfp7U5NbYr2Mz8vynJf3/EgcHFSij/1eKOEh98NFYMYRmxjp0hpDsVpxJBSSW9HK7DAVW2u0IHHXZtDw5TyDc5lXpyTO/s3qYIeSS4UPvIw46mV3bfVLaz0nIKJtJ8QeObVFu3vL+lmIaICdUduGeiI1TsqUhel1795pcTOD485tkgDttUvW2Ac9DUJ+Ki1GkoTpsNLWbyspYEaojb0cI96SoW2OjoB48Iekn7lPbCY09oX4blcbB4QmsXzkKZl66YQAjMNmSkO+4jCtgMeDrorQ7UcH0qE/bD6jAFGOMRqoWaITEZDuOvOLnTDPddw/G7BDwjak5jRoVl5hUUJgQRnEF0LdLi+9jpYwBz0jrI1SLMyp1jzPIz/ml8kS27kGs/xQQg+gyWFW1qgdgSBEoLtDNhFn32xo+4P3dnjKWci+1J+ktd1XW+8EfEzf/42bl7uePOtBZe96/8OhN3BrwEVhprSyOLUWJBUeyLW8kjlDCqzua204ZTILuJi8oHhWaj1LPZ729RCSyEpuGe+OORx2FDmkEYd3ACAYTmyPQPZ4dbLouL2uk0CJ1pAheYvzQiIhVryJrj+1sEvGFk7RXi2BhOYqg+4us7NXbUFLgg0NHrUhCcD5T6F+dZmMhPf9hwpJgbLjTkFOINEKx/fmhOSowg9f2hQJUVekwTKzq3SQHAAS52XzhG163eSj9F4Y2BrYUlZm3GEXQBWhShequsY9UPMQdGpRgkWQgUmUPZ2dra/W0rCxMrT6wbE9kg9g5Oe0lpsKAUiUeY5dtD99g3rPmCqD6dhXN7pmmKKetMeHpEO3rxp7Jh3thXPac1IrPNMohw69JiqkYeVjbxh7xNVYzJ8oHNWLW0xtcl8NrAczq8rISsAACAASURBVLDaRy5brjLfdjnXLU01bY07njXyU4r198Qve9tSsq4e6a+hc0HCxRTpooBxpNOR4R6BT/He3hc8LH4WuJlG0oeCOYEw4mPOFUaI57wdhyRB41BWYcPej7CabUiDBZM4ShcnmPrlPMMGeVN6G+2Pa7WPFWgIj0iWTecljPlEH8trAB7vPRQbUxfMLUeiHlUbQjmJpCvaImpBRV+PeCiWiynv/XWHB5hqLw/D1jFS/gnzOZnfujpQpX054YtRjv2iw6k/jqbMWPlRKpHgJbbWIwnZqov0XfZwYSDdBzpdBBS4FSA8V8HErT3tho/lXUxhOhKv0NClxplEbnXzl6ngEIUW+ws2bX5+4y5mo3TzSVKFb+v1rpKR6yr+4MsR3/+nO/7cP3sbb3xpxHhX7xDrwBx5y2PxVgWY1T3bKDFqudmvq5TLl9XPuMZLqevQ72rJLl+kTcF8ygOK0KRCE0Uc1t7g4ugQLWFbcyn1elF7QsOx85cH0IUw05LLOKhXvBM1wrFWFEl8jkiySSkSHpXN/ZYLPUbvfHZ0LYTsqDspZqkMGEAn4zzet0I6CGGF8GAHNrUPAValxniuwwsVhTBk7cxtj7AiM3rAHdUMEAfItOvaFZGHChyG+MotYdCBLeJFbtuivaGgUe4Tttm/YdRqmg2YMrRihE6CDYjXvNUyIkX1PwTBE/iHg+KKWkeO7XaUyywS/1Ybf/FniezhWwxG5XMYYVlfINlWyHXAlbnYqKAH9aJNvC+4lRSzzUEiYimVbB12vD/ivMxLkoa5HNKxvpNvoGA7L/+Q5IJtpNIa2q1uZIb0uYXBBc0KFnVjg6fk5Ua8VAeSTFW4ETPVkuD3w5oi4RkoM/bXWCAKuwoUgy24PM79PRimGeQXgx4FTe0q89WriZx0M7ByRouXCPxI0U3HaAnjFGdHmasG1J3pztxxuKZyDaV2FYJEmQ6lbLFjcYMtwqTFfmhOTTr4ohhJEK9EpkJvYsBC41rf0nC/zP/S8DNE0oaySVty9ar3uf7kHNfr+sLOQBF3tr1MhmSkmWmrfIGhbltLh4StGzWTk/1LAtNjBRMcu5ozQoNmKTx6JVUIVRlvW90q8FhYjdXh1Ncowk3JnojoOrFFTwxJFTkioc1nS8FQbp3p002JRMpWgF9Wxnpw15SLNdfWCJdXgNZLK9fnY2okHE8ODhFjmEr4fr2+rdmcN96K+IsXOvJix5tvRriIeqL/qgfRpyBvddd1ekCPMMwxW5iYddWZQ2jWUvxJ+ZC1mnrDQOrK9gNyrmesonARnNTQ0b4QEaWoaTdUZQI4Iw2iKD2aMNudD7tA+9KkCVULaLCgeQBnqZbTXAO5CZqTMuvrHY9QRzGdXXGbkHHmel+uCa5BODzB2pFE3WSu5iIMDi5M1IdlHF2C4PAr7SBKd5U3lHRkGapTJ4a6K8iJsP7NRlM6xh9oHvhUZ2BC7mqqMWS3yx/yDXHLwKwvEvKUebAxVD1aMgdjlZr2x6mhqgwtK1P7W3cq1RZXRw05VoutIaIM+OmbvDan5tqHapoIQTIETC/CR1J4WsCY+hmb1ZyMznz1tCHpxctejQQkAUre5/osSX6LE6J4hlqZkuWAqi5bwhIMmRtwXnPVDkN64cSGGLX6oigS1DCD+zpYHaoDCkz+tYSFNK3g7cwRsiecpGBWwYylc31zspuHV9f0TNKI0SxB2IMA3CbPF3JUhw4yhoO2zwiS5dECJpNc93l7scLHvEIFN5/CYnAE8wNl1tMWG+irFnuFNmoTjQhOiw30IuDSNXR/d0JsmbTt3Vsqq+X4Qsxfzgk8hMqRINxgFBKK1McObfKkc7VmWqeXKOhMQEBWDqXrb0efkS0VjNgKQH3JMgOTKeJCV9KBSetTvQwRD1HYSHFYLDaTtBe2sdLU0JcS3OCr3A5t5neDmwee4JZcwlRjTaVt/CzHg3ey014WpUbeuofiG88ddtEkDA+5cNC4YdJIsFedMCch188O3wMnJu0iWZyqwQ4FWG77wITKxR43ua3dp/5618nIdSO+9OWIP/OnOj71k0BH3t334yVC6cccK3iHqjGdy7kilDEPga+qKlXFZcpuUyQ6Mb7SLmiZWg8rX2KOrNMglqaAEg+skLRWMmuWxTWxIGzobLGyTh9bhtzalRu/Uyx7J9HtXMjkE33Mqqm9jkfKh0mAs396eHg8eIeVdunDlc+hhvXHak0rnWC8x10bwTkxBeb1nt7x0lJZibgSgaG/TylrsP5vG2tsnJMQ11g3e/sEMXx1udops2ZJWyyawyJYlwT5zQqVIUhYKBHwVt0UYfN8Zz3zB6s3JUghEiYIQGxPIgMDGdtKyigL4tMfMUphPbcQMJ/3oeg3SFrdBE2NF3veegBX3ceTjJoI8eLhO5iKaYLCu2ibcTlTERsdHq1mTY9sjxyZKwgaOudSa5wNK9qXeGN7aHyuwoNlm0m5nOkf/oK5FBoMOGalRPj3g1041hLPD9Bt2f13iaDHZg6IeqvTXWBsazgkykAg1RB8OksnlSLMH98W2rXXartxSA5T00pBxG5otbvAQwbj3EEmCUJutw0jOeAVZntbBGs/QjCw1YZ0XPDe9X1ZbyVDHwPFWomgS6qrZ6X9WjEFq1zKLPR8CsfvuLNeRLX0Ip9MdgXu4b9puYMs4EOIgeNp656soGtP7XDqpEb1umzf1c3gRUcEGGmrlT+Yx66DiawCCu/zhEsDoqaOuAWFLVjTVLrXBCOTEPaik8M4SSCvthDoeK7aUg+tla9Auc4aK45dFya08A7zyb2k8pgVRJ9a34+8fPvp//fbQkauX/zGqxH/8l96HK98Z8erX08D3k/63/L5RL/TwdbwpRwyCVb0RdFG0DHZolbjyFvEVsnRSeUafYDT5HNCb+Q0nQErhVJU0hMkaLl0VPmsIJw14RzQI5qKV82A6TQ/raGpc/JOnkkCikkV2NPDxEZn9SSbUQJoLu7awkMtvsks73r1RwG7a2/A+z+3+xctM/ltBlNJA/uM/CKpls84qRW3tQ4J0SgfWsWrMOUy+R3EqFo3kx86HyJvCWlT8zAAflSt+8dni9XSMhGXVvmKuLoi2U5oZ2n4T5NA6U0pYgvp6s1yZyrkD8J3p9aXfzRVYZxUmlD72KOCDPomGmIVjPPuxq/QhgHfZnCoZCryssSe50OVulHkfLKgEamvi0B06CcEcOtLpXTMtYLkjhuSTPWBjEqyTOJUijBR+TsjZRogEJg/35vjQ3oeiy3U0oLSqTQPxcql/aMqHT9FtTqyx5UG66RVMRqoFJtbW90kYusrJepB5s3pcMqeKDoAWSeub48pC6bahdK4dqrXXaONUa5n39Jt9u3TU6l255CJ33CRqgW9hPXn17xOoqN4HJtZ1Fo/hhivP6lV9q+kgtm2nDXdNbpuB+FH1yrLD8MYwWLVRIid13ru+smdMJQek4ZnjIS17pwkVNYGd4poMn63Bkfy+Q1obSBgVYRsRVJ06FdcUB1SLXq8co1atCyH2wz10vUfsbXAjw0/dW0RtTfn1VdK38M1i8w4YpNS4Vhlr9W7HahmKAbvhqImv1ZukKqPxvbmlJQA876Lhu6spN02g8OH89TZaS12yLlfe58bL0awRCJXZ4lz9X68vi0Xvmu9feWrEd/7PRE//Rcex3/+1+/H43oyAKce5cUSwQXeBFtkam4iQ0gBB6RQASAtyi9z+cHMcdFaNVpbgxSek8MDY27kJFuppZGWXlfqrbc/uPVQYSM9jwymw2uvXd4sautx83EjwejaMXzriqjag6qi2gFK8IX65SY5PT8CVpWxTgXN/EtnawUAPYY1uxeahw5AoRBXthBL+wDL8G6jyFWIWbbKZ84ULP49kyHB4u2yvDT0iQ2hHjidBzmz6SRudcuDiEIbdb4+9eTWvYB9SQqxL7blqISEUI9YMeRK8OWubwueXA9EUysd2//MqF80ISE/sSQ+gEy6clV3qpaG0DUrOy8qsIpOXaU6a0dahs/66qGDtjcy5oZ36dVrqsQTGNHiV4/1kwbJc2UwVsZKq1hKwhiEI02Cbeezldc9yLYL/SHxpizU1RMZNETw0g/BgsPnkuQl5arYSkc0XaD61PAhxt6zfCvFu4g+sXggsN3bvV8IQnL3lEdP0l/MTFcF4WV0EqJYQjyQq1eQ/HC5FOTHcK+Uf/8aGLwoxbNhMCSwj/7eJIWQxSjuzJrnqCWT4ao2e526wavEdBw7VSp6wvDXSXrMkJZdRmzJsxMJ9IG0t/RdWjpn65gbi8SMnMvFbRoEWgWCPsP4RSPJxkSYpN3shZTaZys/SNUTeEoH2Zkh80ChBAhDQ8e5A43GoXB9NDrdyGIrZut2B1GFIipp/EeImZKDQWq/MrMlxxZ+VLo+Kwyq2pRa7VIJjy2+9vqxkEC9nm94FaC5ovwDJ8MU8bSdTTtajGWmXmbTYxUnzVBwTEwlT5ZAI+uiXeeKYk/59W1bAqtd8xM/dhuf+T9HPH5Y8eDBE/xeVXz5S3OMq85zkM0hWw+0TtkugWuD6goffApLrLw1QuaEDXd3iKLNX6iR7IOjdzaO8BGtlTFc0WGjjdYI6+Ax0XEUvxk3dG5EQeSfpQ9cQhcqUZgJcZBsA0j1V4uTdzW2U0pWgNgX1IKg00IjvJR6G/+iMCRLwrBvntbSHbtd9Zk8guehxpUS+caHgEu4Ow5NCEKkhNsDjwierwYTqBZxkK07eyJ2x1MLU0MNR2zhXUwAfZLqp4W2a/x+tVjcfjJpvcRxTo5ymygUDkQ+8/nd1/3nudb+e9+JOeu7poPSHBkNPo47enfL11BBSvIoQB4mE8QZxun2hW0jec1KWclGSuEmY/iehFevDg2vlwnzeRBLBUFqUYeTxFB7cWqjKJ/htKmGXxY/oVjlpzvhMmYZ5nasFHLdqWNVh/PvD6kETvBiJRM40XLIpyTWG/JDiAAonXOnbkfSvHHak0Nzfc5xW0h/m4Cl9bVqwlyxKHJrj5w8GId6N6liZxZPmsbLlYKLjyBFzrVqZwU0N/lg5lKLMeP/A5K5DA6YfaewstWz9q5cPs28vjGl/MGGwnK0/IYCF/fHYpC4GlKCqvaEyFEmgcLtizXLfhJESD2/lMiIy77aJMiJeFKr+UMpPjOIMtbzZytFiKDVIuxMsWVdG1fuTrKcsaLIEg1Mm5L0uiOrqAO4UE7beT7x79Oq2CMOFa9emwpiLaV9v8veTbzz8F2cmJOwknsnxdvFRViWPFWm8RzSG0Js34k27h95dTcD0mivUSP1tVfjqb/eUzLyta9HvPxCxM/+GxGvvXETz9xzyPj/fl0I6eOI7/nejF9/vccXf++Mj3zH/Yh4yJU3HyrVCwW6McdeIsJKtJWCOjDoPrfz7NnsFrYVWlPwOSnPrdm1UiiD+N9hpcLJi5ypEzy4IBXfHPkXqje/Jkti22hlSgw6oQRIcW2bgU1BkUzpUwfNq0VLGtIVbdG3sGlPtiIGtRVjWXPB/H82vGB5Ky/WiyE4OEKukz9tBIpImgThNdc3mLgL9ATX46S6ANVtXXayO3RhrrALX9AsNUQ5eSJZHjlrD/fSiwAl2XYez+OjSDZpBK44paSRHGcpQP69FDpSYuwhkIY9ADy/sSSnU3EsLXPdIu2pFuFgQbHpQU1wrSMS2MLzxvQZixV+POWguE0tJo+0T+S0bzosH0Yhr1weeZCZvS5hQKcnNUlmRzwDFSTFm1fR56ZGAhO58gHNkYVAY4kJtVT6uD5LFKji+R76+252tODgQ110K8OnSMZJjRK4DcyrvzLUY57n1u3v9aU2ciFBebhItjag21egky9rnyHzlvX7SrrAdA57uYFtnCTq0r2E+8aZ8TZZ41Rwb2ZoCDgs4AVxcNPYmyRGsgnV10kIe4KEH9SrFfhSOt4wW7TxMtuHMmjYXXKoLR7Jal6tTKybiMKhmKK9AdGnk/dU8dHOi73yv2VVvzWNOGvF3gabynBX5uahOrN4o/I8LLH3OHI7FxL1biFdnUzeYYkjBcvgoL2TZCy0Eoo1OcbzSUlxRBlqXUz2IQJHw+S5Ef9acAlu9QUoNVSGKoS3kKNcBQ62LMNQMzCfrgVMUeWS8aG2gaVwlFfLrglGTwLSsE4we0o1fMTqrgzq/aQE3/YyLkVfV4MhFN8CDW+6XxvN0unaAOCvmviAelvFWS+9FPHqixEvfmDDj57S69tORq7XcURcnruf/eKz8fO/+X3xnR96vDOlv+l1/dVrX30cP/Wjn4j7H3yrj995LUY8d5tTJOYc0g8kEiiRPxI388ChwRoTBt7EJK/IXEctklHbpk6nSUNKaC5tbHPSSRjjo47SYQRsmjGX3O3umyILki4RQLOQMzVc0BBC5AOHVYVkYVy/r0AwAfo66XNu6V7OAF3beIohUk5QCNsgVoR8ChoCPZh3RNcN0O15YxY5AkYf1764sUwtuwTz2BnWEjqKEh7F67OOPa5EpVTCQ/i6f2KPzZG7A+rOcryOmu24IRpOHzN9kAQlJTjncTg4/kOcEWdllWFm3JjDAoc4WW7VDUf9UWORumYYPIUPU/tnqJCcFezlhXQnS4CYKrCI+e81mCwggPVNU62zEL4LulCpcQdJEiYdes8xwbakdiSen+PxtCVVS3ESRo42MbE2EgZ7gdPyVlUMbqInY9dQgMqhia5eSN+A1QfM0FXVsr9BswGG0JrfH9pP8xGd0c5FLxLLOM0NmsvmjFrHFTKjNo/38pEUOsjsGZXvcGOx5uK/7vKEoE5Opszk6FpxtwD2xqAC81jnfZGvQSICfCEPiag0Z5mRqSE4RJyHrXeTh9LZmOeZ2UYNZRiFcdUzOdh9bbKcTuI8hsOw1s4Z0bwes4Zrkpr+n5AMGEnSUeUtSV1EICDaNuRncCUSBZfqFsU/5/rn80IZU+wighI9rvWpfH0WIfP5s8i4HumBnGNg67LsoDtNtSDOMzmL3NeG5QVN7dUbXm4xpLHjQFQsOaAiHhnHkdIAXYErSVmdvlT7eETiD+b6IjB52bD2mRIKwXTs4YwYAymGjZUpmeg7R6aVJyvNKjYlhxy/bumBmzRWGsWRekC8J5SoB2kB13IMtTvn/TnzMnmhWmElsgT6FbU6R+PE+VRTzWYg9T3OWRINIagz/NfBzEsPZt0OXO5QW8ymAU17x2ZxFTIhnckJLkgJF+rJUhKubcp7iV1kZt3tFdTOqW43J9Xz+MrXqj/68T7+2n96xq//asSjejOO95Q9fPPrPb/daw8j/szHvxG/9Ok/jF/7756Lj3zo8bdUZT0fd/xH/9bn4sd/+kH/6I9+6Lr0S2fkRth7LkRqhKUQgjShmeIeLo3QSqhU+xinPuanYoCUlmWeNoEVivQxldUclkY3NgJuhvkDFAE2P3oT9lXRI14yHe7LrY9ga/pEZiXZQFd0agYVSatDVQ6hD6lWh2gsm2MH/eeBSQTI5wN69Kt1PxSkroNgLNIqEKRGJUBjXLy/yGfwtIMq9/CYBPs9A239k/1x8nRHSMqy+iQHUpmRVAPFvgPnBYKUpNAEe8Vx4umIbzUN+3H2DIZI2eTOU+6UOcAQqUhdPk/6qWcgynBDbAP9+nk1xM8PonKUwmBOqlQp1HIVibWdAaEOHnRHIT8WBIOiawZsAFLzwbUEuVVo63gY57Y+ImT3Gmljc6SUjcSOMwxxTKgHi2Ddu0XOEZDdwvFLD4+2GjN/wWKArENBgTM1h0I3Mp5C6LxHSWIYgr44YE7Jx0esJSxNLRVubTrx/PejJAsLnzr6tBTzKzgUdNtDBleRtHBLDi+pbQA2Z0o7NpDaQPIeE32X+TYbomxRaZWzxVJAbzhTmmMOFoXv64x2Iymmq+kaa7JL927NiQhiz7BIRUqm95I0IJW4lQWeV/E92TB0vKbfPKqhQVbREpTH/zarIi1rcUpieR4mAVx1R0vT1/MBw2LhChdlFaMQftcrp62yeBLjB9VHNb/uvhue/+T6lKZGaq6fufiudVRoBlz/j8iESIpvLMogZH0XrdQlJXWcxL1g10oeEUN+QWNNARUn9THTwwGHodOeRWANtc5WW8SuZMtRjM/fGKkJBwvXvoiM0psImYGWvMAKETAl08PKtkjmQv8kh+Qir+ksxBeIBzsYLZvShJiBnv98D/z+BamWwW/dRgTcwUL/2jrXhPHMXG/PiEsB/ns+/lZ89gMRbzzquLn3XjKHb36952TkrduI7/hAx1/+/t+Ov/tz9+ILz3Q8uP/OP19nxxtfPePhD/8TdTx7P/qtvGGIvKimB4H9opoCyiRoMO3A8twnNYVFAzOzaHcIjwyQDVVKU3CSzCZPxanhfz2CMs2uKQA4wmrQ9KqJ9DpNSdoBShnsUifIJR3SbkydGUM+HqECfSIJh2UYRAW1ZR35GJzPSvE+5hts/ik9OfxtfTL2NxjQk0Schg51sv4L1GujF8zbzCCwCUSFAEZqN2J6i/j6TNdYGxFlEHxtMminCgOZaYYlmY5WYTCKP6H4RvyE3NBUNahmiNJFUovxbeedAqn56oFXkRRrLPngSgoFNp3LEXZpMxFI+3gcV6dHExxpOCEgvDEO/bodRXTcYDmSTkjS2CDYJWiOwBaM53sRPSCBq0pbSLDZwfD+bTP3NRbS5DVJW2+COPxBmpQz/w0/8rGZZLiVoa7X1MxBOytBA8b9v0wgLiHCg42fNaeVfu8GLGA6OGQp8ShpJSSQmkLUVGSRFxKZdkQ4h8Y2WmdnYgk1xWN8Vph+My+etSXN7L1xKK5mwoupZjPVZTUxdJqNRWwfxuPLU3IQyCBj0S6+7MLzmB7Sv8ETYJupiXgEAYKhfIEVVNv/mBxSMYrnClJOByS5c7myFQ0/DzWFcHhmenrPprHS4EQJpRm+qcYDmpBVjJnlsPovEmA03EKa9SAwFfYCZlJwJBjDQBUPjlw1h8dCUnlrGo8hUUi57kCpurg0ZYEcEqbhvMPQnI2SCslRTpV9QmlNQ5i0yPZK9Pl0xZ4xNXq4dTy4tZnpFxkY4MzyNLqqo9naGMT3CHvPhX2CCtRizImvzHaASt/W0KPGoa60Q6kkVdoZpzGt30pQIQnfA3BvdUrZ/2hlbbAoFJ1bNRbXBDK0iYDnVMaLV16K/spXRv+r//oH4rd+89V47uXndqLvU3m952Tkuje//+WIH/zBiE/9ZMcv/1f34sVv4VlzPq545pWK+xfBZFZOJ3DKzht7oEBramm+s+S2RrBavnMvAZUOazDKnAnubcNttkFlU9FNWnxsSZBZC8GcThEig4QPvLNt07CgBN4NLXTE12PmlMrWkbAzUoyVUs/CAmX2Dc2/axMnm3F56FxFRs88bbAfL97i4o/pjCJZ0EaMFC30idR3rlL2H1U0PgiJr3O6Up2AUkMSKMP6INb0BBZntEGAOkMCuTM3GFSzsNX/HRhexbsyRyDIs2REz7TFrPKpWowiRILwcKE4dgWsc56oRTnbotX4xCDBDAxTkZdL4RoZZltrAmqY0ZmE8zGxh3lQ1+BBbxbhynYVqjI0IMSEaYAkVfL6D7EucNhEi/i5OrqiLM+yMWGpIdWPqBuyI8sPVe55nCTyYw8qWydEuy68vNKifBJ6qA7n/UFFfXoigGkTTvZxKDBHnyfoBlyIY0DQr0ptG57mNY+V6/ujaK6lDURm5zVGn9Z6dkKu1G/2k66vOlPDkoluQaOCue2kTU8cqtITWSRYFWbXYTgUYeMDNjAnP2pMyYUjiyzAzForhMMbinEptHwJ83CJHqmmosCRhnc+yUNKE5i58d1xu44UoUDVzNBcYON9alxXVrhvByA32ekvNaBKc4o3QvG8WQRwBldQTUzsupNnUwcmZRWZhoTTNIXk/rSsjpjLrGjm9Q1RswkO15Uo62Iu4yIWo0MMGxFANNQMINwjqDnddiOp+9t1isupGR8+S8cUc1+XJmFjjmKCJbt8ApbhzAvGROQmC408mbIC99Im1JReM9omwKVreQ0kKyooidJzAJLnC8Nyr0iEqqn0/ATUyiAseXfljImgfWVqGjya8aeWkP61/lWi59brmj61AOB27QWQBm7jfPhWPPuRlx7/ib/8L8b/9G//XDz8v1+LB88/wcTKu3g9la7PdTlvvBnxM3/hjF/9H+/Hmw/HO6MjKEnkLaE/OrrPohjDSPkhlng4PEWMTCf1uPUYWiw51uhUJOefyRbVRhPCN5InItqihVwnSaVPDYXTZuwsOFgZhiXDaSb6yC/II5r1KcE9UbSCUUwAhxiDRTLGRSv0gFwsgJ0AzMDXETmWsqJdIhup4VRLTXSebNY2QgaD/hC+yEFmhMwq5AmadyruJoLYrZGDIWa5xLYF60h9AhJecweUpEC5/KFha27BFe4mp7bVepnteYW2hWBQH0KPrRUo2MOY++w2DEZpxK5BNOXVAW7HE0ilGLinlCw3QKFGNrI0zISDNQoAWxJqGx/C8z3zW89KsOR+Acnl3uXUwi0GNaYmY7bIPUj010WFLEF4RObnzMpAIy2YNJy8WEQ2IDBRGjIfAvhUfasdTT8i9bRgdBfb/mJBTm0MgiQq0Qupjsc4CCDMwnN3LpJjFw9oypBSnJbFfrfRm1Z/vLxSZuOCBw4yUK7RZneWBcWxzRC1ICAlv3i2atya3ZWkjXiaspDH+sArUpBuCrlgpxVFqIerB7hGVxMbICgEx628/JHGPClO/MFAmUxE1sRwbGAgqqdafcMx0QmBGsiTCXrgnD3mkmBEgrEiqwpb8onsnGhpI9FFswoboWDPazAyp0Vkca6dJtVsbZQghtR7Kq2z/BEyUeZZSGfPsIZI08uHgdXDNWyCzHYq/aSZl0uNQ/+82rRjD4qciJTqAUhhItFvQ72CP6HoklpTXDanE1Tgskgx5Ygwlk+RFo3H3TRNvLqlioeLrI3r8/27kt/ZIaxUtQ1LU4uj28dRrAAAIABJREFUsLUn1AgZ+0WrnKYMqH3Kmau2UqXEPdm8BHegkNLnMXuas0eDY7AkKXH71hnHqP7un34hvu9/+VC89YUH8eCFp5yMPKm3zHUTb289V/BNf3eN+f7pP9nxU5+6jV/4W/fiwUe/lTiKR8zweAftKUSlFoNBtHYpL76dJKwKK1DhntIemGfK0aAtzAYQxAPHmjtTGQyMXN5Mln5ajQpOhxUKMBIt1GNo4o8IkAyt6PbRxhmr8kqLL8KTiN9VdEgBnDO7RK1Jx7VBOKQ+5sAhVLAuWmQlwR7JAJS7maHKXTReeck3WQoY0mEs7ZM5Ea1rWBqqR6KHNaRKprF+Ay4IRfKsDmFOHj9GABs00xb/HqeT5+UnM7UFQRkmDSHU7AVsWNtIirFbwnKfF8U/lnMX0ui6pVzBM5IP0Ammw0EvaTDhJMnGlBiceKnA7bUQWTiXnskFlY+gTysnwloR0rX1sC2jgtRY8SopmdCetYXwu0b0CHahtcwmGI1kmB+oZ6yoli7g+AwnTuMCcktXdJ3z7D5TLk8WIUZqJp4Uj4Bpk6z5ddCKzYlQ6r0mLofn1mdu3QfId9qgwNaBjLMGdCOTS+4QqZOd2lZRQmoC6theumJceKlEnzewWDhf3Xt78+TFIRqgyG7rl8uD3NJBzgM6+5uhldgUB07LqrY4B/KVHBIa5nKdrRLnkCGU3o9SR7CmhJIjQxJgK2ZWzbMHewOOfMPprBvBrCTMjabVDhJ0yhkNCe2wNgDqmSQtQD1bPtnUTipF6Fyt8EDKSR6z7sHkRxzw8prOvYPJHTmq2B+YFAKXKjxjwMRvPn95rFD8KdhYoRPehc4WLzuNVg2h5BMUq1XwdGGktZWrjpLmsriAQymBAReXkDQcQowcwxj3tnh6WynXN/FwBtu9eiO19YYWe7N0EjBM6uCS+iHGP+6Ckoc/vNRuYx9g3s45ywOM2cyxAKt8Rp978eDFZ8arX/ra+Fv//t+Nz/7D34sXX34uXv+Dpzvfe/P48ZP94HWNzz6LhOT6nbcnJCphPvlPP45f/Ns3kw99fOtEpxopBCJMAgbnowRxKTctZ7fIAtHxEv1H6wQaWMxoSlPv6B4sa88JEU9r601uTv5wAdtnNE7arLNFbb0mnEZJvGPuPZL55Pnmtj4yHKoxpjhWTJjYB2ySF+nJNEvBafuPSQxtY9T0By5gGAUZot+iyiceyQpeexa571in54iWZu2wGpjPNGq1sM9dqnLHXkWvv9eEYCrsTrWc61FiRhZ9APdQm5DrDHRFBu+JkDTmFA31UQrXMll3Yw4waPfMSoGsWk2gVYMM5jSonTPRRChYYs17cSQp+MOyHTzEQ0gAZUcPVvF4ZpRMsWVVG0VCGm19grZS42SbXgfadYpJkGNCwD6OxZaQGtl10YW5UCUixHRSjbeaspRzhqJDMtMSxrv6guB0NxuSPZuFmuPOlH9Rj2M+KTbcc9ndz8RWfOw4JxcXJMK5wQZYvRgdw0M4RPmYN/4sf1c33BwpZnE70G0PmgCk7FdCYz/XRYwh8/VLDaioOsJKFoRySofFcVaLYELCY2mcV/OiGtCFvBjIAsW+2MGjS9fvbc1LGnkS7rlyG1M5MR4jFFbIhObexDOaeXZpRCyEGnJrsfjRgqGMnl2F8PdjwPi4F8+kd/HyIeIhxnZIRGJUJAxL0PEAaxc8FtCFLIeCR37SoHOo8UBTYaX0vYmUUjVoqC0OuLvVXyOqSs271p9BGmzG12OS/mgPypZDm+NCBG4kUW2Tr8g33galMQsdLSnEydjvoU0ClBa895Yzn0aRxyBMTbVXgCFkhxCU6gPpxmjYGs7ypQQGGmIPCTinzYPZplPNBtwKI2htM88m1EykJSgaUeisMz7w+SrVCcaZeUmn969hMoJYwrhT47zM8TABiG6SvSmndTpSnSM0Ph2cecyLVnE+fuOs3/7l344vffkb8aUnSxve1evmrbee7MevBOS55yLu3Yt4+BBjvftLIefvf+aIuh0UD/rmlyn1x5EIZaW7RIZIaj1o9iIUAt3/09wp303YpcpHjofJOIZ6IOBTl0pRDsccq39GjS/ApiRzcMqdRDS9nRcto4JSbmpPtBybxJhSYDzEKJy9XRZhrEVnio/TQemR5EI7LdArssuxFaeGUZOnMDo/inUWAXGv2rQxpgkX+lmSv5ESKL/yGCnSG2n2SpLYWyX3X2RWYJZzO6WdXcg/HbL9wi1x0USqmNXwZ8cbClTO73b5H2iIlA8QipumWjQpI69SR8SDOoIi0uATf0RpzJr9L11QaCbEcwTZUkVZSgEpOhwhLqosMH4A3k9L4qUUR9XDY/0c9OkkU7NF7O2dK2EaaS7tEw9xhoR5RTQRTaWWPua8v2qZktgiKIC/BhpGSRsHjwWiNbkYltL2JRw85Gbbw7U8duiUA7kGRF2Y6YO8wdn8mYY8fagEnKnW2Br4zH2pwBJy2hNlYY4bDB56G6tCuDmxu8FkT1Aerk/ecAfjg6cqcH+GVgq4Gx7bwc1NscqK8QPZoru1gBjcJZORHXm9Y90ZnoyY7JR7AyJFe/3Jbo195XmD2eIkcIbRZtu/GxISoFJYlWqiKn5t/kSe1XU6q7ZJGso28LGIEJC9Ztd2TaeimUq32HTNyS6palt2aEnJEJ90WzSDG3U4+2dejtVh4K9qm8u8kpOTaZjBoJSKySKI+CuoiJXuQXN5Ly5xL7KeJ+oAoacn2zQb2Yb3MWWJWkgDFOtjRXtUvUFcvpCfQAayc/kdhlhh4uyGRIUoYMb1iymIuVWmGSOGB9PXKBJvYwqLY5jM+S7E8moK1JH3bp554SPfFX/w5YrnX3rmifKGd/O6eTvC8U6vAe6Zwt2d13XfPvyhiH/wf2T8jZ97EM+/KBvkb355yZowJ93PorOtOQXISIIintqohUk2ai1xyFXJrTivvTKD1b3TURlnFidc2yzO1Pye2i9JR7OGmeZkkEmqO2zeMDV1yIulfDmDsxwas3gvQEIalD3SBhuOxawjTu8+8lmUdRRP9pHEDzhA6uJsKrHAKJ7CydXSNrRYe0g3pGW/o/yhdPJ6TLp5s8msHY59GnDTgaZ7xm732ZLOEa/NP8vdVq0mQ0AtgRUC+G3FhtOQSBOQ4YN0AiVldah9a3ABx+K5iYq0HymyKPbmtxJPwx89ciFtvGCq3TGxXkQSzTSUjWyC2F4R/Zm3bw4jjx7USSIPioPdZAJrRqbBlD/aM8LqHRRPyjw4f9zlZkXhjGwzUtpKbaSacgI9WxOu5Ew4akfxIQ0GroTMTVNpR20VyHZ0OfRKbILYGA+yXLmpumFJCksMp23afS2SCCY4gfFwVAE/A+hLpKUZSIl0TxhnmzCRYVkujTFkTUP9DOVezs+rxN8iRsdUteoszXQMtdTGEP2UKxo0CVJrWxzzHpsLjdJN1BymJwlYTXLgCyNsM5ugTpAhWxdT2P5l5VTkQDVKMumhEh+MHeGABYZZDZ/YFE/v5fnFjpmYPZrsjzX1mRisQBuOM9TUv2u9J4ttkcekYxEEm6SCh0510NTlwj+T2Ac+5oLtjtWwbk08Mn5wf+DKZzsBV34EW+6qAVBQJmeSBDaruiH1KswuUct0VJFektaxJiACTKq07n0WoXJLJh9i5rcrLQ3IN20QsElyIa2EqsIceMm76RuC5OzTTD13Zp68oHlIh8A+UlA0Y0UgyzWnWP8C7M+BkaaRt2m6CSUpI95443F+7EPP5b/2r/wz8T/80qfj/nPJQYCnmIw8rTd67tmIX/yle/HwayNe+vj5LbVG8Mpb3rGlOT57Y9UobvBTvST+Y5GGWylqqB9HcEOnc9ufcXK4i9gBqtYhTieBho1tFMkBNwrjhty5ey/n4Eii0WGdjSoRQjOv+neRXXGSV8i9NL2i+OJXxxqj8qnISuFlG4KDAuIkBJRyu10SvcQpsH4tV4jJMTR5wdK+iZESqRqsMyR4ysU7pkShSGnZSx6RA6fq4hCCZp+G8ulLyCXpZjunIeFcRsQL9NMrqHUPPXol+SXNfrr7D40OsQO3IPMh1MRUDenHDdtfyJKYX3eI5kiBUaH7YWFJCceCR5M82sXALLkItbhDmkxOTzIPMxmZIy3vAqrj61pHyVYxNXG0yW0HERT2JdlVWwdMWPBiOYqxeArhvuo5cUlTzRfya7gUZG+5pHaxyML8Lg5I5dLQ4EqtpRKKnpiaC8b50y6wZgrc+Z48vSqWarUCQCIEm6kcHiwmy2g5FqWrJwPrnM4Qy4rafu6p4wjB5Oqla8XSSRFGTBUGdpk7el9yG27TS3gklwtymxolHqP0PtUjA554fdEbckqhMSv8CYJ6hNBzUHHRrPxYuoYp9D5r27880gA0q9pr9dVaxzLKT1p+rklC0N2FCJqCk8pJZQFgVjQV+9p7G7FHQJ5EoyOdAUmRYyFYq7uV4lWB9bamfxlHTc/WoO4EjQINIVGG5JmFXLA4DZxDyIJ1BahwmZR38q2jRnGm0isbKLScXcNKi3tN3u5oZQg8ZLxFNC8rhADygFdgpRI9JqNDvkI6I9dMPSKcXb3cQGLM2flKqhXl9mBWSlDDy+XEdZY/fOve+eIL/fjP/5XfiMdf/834xhsPnsj+5d283nMyMlGRD0b8vd8Y8Su/di+e/0hThuudXqpE8iEL6GtT3Xa35+aVjdmkxjwd5q7zbAdpJKji4nZvk85Tl2wgduUwHNmLu8n5YQPg7stSdVltjVa+P7Arsu9s20vGhscWZY/UMj0JzBGkGypgW84VWk0pwWrxF4GY0wtWPfVjiH0pXllsVlqyXYUAalI2o3kTLTamY4olT2uYYpMLDurQ+kRop7/FA/hqZKdmEmGpVmoGSzIkKZsoBJh5oOf0J8uRWmKVuzEft7ER9XB4lW/uYIlVpbbPUphuM0fJYV3zr6HpuOXyIlyERam+qxrJxhgSLQiPbre/N4RaB7GRdLdsHavqAQJ0DSdApXZcLJ4JQqJbhxBS5L8NhqSp0ExSi2lU7XQY/Pjih24gsPC21e2TfFO6O6eF6VoxnDSFHO+uJjqWy8l3HpR0tCAqtZYI1HP9plpZUryZ/yhBZRv10AODkm0aPud5LsvAFRJ893TA0gouhK4LNWBimC36mcm+ukvtHXUVDVX63f0LqtgvZC0HHvppQYDwhxu/YCd0HRlAF2jkl1oWQewpKCdYE2KUgjHy1iIONDibU2tOVYtc+5hJN0WtkdVKKUyKGVaLE+G3Kf5mDwyE4zmOONfcAZCHGVntMgnsDLaE2wqHmDJORa0ge41NQBGiDGsToaYGLLILEa04JIOx1eZIMO3pFmpaPlhVOl5I2zFUiw1yM1W7Mm/MFfrH7Ht2YmwomBKygQILEDYoT8M2hFYGZ8VqM0W2VUOzvTQwBmnJA+kqCO5MFh4YcrYOnwKWM6l179MUdhZoBRXJta0s5ifrK90f4uwaLW54FOXyGcH739xUnnH05z73HfFrvzri839wxosvvo2r8R5f7zkZuW7Cg2ci/vbfASry8ifeWWMknDROiOfNacgv61Lh6wscWONLHAshnBrJcl3lsRbLaoGB30/BEZ+OLY2A+QknewCj7VzS0tflJyC07qCIaN7sUyPzZkPQDUlh1FtHsMVbUrt1Kh4MkVe5yCrl6FiQN031COYWkL69CBFNpw8lVKlWguYBvStXd5CjSyePimWdykSeMbV7RWDs1i4dr06A1GtR3aIh0KHJmdwe+tpH7BQhk2MUMA0sdarOwVg9WFZu2vrKFo45hlqpDlJsoGcQchB/LJz6q2nni47t3Oe1MEpNKpxzlmQnlfb6ZMNP7W6f6iQuNenTOeapMxRm+C1NHEBD21/LtRtn0SEnrqRsnqOQXhBjwLdFcwBOumSLohhH2owOGg0br65kugfN4kja1vNhymmGdV1R3UVdCXy5k2U2Ou5LnR/rVxZ0wRlVYD8n6V/aY4InxQzMqA1zJOIvM1F829lOnGKaBx7pEKDHnFhQpcZUw/YzkXIGKwAEqBmGplbJKvWpC4nn7IUAiKbLq2wtTklzKgvaFnq7Or2rkWvFAHE4B6R5TrV0iIBReEisCKfsCzRfY1ccWO7p8dlhGg2RFIvxiug9WLcX7Lc4plg8LgkgXmTXIQ/qIkDGPYz3L1hKAFYgJXeby1dfS5jGnUjpFJNPC6vlTMUpDerN5TTsHyWseyHExEhOZ9uMJcOMLSgR4rnIYjQ5HHbF56K1Fyot7+AitUJVT/vGM+Y0de8prHbXJVPu8VRkpgCFFF09SKl5BaGs1BXY3IgWL5hu7Uxup56OIEK1oRaWBYxoCrJxSKmaTXIH7GGbm4Ge6ePzemaPzo9//Hfjh374Yfzxr4949tlvBTq8+9d7SkauC33hWYz1/r3PHHH/lX6C9owv9xH/KT0AEwoX0srQ9k6pF+kRUTFHMKKMvtXz3XlJzD9wuPEEJxJLVgnlE4VMMDkZ0mXG6clDxuXAIYicf1+u4CXRYJ6fxmyFKTPKwkALf6BZAtZqkPxW75H5SYq2zxipJZmUg6bfGtSD1NNO8nFxd0OlxmAAyVS9JQQ+/QGyjBM+cJ38F3FBFXquze+QgDvCDoAkMzUoKwbhpEUeTNcqRATOrXRSweTSUUF7qcvSoVhxdZMWMKhezqb0/lN2SFQ0u9eMRV5W363oOpZO85pcnyMF4+SpbtgyDEHotCh4WqdTGlSx2hdLYhuESYirLm97tHMFty4djEUCXcCAEQ05a23IDObSlJsmaUK1zRHhVwQvYgMtZqmoGB64ls4NV+BoY9LFNG4qSfIEdnANMUuc38+T1WPL4m7pHikhGUuaU6YnNhFhlwUW2wPS4roEOXm0KGObGAYj7jY113pKrRHadrOjx3rQ4VEtY4MRdHSiXFh6/YboawTtxK8XuUBI5YrquegN2uCkEmhDWflYnYVUk7mEY6aqfnm+DaP1U9fH8XQ9a7mzuceHsiXmsLW2Mbvlrt3xoermDBy8mn1FWaQZXDY47T513YFTeLb2n9wqhyaV5f+1R9/JgWv0KgoLwdRyrg8r0sBXXHaRhS5Tr4y7CdqmRhBTrCZS4zi0MLUDGdyPJMVIWg56N9U7HAYYrSplnUTFXECMglbJSFeDxeLZ5ifT8n6abLcNMp7woAyX26eDConlHV9retvU3FWgDLGcpgjGKVJzMeJeNlM1zvO2H330o1+Iv/TPP4qH9c1DLO/19d6SkYr44Acj/uYv3MTvfe4mPvjR2srgd3qRthX5DazJKQ8FeT6d4tIePwncqmUpUF6wt9ptNsTNxUmgW1KanxopUioO71E8Q4Ztk68fP41kc0iOhZPEvlwbKnh4oGHDv9cKRJjhGLsgoBWB/N1ROJSq9tZ5xOrIrC/mu0A+zmFRL0fmdsuI0fPQ/BwM8KRRIZ7UQcKISuRWCRfqOJpW0aKjDfZPVbu6CeBjEVzIIhK7t057FW4ptQkJFRTxqWvK6txyjBDjdBVTQQueuRWHJDha7IJSf0ybuXpJJXGQRypTGpKymYwr1RpbJ+N6gifFr44xhQcqCF7gcdY+5xvi0LhUTkEsjvInRRqUPMCvjWc3AXceailF9IXFG98B/s5eA7mjai7OH7oRIKCKnh2JMqeb2RUZpzIhUCLMYJduClFVtsneld6oGyeNEO9mEZb9UHqkMRT3BDgCELST0c6A1j8CAM+plrKg4jk51YA91PKYd/oUuzhNqpF/MGFS5O5r/J/nQrkPZG7NBga2PfF0QojCsJ58YGkpM8glPOGdZ+aT3Sl4Dk4TphRimrqD6NNwCwFtGQTFqHC/unqTVEnvJVCSxUPe/CZGK8gM8+9LU6DzRJIdrUaQt1qqjceZujG1bBek7YBI4HSo58wgvdHf22N2TJgW2Y5bgLURD3dmBcIbqKTk3j65X/iFNO2P8XVBbF5/GNiWsuHOQZEJIDIA+gQwkdaMDRv/XlhU8p8RmGYffGgMKhyHMvEg1RhQHB0ajUZAG7HOv7QgPQIO86dV//LDEiptg5TdkoFg7F2hNJev1w0vEKSYxpzX+Vw14uUXY3zja/H4Z3/22fjS5yKefeF+rM97Oq9vOxm5vsjLL0X87u9F/Bf/5TNx/1noivQ/5htqbY8cr18jQ1HUEmswKmFYzsmRwRapGMZqJw5xvnO4mrUdE7ZYmVtlilHKiEVoagrykgpjtVPpSLMN0ussqaHRsuRHkl+xeAzBuL1NpDUz/kHdrt6qHw7ecOcy1XJCkfJmRPHJq5avireJdzUOT4wAmUexfpB7UNqVvaVPRpFD0/Cpc7bVD+ZAa5HPD2pdrHuBDKjJ8Jp/esTWb1X/nFSgapnXrweCxpeMDM3FVP7J/8U4p+tWYSZ4lEPVGuZj1F4hzsKPYhUyRPzieXOp4Ip+Wy22CgWgrqPw4JDKCeLMZdp50g0eWU4oq8kV8jDUP9aTKCuMrWA38WIIRRQKb7SohSlhGrO0DEL9CsQ/Bzq04CzjKFUJqeLh7CqmnYcQD2SW/y9t7xqrW5ZVh8059znnnnMf9bz16OpHdQMNNGBeDhK0eaQdLPoHCTYY5EhOItKWE/+IEvMH5VeiSEghShyECI4cJZIjDNiKcAwdyTatJg0ONuYhRHdTQFc/q6uaetd9n8e314zWmmOMtU93FfXo4rOLrrr3nO/79t5rzTXnGGOOaaQKiFMx/UhKkxJj6WN61LnRxATX6uy7ttZ7EVMmw3iU9LTiGec1TrbmlqFlJwBJwjAXQ9+qQz7UgFu3hEp2TbRXc0m5V85+BubZTS1sI6TzyNVKwshkT1AO2h+AxltUW2ZuzueNviRh757M8qY+uL6RRE3jdxdY4G3ChzyUl4hs2w0+JK7cGhNk0w+Qj6CdqvzKCZv1Rzfc/xsG9SLnUpEnnH+czwGlbdONEyEADxLUFYm+bq4mlkblyDGnKziTCFgr4E4Gzncm020UJKMOW4uoj6WYOKwFHAFlIIGctzL1CKRYMCxEKII0iBgM2DS6mE57/jG32GtEAAW5wNFIDjfpVAuy0JEHUwcWo5qpO5/vqFUahGUpyt7BbhWY1QSYEP3DYREuL9zRylfjvxJwnvNUaZVUIg8ZmA5Hs0MSDd2bYUhUo6V303HR0OJVLsDWx7eYna25++VfMbv2tJUPxZv8euPJSEdF7uuoyIE987k9e+hd62hLfXVcpO7x3rJ/UOtyZ0v3U5IzzthBUbYvVRE2yipbdUhVlyssm+BYOL+XE6iM5DTfiZwacLqSZWA8kxG6otKwgsmipDbBb3PlZWAoVZOlA2hLsBf90a7gGKMeeOD5NWorkkGslkiQDSf72pIkbY3cB7LapmJqit9m7F6ddo0Eo8my4O+5DcqqkL4Qid+sbsFkPdxkR7IxMYC+qceK1ZjeqwJYy1WifOXarOgZdGi4rgp6oWiBsdWNpuZcThSTd9NzWMYVGYJCtdKvKiAa/t5J+EPUWtfmjQkIG8CdJgeibKvxdtSnDXRdJSQ1tjCILtTQKaoWgsrCWuYNSk30ElYTKoXHrRAAg/y6GvPS6Pdc9hQoQBvMjGKF8RHaM8uNC71hdHEojLjBbs513ZjfoYnGGMDIwbGWc/JLIztJH5hQBw/ZNmOq0la0+7Tk6OxRDYKqL1wFngCkMxEGXAkQ9BWjQYYeVOAoxlG1VIIRAHsajRUAgxtsb8kcpWwLYwmi4G2ogsFxwfandPINhtgT4JP+GnvHtD5ZNa/1F6HnibMJ8lo4tjXyhCQs0XREgUMinlM+xOG/bGivsc1qpGeykQsCCFUZU0RRBx7k+QmfIbbrAuErSzAcldHURUNrQEpVxhOJXcXXTTaXsPvPqXlFOddw4iLbYiCOEDtVrrJg1zfAQGJez/AqLljKqaMrnrmJdT/vTkRehVcvONB4j8u6PjWtQIkwvQUJ0Oh5k53upQbLOIDkCDs13SjFzXpiII/u4YCt6QtX30M5qLqsyJ+eOz/q/rIPndkxBmIbPNMqpVuS5CyBpggna2Zj2iZ1tdUR7o10/Ox72KSPOG3GjYrwdZh8rqu1g6O9UXOuHnbP1bORjOwdvUaDstfxekPJSL9599xt9pnPmX3oI0d28X5lt6/6csw/2F8OXmjrOpbV0kuNXR33035h4scbBAsJav0JnaekJJLJFe44ETVKk+rRWtnHOM/wZO81CBxPYn4kZ6knSXrHk3mogyw4BgedWAk7NhQIQNhwhmhr17zJgooK927TwAEoEOZ5Wx3yHFgHD6uazsUADPakK813DnbSHTkvZp8arLl5+AbHphgLywQZigPe1IQkwp9QP+XbGKyRHP2Hu9M2z4/wBX5o0/5gAKDqyuS3UA4Pm+ePGTflQrLpL5mXkq5xJSbWo5iZhMOxq1CEYrTSjDlPk+wZqW+nm6IaxtfNWVy+ehaET0gfTN1yynyV85GIDrPS1V0V3TIIby1WmkpZGpMgJ3ZsWG/UMZd3YqjKx10t/K8aIRuT2O1+MCZqVfsqzfUpmmTzPX9hxZ1GgE4FOZbC2H9tNsMbQx41GymxMNPy8WMLdBaNBpJAJ2dTTKUgPOAWWAlT1ufcZYL3jP0FgMgL5udeCgghNGifxG5qFSXDvRnHiJMm02Cb2kPQ17AXjcecqJTVBKgaiwmOk8QrwPQxfhh7Xkvwdc6SzI19WWKHh2VscnwLH9k2/lE0K3toFyuWAnhyVtZGMZFRCeMiNxm/GJP5zwhaMdcXcWUTt2UkPzHhXHHbCR1nyhuoRA/KFIuqc52zSvece5NMHX3HgvBIpU8cBeeEsEQ4pNOViaJah0PHhCM5SE/UDMzWJr/TS75NT6L+NFnt1EoEKsvvrnu1pXYMgarW0yoJ/hw3qsw2OZ7Hzr+ZvH9Au/FomyOCSZ5yF5KJqlsfVUOfrbYsbffAvffbzXt3dtd9fw6mZ2/kl/qX7ajI//3BQ3v6cwf2yDtkQJ9YAAAgAElEQVTPBnjv/hp+GRq7JfafPtvtcrHVlzgo51wF8ybT9FGnN+gjw1i3oAOpcAS2DNRDYrAlFLtykVAdBf/2ie7OtJBFS4MTJlKWUBpSl9APK87AMMVkydZEjHAOCWwH2Sc5BEFWVaDXwNRszI61dAP0Lt1D5+kRtAuaW5cVOrvLNmqlRkqZ/eRGbkum94SQRnaPnjCKNOZux1Vi9jVZf+O9MkOpP/4eOrYEJDlFgsvo6TNCskYpFQdQEG0swiI5tTBL0DunrDDioPAqXxSMWCNyD//qAid80CrjEtYKww0XGYmhgUiHMX8FK2p8i4qHtF5gRdKXaVtlDTToNtxX+GDwWjSknOG88Planyhd0HYOqp+DlBQamHq1TTU9kciY+gWs/zpxmxPUY7cDEEYgMkwLWjRqVqtoB1uYw1PL6+yWLmLdhAKWoaaGCfIxtYwGWwZvhPpJ9N/oLSgSmLP2GvqSXRx7koqCADYLopCgvTWZ+KpjqyF8IJ+tUz9M0veZKSGuQ8lbe26BOzfsoIGTiXFrrib/AkCp5cF+acFr264nNvjgGdZfRs71oVo1NXsOxQ7WjdpuGX8aXQSCHS/BOhzvwdUyqhMYlyErF2vVuEmJQwBahhx01CArQqT07lljtmadzb5uzpAx0rFYa5N1Nd2PYqHTaak0O66QVmKsFkAyEC3U42BkDJModAsQ5MROSKInkAjkLFzxxVWkuf6A6r6cLTe0i9KMHjYBuuho9eiKqsP+2BiK43vgodSU9EbsS1lbcn8VYVQhRdlk01mgMc9V5EQ9/xra4fWAEMVVBEnGV6IIfSn5JveqK0ZT9wB117STkzUPHrzv9L1/6X2WL/22XbhctmBv5usNJSP33mP2scfC/sk/uzze4aVre6+qFeHr9JQz1/efMl+Pc80ji40RxsaosSEcB24yKYOYViJiKIBOUohKIULfoS21NAoGIQSudBYaOi1pKc2MZTF7qpTqRs3xdTpHMKpRx2m2idD4QmS1I8uGvrHagkVOo8gJxoFYnEPg0Fi9cliZT5K11NnBigI/AtihMcGX+RfMlujxjXMUCHJyN1fvQZFEjNipIyfByEOmoFxSk9h47ioAU8ewqRk3qImPQ48RmU2Oxmmk1EPCbo76uUZpPxBI4sjGQDuLN+f1yfVWV+nkuNXUsDHoEEI+fgEqF0FqrqtyUBo8nI2uaROPnphJaT59gnI++g9nQUNto0lYwein+4ZmLtOHJxrCmfNQJDxXMZUg479C/fP89aL4qzcL185qlL2bmskMaVMKseCnJJ4PRDfOFF/GuZOd1DwrDBsbD49JBdsnjN6eAAOG7VnjZ8xmFu17aoMgdA0WwUvFGMzRpLmVqUj3eYjU2m8zd6zmtmI2p/5cjt6sdsBzWgocYn0WA/JxZpHDmqZRzEatsrL/qFLFms0CAN8UHaiIQ0SIKXHNeQ+QPHFklhYi1sTEj22+n/YqU2l+QIG005iObuwTgFSeSthXIyqQoOaSc+ujoJP7jskoGt9qg8MlAUMyRUzWth21Pg2FzDZxpU1wiPLgRqVPUgs1sxDFN9wf3xiMbJIcaN5w9SEGbmbiKLhmaDCojWfsQ/f+7G5jesZiwk0nC0VgXKT9nqxyNMTppruk/ivZ5fP6t/efQj2TLJCUvZEi70qD/v5na7ODowOLS7l++snH7cXrz9lh7rPz4k17ve5kZFA095j91u+ZveNtZ/bII7vtNb/qq+2a3byRdvFw+Uzb2W33PIIYIWZUKE4hgHPQh49VeWA4pRGjjLmWbArV24Q6TFI97b9GvSQDBHEzDZwsdQf9A9X7i2zbx0Cv2eOoKRDbsWmc38A8h/0d5Q/uGJffmNKP777W5muwXpS7pf4HFwJ0tX/LZROXxU0SKyfF4DNYlIiRg+ByAoNIdGorNim0FKV96l9NMKoxaGxqBfRoOg2MJnQ1nXhqWguLYG0S/oD8+Ye5UUJTw2weF8MFI7SENVDCZ2Tr3+Yqg4eEbySZNbS/waB+w0lsj36kIK7Md4vCp/JYjstAqMJy5sQufDKcphss1NEHYq7UxqeWb4wNMj0BAt+SbfKykgnfTNEF9uEndM7S+oruEEPdYvIadtNJmmPWNF0oecOTinwwCboLocOnNgRncTGzDwXCuVDrGJZ/w5DC4AALzRfmRauDkxWrAr1v7h2Oz2T1ARUwvgsTIpK+TKFEGhhaXMcUCBlBNVD1pF5r/ZMl075iolV8CaUaxOLZ2sHzf4MVQEbhqJFh/xHLpKXYuj7ujya7QKI4MSfV01QOcO2yIiYqAiMzZ8dSLWOYGsoTi2sf962xw4Yqegiy5+RH7g/McdZ22mDGM5KgEALLGaia4LfuVPg7x/TDWKjulqyptRHgAbg9bds0WGb00A3QAzORJESgHeYmADC8MVXn2cJ/ER7DjQnnxOHRIvhY7I2+KirOpBlZ4FHS4FJwCtYnk93t/jlnH72pnqEYxw+xQoe7C1PIaXxCttxmPGFmrg6I/iz3zc9u/d4f7578o4/acnRmewcH816/Sa/XlYz0quXyZbM/fGzPIo/sb/3NM52xr+mVZndurfZd333Jbj9y+bkPf/yl06sP1ggVBM8RN1Ysw9gc4EktExZn4+kgGoFj+Vnhg08VHkXBNPykfEGvKn0kk/OTa0hfjSVyjjcQoWoY292VLiCUqHoyY8cpanEe0KxAIcNvEClFbnL8arWJEQ4WwrxGO7bK6R3CO6ZeXrPWUF3I1yZZxBOmSR1lwJbSMVVa5uKlyBOIWhXYxsKUnEMvD9vIIcZs2GS7nYBXKNAT1S6dlot8KCC3PA6r1UOAP86MJAwL9UPTNHSIiTqGAh3cnC5hlIGWGWoaKCNqAVVBkiR3DBytducGoUVMt1kEdYSW+g9yWXSFdrBwjT9LkaBxrFZV2KBuZnKaSU4BMzrrU5JyvPI5GR/XcPgP7hoUVP/xHfsvOMN1cFg7X9zUWDY7ZlU3I2QFDXN0fVnuBEYRYz21+jnn9WNyWXK6DhMBK6V+aUxqzwzJszoGE/uTQgeHGYzz8E92HHaWcUXlwVkAKtq595wDfZD2qX0Cd5iHJw+cWbHS+crZUdytczi8hz9VFekiaapiSFUmUXZ49EVl5crVzswz2KaibzFbbUPmhkrGZR7GBlR2YkB3ZMRNwfoIhOVyEiTqRFoCj2VTpCXv0FhVo/mT/KZ6PjQnzJgW9/deh43utPWwjXubxsliS3iRT1V3cdtiyeDakiKKRksbJJ84oTULYFvdEKWmro+wIwA0RD8wJTEz/HpQHLkFf+sBdTUKpGSVD/igy5/LKgjy+6rOJriZQelnLTUFElN00rGI+zMLI7SChafypznOhrgEPr1x7VH4o3kRrnQRPWBJuzIk9tp2FQQ5IUB4Wyu3IS8gs2EZd+ZnGYGkfj4uHIY99dLx2c/9j79z+tJTzdrevrnfeVMTEdsOyqP78Z/1unTJ7Pr1ffuFn3+P3bxxYJev7F57IlLPwF564ZbdOf4m+7b/6OrxhYMn19wdWu6h8YAk5jA/J9A794kkQBjZO4EKwipwGQNYQl0dp96TpxgjyOsLzXMWbTV8z4VUZWgnK2WxEtqhti2FM2cv8Xh3ya9JkWZ5mqx0KWScgrqfZghZlLxvimmDuj51vOsrufhk6ClaUu5IbHZR+mEl6q5AhWMf3W8SOpXR+eAi3TeDTNmhw9LG2dy2KUx0OIimwSYupDOIAlRRHLNeZ+LP54Pth+A9BFS4u3LUlaU+3q/B2sfohzHE8LlZ0UkKrkIJNAgtmPaUGUkqzLLa6ZDrgOMaOwqNdnlQVAeR17aCQmObgnpSmZ0oKw5UjEmNivEQJ3C8oWWItafoIfNpWwHUBAx14/Op4wHw4lzDkvqRoJI2wzN31RE3ElXmygY5RV0fpqIosa3w3MjSbUV0aHHnnDl60E01L+xXKPOaoJSITUGBPJYpjYFRHjCXYUc6jzlCApZ6ByEsxM1oL0utFRvfgFwK/N4SQc6xJFMHODu/eMQ0Ah28EiUChVK0osg0LXN2jAKPVdXEj4VUrhGh5f0VpQGrFAr7pSQaV78ITGURbawI2BaLQRPVHbTmPAjYpKVsC88/44tomg3sWfNA23xwkhOj6XnezVSiwSN9npTqmFKlTjipiU3BHjKyVeMn1yBlh20HumaIcKhjoR9QhLL7TaygpQhzjsmH4hn5rE9TOWlqDffDIaoSroyJXc+YfYDWBBeiwnl8Yq4nys1sei4ykEMi8lU4MUuSHSCxDeTH3nKtuDo23IIgqyeHVpz6RgHZWg3l6rRhrJ954ri1O80uXj6RVvnNfO3tdvWm+/tafy+fR6TZ3XebPfbYvv3+x9KuXr1p1269zm/jZqd30n7uFx+zi99xcHrP/Rfy+Nap5eHFLMcKuvg3xSQd2ThkMzimgxbSjA1Bz16m+ZU5z1HDIqwrBq+qYsnCkwvE8kNXpmbHw/Bs8/w5P8HKhg81BDhE9GgIBIOTTBmvDae1tDXmHaTTTf1bzLk4uP8TpebNlGGpuhrncAKWVYTgx8j5FFYOCmQoNWrCRp0jjmm1LXQYMM3YFNe2iSqyLVYTVHkT5vzim5SFLrAcejWZM5+4dpkZ4FhmwknZALKcwEjU4vZrwESi5XG8x9pyI8AvNAA9n8LybVr9GgkOTZtA8dakd6ghrjMyISFJkFZCWnJrGcnb1GzT/WOqwlm1qOOZjZdRPvtOpKnyQadzG2ecaxhOEhti8Pdx7nHkbrmzSYuUW25jgucrqqGBwDR0tJD0QG968KZWIUrJb0zdMeEdHX6kFLBzyO/hq9LFFpa8JahUxsDeHshW7TxmMI9CjJWk4ovUPgb71vNRn1BhNpK3FECjYdKjeinboOq79M0BT2DSlfYwq3DU3d5Q126ef2JIggQ65MKWpljBRJIyEvZU0XZ3O/HGSOw73dIJEjRjy3j5r1KjrkUoCHciC+fRI22yhOWPchi5kcDLZUwYytkan9KjGPbh1IC0zdbxSFoTa4Qpaeq5NnKe+TS6SWrk8V9OsiyMbS/jTkcF/Q4v9uQKokObD2N+0RmU8JQpViugho5WMgXKBdxjRxoCRkYmwIHuZMYGXTLKBUihI04FF/1NeMWcKN7gDo9cP2feYACrHTy3bKfUtZukms7vP55hztqUCdT8yvyqsYd+91Y1X/c/WmLvTjs7XN//V27bB/522nPP/TkkI2dn9aZHR/W//b9fDiHpwtl1Z/b7Hze73Z600w3A/npeu71mu9OdXX/xHe3e+8K63cjiy27XzvZY/bpp4LHyZOnvq5T1KlZxZBu7HatVJ2lfDg2SDk4oc7D+pliSQ8cLmnZ1oLIgF72G5sjsrg+G1sBsnP9WH7pXkk9WsHrUer+SQA7JCVYvJ4Y7B6U7W8jgwuckfkaALOgUXUYzHZiarzQTwkkGlHegMCN86+CpLLyjKHIN0aq6BSbE8Cc39O0yAWrb4gdCF05blZ2Sxs6OpIzVzfiJFV8tCLCzymPkTptiOCNGVvRFmWRhxBhqvmJFZS6qUWwbjADW1xU1p9spGkDHPYa4lEN5ao9PC4AZBAjWjIaGxi4wyTdx8iCWQ6mNMUgVPWByJt4DiakzWc4xSoh3HNYbo4shAV4JpTL9bgliEO2XRtNQklVgxWPMxS8rShCbdbBUo3NRhS2mmNqmY1gLLBBptjEoitxKEPs+JwzEWmiNoj2Hp95YOaO5PJM3fEO/gHhwuDGxCJh9LoAuEg4qRJVgm7mx+CA2PhnZhM4qZmxQNVI3Yhg2dwTCGyfoYn0XZr42Z/FCNFbrNbHBMWQX3yZJf9G1CvRVC1FryjdbAVYRwemD4/5W23bIUazgkwATTbhRm19a6s2GyKCh6ZDUOs3JcRM5axJvMJZO1HDIxrC25GxWj5ZKf+chTKH8tJmx8qZUa/qmioOvFLhOUpGFQYaciVFYgIqamqNsXHpS7Li8uJVUl9Vit9uDiYcVwTGef7+05squas9XtWNOdtPlPMJ+dcVRFBW5YtwPe6Yr9LHLbgTVosLmqN8tftemKwP1krNNogNYoF/gEr1J10ZpXPaP4/q7CDHQzAEjZeOcNqoY0SnsSLNg+NKD2F7k/sGRPfvC2aW3vvNk/7/8z8z2L5vtjs3e5GaaSdPwxf+OmJrLseSWSlQ++emlxmTtdOmv6zUWYNuzX/77v7u+7wPvaN/wbV9veWJ5lpxymzrQkJAyvC0s1CHzsEJ8vWHPxAYUIWja4aVk3wrX/Jgi0YbwqunA3SJdLARMGLrN+OJol6uSxkPJRnLsI3J9tqqlT10jSdgSZpV2qWFuFFcxfM0g+QtwT6zZNtapdY4iGKUgPnjmFWu9yER6A11Svg01v0GxkLHRuRjirstofNlMujIBN3AIMWKawwBMRVaCR0L/rSxR0W6H/G/IaeHyMtQzNOIcO77huA84+vdMCnmYWzlbrUZGt3mJfwNq50DvcRbwhh69bLQJDVaCyBSyrB8aUeCoXlsi+YNNwQw6qnngU2niwRvqk1CDOAcYiJ1XLTqH2ADyTwSK2PwWT5GE9d9KTZKmuDQ2ZakHoqZzGspS1lhezeI5aQ6J8st32NisyoQGbS9oSh93SlZ3SYUfD4NSnmbj/Ny6IzGZpIk1sxAvVxrqAUIZDS46ECJz+vOODRjEnokyZDFF8w4jJ5ZnFw5i7kDgK4EEHB07NC1n3pQ1vwZ4axPtMqriQWn0ZC0mKgSIauRaGEhGAqkS8lYSw3EyFMLXTAjFppigQJKiHWeiaqRyWKCV3TChGZVLRu5Hvmf03ZO6AmFttlOAXANQNxKgii8JJSlneGnQFnQ8OTXDjoHZDgsTGQW7hnXwAkvAAX27FNgln6lavQUpr7qH8P2qeNOQTBHFYOmqRAx9g5YijwMSEKiE2Z/nVC1vmlqC34q4REO/erXkg6cKn1tZ+ReL6HHEaBbiRFlG5s+GBaMNzTxpUHZP4XEqdp9bGwRHiM4S0+mZkHPk1KCEG7KkETRU+xrcrGWBXeVA11FxcS2jpFjs5vVTe8tbmt339j376GNmzz6bYlO+3NcYwdeWLxWw8gJOTnSAjdeli2Z//LjbH/5hM7tzZs984XW00Gxfw+NhZ7du3cibL1xtvvSDc69ja6sz20t1yzJNUG2Nqkc2G2PnjCyZk1upOMIR0cs/HbpQLaLAC2l8BGRujklqGqQbbwNLHrRAkRvKZ5tRgJczYi2oWCBBROyscQlItEH1VKkTCcxi5K+uFttGTLIG1QyPk6wJM0vSjnmqmYSdLfNcIdXF+2PT9DtclErWiOCS1xpcBqYhD/o6GAc4V0auQZCWqRaG68PsZUGI2zTv1O8vssxi7C7gH4+scs2mqoqJ34S49JnjLGvF0vI4LXweUgUoJrwZyalCkJCAzmaHxo5SLFjjmAAN/+vN2V7yVaSmo1miElm2KePJNUaPiXVMRRAFu1vtPcgzOmcDlZnyDhDDbN/J0qOM2fvsGeYYjjL4kD4D/zGWsoOtaAi5Lm8vTtAy0cd1/eIruVqoMazEtZhwxyQo6RpS6R5VSUCLQ40TKvrUs9oNkgPrq1XQrIED4N1BzIwx7gisKCQZbEjAlDS96uCYiu6AHTgSTad8pIBSTvMjcyI6mNEAJB9RAU4xGiXIWrQMFLtzyGcSKK39hQZvpydPjbgcLO4cKadauBhUbNXK1YN9V2qaqARgPFH9aDFVEMiksC3oGFgBJC+KKt8gOcPrx8adx3ABmY3NWoBdixEudVBMCkQNYKx2OJKPrVnc0Q27jY56ZjT8Y93siI8pewPtEgAliK8LCKJGIzpUba0wlUZBO6UgwYyq7r/MNNHSE1S3GNf6xKUhCiLtlVDyYIS65Eea3UCpcFZ8Qz1QvTuVngUpO+Wo5FrQE590vOQa8AWGdFz49Xkhn8DyFIRnAy3QcI9XwlFD3tz6m/Ub0mW8Z6fHdnl/d+P62ZXT/+f2t9rnb9+yl67dseXClw+N9I8/Xvft/sMbL99Nc/Gi2R/+cdinHg87ulR/duGC2VNfcHv07Wd29NWcL/v6X4eHZp98vNmL1w5y/3Bvd3p6auEHw+etgYRdcKRlDbYNhkrm7wmlFwYwF1fh4lIxtHrc9kXfE9s0MSZPyvQGwiAYW7pcsRnnTcsUMYY1CDSWVAQMOMswObEbIHOAwjjWs6bBlksBpzk1Gjy0hJc2P6WokXVU2mSiA7MDmqOEU7sJZ3Wxwaiq0ppEUPgKZDaTkSQvW0qyUT0tXTnNhU38EWS76q6q99BCEINjSTYtAzIF51D+k5H6kKCBRm3cYfkqXXqWfXHtNE6mrA8q8LJgrFCWNfupZMLa1uRb1Xdqw1IC1E7UFI0APVRE7lSaVW4aIRGMJ0H8KPFBpxNKYriQ/2awWYf1QssSUvDuzfJP5ZHQfKBnaFhHTGsEDSSjIKHtdLsE/LQ5axNAD3ij/l2XjOpfChiWA07eEFjoRSj7OHpEUgIsGJjtJklr8hG3QpLafkw1WGPVSZFDDlWzSmuMkqTj45snh9X7EDE1an9GvrniMA25FtAki/JwJzdOiGPKqYarKRIZTOPm3A+lEgYdNmcFM7CnExIyI6LvNOCiLsox1rCh+6GezArtEYQltf+TyVzSKajGVRRCASKtua5gPJkYuXhbcjNhcdpxJtAwLnuWx4X2FACY0i5jVBMmqiS0wXW+sZZJXjYXGBbFaG93DGCroFNoJNDC6nMO8IsJJRUFvxyMW82j3USc+EAYrQrRgEShHQc4WyMEQb2xqxClEZpc/WtXps5mkh+UQKv1BfhIfXBNqws+iCnqsIpGVfrERoJUPVRj4ayVH4/IRdniDCNebpV9myxFWo4OQ/TYcZWQRIXzQCv5UKOt8Lz+On+QLZT0cCQJQKlF6zstsilJkI56aps28EzWMFH26/RhJujss4BkK32hKNFtOsstY7Gd3rlp+0cXb+7u+Nk7rn3cHnposWey2d6XNWa37vbpWdiNW25fdfWll09Gzk7NvuLRZvfdnba3VwF4bWbf+PXlMWJTRfm6X1cumX32s2Z/72cP8uzs6FaHJVprS8imeQoJUYrAG2l4IcZWeFSbSkZUCat/BN6EaSAOPLTi08Vw9pqGyuxBzFKb6Sx4McKGYW5hPy9mIknO4TKBKkEHkgnkHuNvG5rbnP1aLZNjGFuocW0zkRJ9i2MpNaIgiZK2SYqB7h0jFZNggXACCrUllaOAXBzvmvQEYlNT+YI3NfHZjG8lywLWQ982YjIURhXr5WouduAQ6Hdw6i3LUIbW4EUWBG1zk4P3U+O0c5p2l6zeW7C1jiyVcbAKBbrDTxA2mkM/MdpvQCADW3KI37SXSff1KF2mblKx4JToKD37dueMxsVRe0nZQya5kV1jxGN2U+ZU5VEFOgST/mSjUs0uwO0l12msCSptpOCUAathaRSkx6U6jvo2LPuyqOQqChO1eSNPMvaPTSEzW09iqL8lIaUtuvq8KBiqtkH57/B4V0dlTR31kivHOgr4AGBAR7CCqgPoUnKKcyNiyaqiTr2VdsxgRslulRIxqddxcPbjsWlQNkfWUCzgGBtV9YUDRIM2g/DcqJXGgAnHjOZkyOj54Zhrh4hTNoEFHfSqvObxQXwUTnFSpRNtgj0qKJJ0Bj0P1W4Bw75xci5JmZLRwghcZEdsAlYYO2OxQ3Uku9qhNMJVtwaSjUHDtfg2yi+mEhypGbzvdFKvgWNwDiIfOW59K3Sq43Q1IVLWF+Vx3TyqmQ1MO7hN9iylcYJU4RkOj3MOs2FCXn9S3EVhywg9BNqTMrngLhu/jzl+bF3iflxNZh2BPblWlCW1wqSpmdqGDBNxTWMxDE02aEP0xN1H+OypNnn0aLOutC1pC5EB2JaNu+V4kxWqOCgZ4O0zjXo2FlA+xukUthWYdVqivJOTE7vn/ovPPPHJuP3r//BZe//f2LNrx8toeX2jLySGtp6Y/YX7T+ziwSv4jJztStB65QofidnefnmMMLC8oZePIb323d9p9qu/kbuTO5efaq19s+/WJXzZ2bI2jKRbChGfFlnUJwGSohQbUBaYOWi/ILTwKlyNbXmJxkPib7M/hEBAZRk4gAe/2GjzDRNt7KMBUABHZ6GNGQhVPxVs3uADUudVYpqJSxBgU+scrOiicoPy8KiNHTMU9QixsOYCkkGIsfDZQhLctnUan5m3Fbs5YEEBLTpB5Aa3SYHtSB3YkND60IWoMXh0qj3XkUbD3FBnD0GbxLGW5XEy7vu6MkOsY58sDcWF6AnmEQ37+UCCWbt2VjT9+sBSBKuYNtgvkC6xND6w4HaVDiZhzZnJ9QNAQwF33N+epi1qWC2CQg4uZjzkgo04OH5xkFLVDD1D1iwAaTvPZ5tlUzFNJDdiiPpW2ZZhR4rZ1a2akALzPIYt33RTLcK74vqQAjq7I0Tgu85l3yhpkCPSB6qiXcU+JmaSiJecbnRYSsAtmkH9rFi7lU5SvDGQHnTmQ56STFBRX2zAfi+IZaFhCA6HIkowfCzUZsz+oTEdpmHw0VJDTPvFLOzvFy1bKc8Uf4KYSApIYAVfAWGpvEuLCYrnHgy6T+ayabOYGS1Bn6E5NUpj+xNfTP7KEMYYW1lYPGPJFAO8BLRMUH5hIA/ccLhQDV08DaOQeeSJLaX1D1ZCzxFXkBXlk5BoMelIGFTalPUtNWID9o0qzxrhCeQ8UQSOlXZ0esYOWLn6YZyC2YKo2pCBRU0vJiKB/ytSkRkVRngy3wOnUro1KONqN7WNC0G132B/rZv7k4SDZ/euMZzFBGdY440LaCu4FsfyS6Odfj2BlSZUag8gN5nI+sd0AGr/KlIHscoxcbmGYbL1AUQbd2pZZQISb745qTnVlXx2aok4IVja0mKu8Qg9+x5xtp7Y0cGFP3nggQvX/s9/avbB33Db7ZrC7ht6pdn1a24/8ANn9q0/aldSDckAACAASURBVPb8i6+QjPRypItTOgrS71mHY156ye0Tn9i3w0Nx5K/7xW6dtzy0s0sX9+8cXbj4B23dvT93Z3F4YW8MJhV5SCGbOaWCToqWBzGB1UJXXYc7EKiiW6aVbhm3qrxVw7pzqP28uQMsXIM7adr/FzwWU0clC3CX/RhiaKRJJV8ZiORlhbOuKHEC3ZS1Ppq8gdlRiv4AQDhodMvpbciJLgaZP0/Q2eoJ5DNd6V0l7FS0h+mmENwzi6kkKLAa5pywGe/haEX2FwNICUXb+kYr2qrPmQY76xVjp5MHmGYYK3IUlUsmgtgbDoe5avJgrTRMugNKNJsRdtqhRQjgLxAewyUAsTgQZq5qIJfqYc3iAl06vTo1R6qpTKpypxLToheHqrpEF7/m6mRZRhCXj+BTYnNnOPV/SsaQvTTJFyqk9n9Z0DLMcrEOlAgkBqMBkRAZ1EJjOa4bQh7AB1zoBv7hNdA26N8IjxUq/6eDU/C0qyS+MZfnvIGB/KO1oFHiYDq5bJymjURf6hDG3JMqJjH+B1u0f6GFLSdLzOfIcqI5u65hqFAuVAn5Mb9/URkA1LhlhPJtCt+k5rs4/yUbLKMcc6twqkNpiEEFNBKRuwclijC2Te40BgUIiM51RmADUWg1eMFxHrfmG6EDh6Ig8RhDN7g80W3jhYImARavtlenjyv1YK7l5Kqcaoa51G+Kz6NFYCz0qAcu/4ISK8WmsUlMZWGFDO9jJBSZk9pTS2GVsIGrJheiLw0jLvX95OGCEFpEHwgORw+QKlLOIEDtPwuZTdGGXkNtz1wFUJYmI4hrOFuUiQCzgpudBo6hTkizGg0hswEqhWdA9QKRmRtNRZW1LMqlUKkU4hxUKir+J90/yl63caZPHVds88EzIBYcBLpMEb46q6wtfWqX9/F4zQ72Dz91eLSM337hud2XkYVsX4t9719udvN2/dHLJiNe48Gse5D0LpplqT/7x//4in3hCwd25Yrw4df1Wte03S7t9vUH7M7xrfaO++OPIu3W2W69khdiHeQAKm4aQIKmqY2KPoZpsDv9DCCBB004lxK7hJF6QHaQyWFvNcc5h8eXYzDUULpxbyM9EGmkapcFJTjsaUU9pzACfVDnaxsKhAA/3AjJc8wKOQ0kH2XNVXO0DFaTU7A58almc5RHEjSCZLF3Hml2kyFoJefbzK5M6co5WY+8K/0otl0Q+q2gyLya57DR8NdkYz3lxqEmQisPyIX3FISNBgPXeTKc5ehWvlKKgahAB4RxdI2JJqz04QAHJK7mIY++BZ4wTRIKM/r300YGN8WdwuUvutn9VqwbaA2KaeHSJglmK+rF2YUDc0x+C1d+zAQD/eka8zcUQ5DlIg2TsWW9AogAB19JPIpvvHD8EVYpOuMNZD02RFKZsrHqdx5A7AvHFJVkfEAyxYpRQo3pU0ZTm1QTgQFQdljnljlnpwIw4k1GJTiY0KUNDWVTa4SRNGLrkdqJTdYvbPHZ/Aq1iHNEQ9WZnFytAsdcA6JQYEaqfK1sa8gfEXoE2c+HKE1MdV9A7rQRvQSx9uFM53MjuqPVHeddSSCxYEQicWQ/lyguufaSLxTYMhhVxpHrio9AVTLub0wRBh1gsTeWBfpXnrTVKye3CkxdFt+IMoVF+mQ7AHjGyqbkrNF8gSN7mgiw0DSXLWLX0VE9ZJXk48Khn2E8Ij+8js2OMEFWdPxladEbzIlNoco4rQayI6Og1PTOyXnWZKOR81HEJ6VLEsbjrP/xAOnXr+5FZHlUscDzsNLOmsAAbKRB5DXcDBCgYi42KMYoXTIg+SL3bDJoIPad47Ckri1pQqBrMLOrVvvvL4vluju2ta2d1P3Tw6MLdvnuIzu6dPC6zv2u1rpzHHbrTow1NXKL22E/+qPX7Ku+yuzTnymd6qtKUPplHB93iibt+7//hj3++JFdvPjGOmkSYfuBB5+2k+PFuiCmtbbuHfS7u1uGgiFAT7dNGzmGRq9pGia+5TnL4rOhvIcTdpcUmROg2BKNNPaWGhAUBkE8lAVT2wcX0mAJzNXJ+MFCX9GjenQqqXeJA3y0YMzMAglrYeccbcIVlJUeJxUbOsfKS4+7Xl6dJYgyGJUQbi4TJkxb4DE79lPTkDY9Fl5OcGeXWoYKAtltIE/ZVHCtuoRS0bGgbvZZFn68Gb1dd2xhf2c/j1GfiLierQe2Ma9w2orwiyRtDFKr1Zyc2IhJnP6EP+OxaUahAbGe0smpHCUeTwK3d9VwknNlls4R0eilhUGZpOzwxRwVPioiR7DBc8RCZrHulMZMozAyV4UMrHOyaUqsNhqdk9ZOxt6DId4Go1Djj10hsR7bwrXDZh71q02GphlJbYfVtbHGb5jiqwFdPtfRuIWLXJKna39FfVm0EDdO1bYTDSW1gIzepvIQvCiwrGg1ULOF0RG7ovyC9CNnnqM9TeXYeKMV+y99Ds/MaieoCnbE+TWmYbrmF2n7t9mYAOsguhozwmiwveecbg8+h4P8DafQRIHA15AORZpM/TmjGYHeyiRDaSd9SAztEglRHV/soIDBDqXik38wppiZTLNoGUtpCGQHVPeoSYzd5nNxNW4wMA8uBKpDom0z+zBnd7Z24/RCS0g5CP+6so6GmQXjay8btICTxVPzlbXMbXZdSexdwEt/yosAKormoHJWjyKc5lxlEPUgQayt6JJGw/6RyBIrMyVxdQ2wH9nANeTTmxPW5LJTJz4bGG2DoAkAIkRDqlsA8OIJcp87gsA1sLM+C2+3NutNJoeX8+To7kO7cs9Fu3zP4asd9Xr1ROT6rT27/36zb33rmZ2emt26vdiDD57Z9/2VnT39zNyIr1kPe+uW2Vd/9al93dedvqIx2mt5HRyY3bpx027cvM/uvfvuT2Y+f9uj3QO7jhFG+m1fK2dHrpjY7QsWe2O9M718a3IHxKhSH6rWmehjoiHYcaKIqxmA7vgYwoYQ4ok4MZRgqFQQt8pdXo0naA/GE86NZ3H13Bj5Q+J8hOhrk5rSgmpBhbbKy33F6T8WtQPmMqzPCxUjjVtCQEVohNp0N9TUhEByLyunKprbLMZaCIVkHZ08LzDKzjVZAY6WlfZHavPLnLmAUvDIU1qwTS0Q0WelTXOPjSB+znKoOBS0Wiv1HlnR2qauWIf4FAoITsqF4BYavJu6Qgy8Uknwq3/I2wxrhILTbENkOp+2L5Dzzk7E1EwWwq+Kvo09sEhtGzQyOB5TuuGGrAsDDTedf/PjCeCV8X2j9pcX3jADgwHdmaEJvWdaYBiah2ZFqKpBq9b926xvmmvVvcDYAvab1pdqKBbIiOH/N2JNKCbSZvblRXBWFA7LTf2H0VQ5YDSjWdCAeUexEjMNJUPk2N9qvgRjwDn66NiLgoqDykgsBiIU5aVSLeSNUm82fQeYPrpSaQ3UpYZxEGKpgYkNotgonyBOGaxl4sLkwX0lCasAv5WywWAaNm42tQucQycNpTEZc3TfU4gGpTrRtZjkrabQz8TFmSiKPNjE4frkhTr04mowGiaYAXECvxBGgMcjreyA0cL8EZ/nGAxSgFWKa54nrkRzY+O61LhV25UJL8ux4WoHnhdWaAkVHXGToAkmohDn3eAYkUsZfXwo/XYMDXWdSFAgGgZCG1vEwCBh1yV3DAhxOE9QMtzk/V5xwTeOxTjmdEoZiTpJv8EToMxr0JpV+dzSd7aiN2q3sy8sp7fuPHDB/PZF21157cjImmHHi9l/+h983v7SN92xp1+oPz/YN7t920Zy8rqTkf4L/Zc7wd2hFi7j1/vqmsXuWbI7Dbtxfe+TF8/ObrXY2cH+XvqyKyvtbZrGHJD9euC9M+efOTZR0gV3U/bw31PFCAXvbH60VgYf6Ex0Cp8KnJ0hiz5ioMKT835TYjAXbqMTDme3NADQzEey0YzKMS4iNrayByEhw2cV4/QlqC6SZhTBNPixQfevaVawJ0r4AkxNk3pJFUY8MQXMdEnASHzYpzm+b6OsoSSzjEUNI0xq8+j50YzRU76kuK2dHNPUZDMgiPQoIk3LJjnss0FFa+R8wtmCfUzJA3WQng5Rc+NPJxAS+LklvIBScVQKoKnjBDTVFng5FSbAMIgaEdec+nybBBRYu7maef8J90xaGwgb27S4nN1FkZgPrDkjF9t+0ub78rFV+QZTnYA4hUXP+e9TDZ288vH+WJNsIuCfTFcX3pvGvkupLFmie0z4TaVb3eqxiLzLVmjnww7FSF+aaCf49hKBw0VGWc1JZpescI1QJHpWQUEElu0cOgN7CSJUTgHanA9A9j24Hxb2PqhM9omxudJXtuF1kDeA6aI1hsVpDZx0kTEEdDnmuhiO+parpM51cekEzma6CysiHfoquedzqg5s2cdVVKTfCHjCLK8UsiDOE6sEmzQ3pNOGgethb5su4dxC5AhcqieRWCg7YM94bdYoBGFCTCRuHG29jAmdvuYAOPYEY8VJibW5C5tmQBf0g4hb64eD+WAwwomZ8jDEHUvkoJV+CtqcGA9TEmOnDh8S84egkjscPeNbwWJqTSBBq6U28siQUtz1JSgNcRSrluyGz5QIyYhaupvsq/j7LDe2gclKz1jo216z3Jn92k/91tnN5xa779K+5TqZz1d7Pf3cnv3173vefvD77tgffcIGXDoMVHeViAxfBTyz190pnDWUyu67r3fblK6kv+HNm2Z3br+6RWwXw148Mnvk6jX7hz/xwdt/9ccf2n3je7+2+9smBmhhiFkUT8BRyxBSMkGs0szUUl9nLfpDkCI3yxBKJVSkOrmdGDYiKc8j1jVYZmgb4fv3p7fOOr9cSRtzz5JIWIr/KSRAtmN4N9YftBerI5tDMH1mq5vytVwfbH49L+s8dAwoK8/tpLLa5JCTx2YKMo+OEsu35BDrocNu5XVdEySQ9VX1l3BQXWaMKIk9rYuZU0FhwD4SJGrBP5hHPDout7m8c+uPnwqHN/34BPYwTCQ3klU+DQ1z4lMENIg0GeRodcuCzW4kpxjWo3rxC6mDcdyIHDVHt1YKWm3YJzsiQHMVjNzkQkKKPmBZIiQ82GBSMdanzMJByzdkAGWFWSHZSEi3aDlzAef0uYbr7NB3zQiDNE73lh7fTo/RDb0uMMqE60F8wfNPMRNZZnOqT4trAsc/R2AMFV1MycGcNQAiC8QjvyM6b/r5ucKWTUphnJAByS1uJ6D6ShJaKa7rTJnz2NQ8JwMuk0MXrfungyHacjbhg3TDrPwL/mnUwVLrkzPn7hwabmuw/zLonVtO9IYe7NHjxFAhJA6LBeFNab07+tdFvdWCMG6mUAmgqRpNrUTMvBCl6L5srlYWaIfCBafCQLlMuqohI+j4BBskROjkQBY0c2FxG4ojleVG3z40IHBfB8is5OyChvAUqTw6KxkP+LVMwT10PLmh4gp/jLEnkIcMg1xUTnN6maEdYMK3WKWJes/RHYsBQCNMhGAt5kWCZqCbghv9dEsuke6GZkfYo0ccJWioHZH1YY22ZP4/lNRovklFGeFnQFGKwBulhGsp1xiI6qCvq59jSPqm7+nPsuz7cnLWfcD21+PP3DjNJ3eW9x8pOL/aq6+G08/t2+F33LSzbm52Uiup1yAvN5j3dScjDmHTE0/s2/PPH9r+frPTM7dH33HH3vrQaqcnf/bv94Pg6MDsv/uvz+yH/5On84knHjr+hhGN+nbYa62dcSgoayqVTXj6YmCl+ajG/UoFZ/xAbllrMWjCB6Rha+GZPOogZnZXVxi5AK8m4RSuqp5HABBG6ALJGqxAqvcKwEZOwYWkUMZjXQWkHrRz4LzAHzwCfmcSiuOQUnY9fwjVB+t/fMugRrW2Jt1NXYIN3C9TYeXbrbZhTaoOkkO0z8GDJr0rJ1hTJ1Hi4TqKm6yB5KMg3bEIV8p5U7CHbjwsRMreQ3R4sisNotH6OhE8IGv716CagXOtaMJt9M0AOGZYK9DPlEqd6UWiyYTyyaJiVMHz8CCyYELaYbgMxwH0DyTvKWOoANsB+K0JOtDYSLppikFumlACEvLxmBuh6L7KRNBemYLxmAhK7gHuSJmw/p4NMwZVdYI5p90HphRZBkXfOZuVARxMUSOlQ7T/EFKZs+u9WAXnsyzkrEwqQ7VvKgYztsfcR8nPRnAvv5kCMjDkqc4yn96aWGohOg9dZ+PWLIZ5SHB2MQ2i4DDLFG/HxJ8CEZCTXOPZ0C/NIbetxtpP2raMU+BElBQoAZyYXvGZOs/Ow8mIX4TL+Myn91doydE2t+7kGpCirJDaxZTBmRTLNBfFot1s5mTq2ohYKVprGqD6++DIEwGz5PnYDKZGjZJVJ8kzA12ixbhsOuBZRxwD+u7YtLv4pG547psQbVaoPZFHIsMPmdJu7QpxTkysBQLqRzisk3ZTG1Gv6X+TinlyzEgvG+YEE9FuPgc1om96M+h6NswgEjjaY+oykV3xVjTuKZN7DpbIWEuxFEx4fPOmedt//IGHrj7/zq+8YE88c9NeeOHY9vf/bNSh36bdzq0d7Nv9b0k7vjO1bq/0ekMealevmn3oQ/fZL/7io/bww8d2dhz2znef2cN/8bqdnDSp1V7u1VdvT2Yu201b9493jzx48emzO2f9ae3t7y2nJ6dnSytAeRjJmKO1U64WbLLFkh3OqFN0YBRiZKM9r0bYAqfnqH6WScC1gr7sG2l7JepGgdcIGKNfreYapCurlnLIQeZkzkpVujfSPyjeV8L64Y1jlSjSxAHQeIbj6wC8LxvrICjIBMeSO53oPqproxSu/iKoejUmfeROoQAP9niUypZ/l0BUGWspY0iorwrIHzr55nAbSnDRE/ktI6Vq01PXqcJ1gGEoW+TuqeDBThUm1Igo4Oqc/dvJTu7Yak8mTUDcF4Ara4JZtTQ8KAA2UDQjALvIFxjn48kHirpGnW95LKnXdkx9cUQOZBVV+1awcRIxusoMjfuZvaFzMBwalOgAVvMOJf6rrwy9jAaWbaBjT0p8cysU7KZZWb2qYZqm69KM1xwVDB4Jdh8lrdRAKtHzlNjhNDVPEBjRfXQiN3NU2S4nAH+jrK3pdFh6sPDKujy2yxK6lxCQ+UQV0s72pNo1I9OOYSdVm9mUaXOt8MCCq9coLJaiCtgaU/pRAo8snjFwUBxncf3lqAG7XAPhAcaza4mCRblU5W50DcdDXaYSmAgEW2hMPTZc65jVSEaWGZJzBJ3OXq1gcllStshmnXyAw4eacIYsIY02QDI4bBC3zSFAIzNP1FBlZCTudgUzXM5L0vJAgwulEozAUnchuPgsJ7rgqvc00r0QdndhEgWb9jbkRsRrGJJOu6HKmbfDvAWzJ3jo7rY6dsqK8QSLpCq4ISHWxjmjqGBYZEa02NbEsqmbRgupK88ZVw8xWmtCpFUYYP0y3UY6WPQOayQshSYdHjFQ7FV5FrO07xM011x9uX3rlj1w9S0fuXzl+U986lNP2kqzgvWVs4r+dDsF85nPLvZDP/SSfdd3ndgLL7xyTsDXG0pG+olwcNDs8uWdXbq0s7iU9txTh/bZiw/Z3oNheUsKui959aJw78K+3fNNj9hL9ttndy+HHw5r71vX3YWD/UMTSAB4QtSfhM8pFmOb7HN5UzuK3s+UNel4XmiFNyOoYNNfY2MDivwBNc0gOAwyj+FSV7sTrlgZnvM0rAUZGptAeRUxGSrSQULo9hAaIfFemydw9PB7ciyqfrKVKlaaNhIEkx0onwYC3DgiirahU0nQ34GheMTWKsmxs6UUTz4I2oer2dbRzisEHO4czBmM/DmxpKxRLhGc1cbUWXo/3yaZakQ1yh178OeEGUkSaG7oOJ6VqrlquPpr9uFryISsptCZZHAorXzACktvsxGRi4oEXZyjyMCyTRaQuXEKESY8p2wKObfEtWgVrYTPMS6BUEZw9n5Id4oCyER1eZuZVKHJEz2ZFXOwnlcXx9TaOrSBeP8hpsUEQqR1WsOeC4gq0ZSUfvhUPW53AwDzoNxVa4Vym1LlEJmrgbYm5o01Ja/e2TCU1No2tX85fGwoPymAP7j/51gePB/nyqZNg3N6ZspAEbtrkjazZvdtmuSAWcQAC+sxqOGwXpZkEpblHyJXWM2ST545SN2doZB9aGD56k9DUtOFYYi4jU9kg0gMl595SkAx7b0kYpixnab/Loab2ljW+8YJW6kx6eA0AqZ/HaziIGgNu5eeLdVF1DmaXClpAgJE14MtX6UPxwA8pxN7NzTBSP/qq3V2pG0E38Oa2Yevm1RacpifWBuLRkbZuWQ2nN5WPihtb26AiFlk6qc2KlToeetnQMqTaElSUf2zFxKsAL35KL/4G6j7yInzgP3f0qbIBHvj57qe2ul6Yrt2+JGXruXNT3zqJXvkkbuGrLitr4w4tLMu2wj74R++YX/n79y0GzfKX+zVXm/YXb7oGs6TMrt4sLOLt3e2f9++tSs+RC8vl5B0A5W40OxrvvWCXflo2MOPPPRP08/+893x8VccXjgaZkkIWLS9nDtaawJWhAmyeYYSV73ORr8Gk4n6TSgGFqOTmBR9XEtGtU9M2bLNUjA1G5IrHI86yQptdV96Cw3GAT/h6CKRSEkHuCBVzZhQGBKXM/0P1VuKWybyCjMg2Q9DJxH0EiVMg9gfQTsQNNqzrGyqCIhlc00PxyemDEYyeIUVNBf+4rKZQyuC9jZAwlnr1FULdaEmLjXBCxUPJk6QRmkY2YdfJ24C7Y7ALrL/PKnQqUKJKnAUjoYdKWa03nycQOLRHFC7vzvF9HIqN8SuVMyoW5n1ZNmANdXLHPA2ZsuEHm1K01SFMGTCNcAXvRGaCFRtHI4Z/8auR/jb4v/Tf4M4zYbnEm4b4ZTqUY3TgPxMQZNEF/Pkmfluq2wFbz9nPtFFO3nKuMSqzA+VemzwbpTsBcCFCkSk4zKO6+txHYWqxv0DxWGuaZsmS+q8k5PktOcmbcoAYFAD9Z0TklxwbBZvIMTjZvPdjFgk8a9J+Liyd4mWlbCuE1ul9J5nnSpfWZQI4a1HMFvT1TKGoqpf7opvQ50igCXyYKP9EE075vp2pmJnO8Q7Z6ugwXgEyk+ejUyMlY+l1OVECAnQsp+DVSAqFS/1hjKDcf8HEwbam2AeQEwds9RScWUzokhHIREvDpOGIxgwrJZXmext6zgm10T7NiSzHukM4XqAo0ZcXQq3ZGMEF9n4tOBt4HDphOsYsDFsqibDQboX1m1fKUhG50ANafBtF2UZqK2YkMdmiUZxudnkcYzH13iztZsm+hB/pf38T/6LJ5/4g9t2cPehvXDn1bOKW7fdrlxK++EfuWm7M7Pr119dS2pfTjLyxS8/cjv7052d/c6p7b9zHaL/l+eH3K49E/bsz3/Y/ucfP7OP+12f/Tcfffr62x5qxVAamsiAlTFXNq0AFKQaJeSkRRVMqgAuA8ox68foujUGniHg1r+l0YG0zTqLmKnsA6kMQ83Y8b5WsoBhW6dwahojga7MWlHy5AD5C1zZpXwSI4DQBc/kXpOt3FJKNxLVafU0sXZAk26NI241s5LAMJN55U7oqWeCgb/HcA1qhXEwuvp/S/zO4h8CCh2yDWhf+aBwJGGrxAkiKrJVIywtMq6kSwLqqIbTmTIT3V2nx0GbjogLCZPW1xy6N5qUaOD46A3Gzu7+M4voCWPb0bmmwFCzbW9vy2rpdQdG4i14gEttQUIeWlIqaCLYh74IOg/8VNu66eM5jCevCt4ntkrnlorei0CJshKhCamB/wHBVjKmMmqjjqVqCXhr4rxkgw2H9ilWm7y/2kSvvWHMdLXsbOrlAHwID2EDgzKFcsSox+4hCdoEh2LPD70hdw33/waX7s6UyB4r3LPRo3FBoxOT6UhtlTEVBhu/dI/J5hjhbSiZg+yuNbZv0ey+sVNW5RbikspWsw3cwJyQGQeycidIChv3RIfGpo4dP8VG1mDhE+c+TXMwJvUCUKIMmMqor+rsDWw16A+1hLCUc86XyzJn5Kis5JeVqis1eTDRuUZXqHrzJOA2h7OkYg2KHzKN0HZARAlPosXQyMPvxzSwwkKDQ1mhTmxdQU8N5iJxb9sUK3j1KBVYpFKKESJt2kc5Yw9AEJQKAaVOc03+NpsTtmkoZ5gLr2qFPjGAU4azipQwJGVncg5PP4Solkn+hlw62gAp0aV8m6XiRKj4iOcBXDnxIoQIu78R9o2M1dbYX8KWdmjPPfGifee//x575slr/umPP5OHl1+5tbf/+o1bYfc/UKM+eiIC87xXfb1pych4XTDLZxc7spu2b7dsPT3fX8XXwVna7qmd/dY/f4f90m9+eHfXt9x17Sve9Y4eMve7+VtrDNR0KcqcIUkQOP0ZJKtk89MsALiGldbrfzbPxymgED+ivBrKrpks47NnIZPszDHCnSrT8A5bTSfNrHKjVCLrMQ5xn+AMMeG5XfSrRmcjCFdnMQO8E6pWJvBs6UwWQoAmSHBvNkvNQyGW3yhzx1G1aenCLd6I7TXUlH11PQJuFCyzUpmvVKCaNNzgvcwpznN4d7j8yAlVj4i5IGTApT/PzRfig63xs1hTdd/w4J3AiOP/6QFsHYZg6w8um/Uth6Hy/kPUbytKewV4I+hP6y4mPX1Ed8mbKo2jqzhlaVPQ4XrwhmZdNWLha6WWtP4vrYgxNtVV9yZVhvK/5PpcsWU2bSTutAhGY49wBQlHFfEhK9A9mV2owgVWo0aHrIljuoDlpjlk+vmwu8Q5XR0ghvzoZ/lqGG9MyqfR3QMTC2PCNQYkp6nf1mazJvU8GO2nqo4JAmkJgkFY+3T9U+6UgijNCJASxgJAZnpHeATMwotPMnLqPm2yPMx5+FxNxAZzFNrcAQemd71X9960+WEpzaOOAEYxZZtY1DRwac7C4/xagp31DKfZGmJuY25F3IQyMgfMuylNsJ5abO+PkVoBoAbIrOArTZnEkT605OxjcCIWRGWwwrB/GbTZ+Ks9+IptMAAAIABJREFU5PSBIqzujiFEfAYtMaeYfBU1Z7XkBNYAVinjJayfKVSNnKZ8ulRB7ABOdFJUceu0kaMkTbMjlIJoqsLsxZ5rSlUkpcT8+hTrr2scn53YhYNLj9979d4X3/4XHrTbt0/HO+zvL196qOPV9/HJ6aF9x7dfs4fuN/v8U2ykevXXm5qMjNT7wO3681cs7g5re9N68dzPXTC7FXv2E//bLXvu85/Pv/neb/toW/N7zuzU9/cPc0ypN0grkzdzsyzpvclWyjbveKq5rTTUa2o0iOY35Hzw3BMFKgPcDcK2KDND3EUTpgm/RnZdcoKeTRNhB0ME01A0Vk2alcKyhARM2btvtoOzUIRH8PgTzKkbw1uanEIF6RBRpMXRoKVmIx+OxykTT6VmCioQMAzUlaOkUXiwaRFH2kwP5wbW+eZqjuPIsVn8lfy+uvoNhprBp8K4H7LyQlUHygWpkmBY1m9mc9NpuUxKnPA20ivWEyR0a9mxcYkKlxrCmhTtk+cZ715KG5YoRDzHHLGZ1CjP4ekcLrkZqjzwLtBGLjbjYzP0bgCOTb3X5BUlXB2AbMzBkcDQnI6mVFA668CYtTxUDVs2QOQPvfigNKShVqIrVXpGNQ6xR9E4aqU6NDl1iNtPw5TIktcTnB5AmwE+SlunHn1T82luWpX/i2wekkNkWQiM2gJpMzZmMRskMOWp58S85XEzhvWwHK211DjRFQmlxipQbczRnEBnN4NMpueq0ROPNQQCDkRsgYk1DG5QdBdmByfWeSlb+b0yLxTaW4ghKYTFbmzKahQrgGK5UjqTh20FxOLdSv7BNY/DVmFhxI/yaNL6RSYoFAFex+hY7LDgoDZrWmlDRPXZRWYELryxUEF4ydlCa3xThyctwFqTsTeUJkGDCKqW2IcCJeBIF0ghSWaojZukXkADQ9+LdwOnyJsLLAdYaDt3KjTe3nNakpYb3FJyGUVKXNmmzagDXohfui7JAdJt3h8+DCXASNTWstQ8vnPd7rl85V/cffXeT36m//e9h3b5XffahVdARrql3RPPHdnXfddt+8H337IXX9qmV6/+enOREcPj7V5Gb3/A2lsPLG9XyOhmZ3tLGz4j6y5t/3DPvvlb7rXf+Z9um509+MGT4/Wv5/7xwwcXL7nvTnl7mEePANdYFVL9pay21g3zEJxVs/8/WIJx2TRMreNhOY9wnDqqNrhzm6vw3SpIWccycG8PZ8oSakw91PY0vZnYyQz+cHNCCIJp1ziQLbd3Y9bbDcPCkZrZRv5F8pxlFHWOJV5x3QtTZGWtOc+K2lqSFBum1ZVHCkUJQgTxexrv4EzdeHTxUDyv+yJjOhOxJO7u7Bu1iaHXqAZj82y9AjNZaCXKX22bQT3VVOSR6tzIoeYvJFgDj7xm9lbPL+NmhZRGtQkHqFlOJG5mc+LoiTLwmlqcv8YiUCqYY7AwGpYtKencGtoyXFZphqON1ZCE8UkMV3+awrTqcApJI3IGVpwg9MrOTURUbugkbhgB1S/vHLQfzEDw/pumTELUlKMiNQwl3BRFT5+eGnsd8AfmlkPq4+z3mfknIzJaORZcWMKMfa501Yg5sRPcu8bS1baIIJ7qFrNQtWCbfNCrs1mgEYtjD3onWine24R4TdGmP851c6ClsXde2GoguUpkKeKxZXAFG+IygJeYUROj9UzpBKOcjnrcKnHIvsI/aMhzcNjmXL+A9WdUHMnfHFukD+S4ecEUREJnO7SpOx/7ENlDTimSMbLXfF8XmJGmt2oO7RluEp8N4AGqXPDd4UJPBsrVZWsaqSEYtTTtI20nsjS7nHDIV7+/+yw0Bc1Y0YYj6UpTxVv7QjYs0ydw5oYbWZncyH0u3pCZHZeyZcozRn7b8xbOLp6ENJC/CLWz+9psd3bHLl1+x6/67b1bv/XLn7a73vlw+tsfsTsve+6bXb+zZw9/9Yn9+A9+xu46Snvq+WmQ+lpeb3oy0r/VjeM9+8ob1+x7v+EFO749nXxP18UOD9oQBV44cvvabzqy5966bw+9/fK/vnDw/DM3b9vDF6/4HAck2pRdKr5RhCNvUJ+Ja0E3jq13Oye/Y+/JMJs3nZk6RySw0HOpXdd8Cv3x56ngtJl1wi5eaj5cD1nWgVSrG9OhTVzD7ZvwPr8brCOh56iVqfGnboIstdfYBE2VVYWZRgHtRqpy7n7a7GXawP5E99QVU98gNHR6SAkW+umwTohpjuLT1BHgJp/w9OmAR6OOlCJEMGI4Uc+aaOdJYEz1mOJ5JqkhSRKtxgrPrqN5t/GMNj0K9U4BUJeW7xgc65KIIVmEkkjaURUo+J5JLFbNJQZ5A3PLWk4gxFzYnUJoA/oTzDiszXtpBtOAyLLGAiJifl5rASgjiCBzoLAODKaLaJdLM5akLBFbCVUml6KvOQ93czP1uwaxRzb+akSdbe6VnTMGRhf5xKB4fSZ3GKle5sOiEzqcu2f/gxNS357oJJt0joxDrxD4gOxcv7AloogJEELajFlktsxMG6NZwN9wzyWXD2Xz8+GwOqmNjx+2Ni/VNjnE+d1NqBdlL32HPAVMO13hSY/BwU8qCbWz9ehJ0MnRDkijRuZLDJUurc3msc7uOd1ZzsmZ0W1zXqCar7wMy0H0MepCBON5Ztv8AP4GmoBqCN8QNE36l5UDc6E2fxUYgjBMUbU8P6xc/ZBm8e8bh0vypKGwbdnsB5+LbJtOtS03zdSdw4S4qqudWrgLky4NrDACbCLsSttQjgpsN3LX8uLDk8Zrgyy60PKeeC57y87idP/sdGf/5O9/5Au//ZEn7IF3hX3794TdvtE48PTca13dTtawv/EdT9i77z+2J557fYmI/bkkI2Z22vbs0t6JfcvVF+0W/OcffdTsdz+22C/9ymW79+5edu7sQ79w2/7aB/4d+w9/4N9e/+C/OXrhuZOvNOuO8MuereuZ4MbaOYnR7EYplhFDxM6aDD9IF528mHJOLXarcajFG5besjRaAVfDgB2D7Mrwb5pv7h6SGSS1bpa0TWM1s0EMzilHkEGj1J4dO4jujUUFRsDUm2vwxhwjCqw166xTfZkQ25W9dZAH5qgrCDoYMKqKWKgA9jBZ6RD0oNyhjvnA8EupGQDmFjmB+6O9Y5MqmPO1jQ+qPgdKeYdBkT7Tafve/y1wkRrLNsEiBysXSBKJKjkHjZO4W2mXTOCq9AUxYIySYUC727bJgm3alKx8FhrLt2RJNLPblkQZNsXxtFSh4FnJRWIGI0XUugh4zrSaemfUQq9ReILTFyq2kv8wEToZm6+Mdd3wKeP7xfDtQsXFsx0dJGoNYHvyRvsD3xOEaI4mDtQGEuZt0EZIQnnHNd+mDr9hFsTnS4p7rK8G/DLYujY+f1GSxTvszNI86muxhQNPj8W1kACd6AkNhIYyDKsxVc4bWMUxIK8JfaZXPfYvgsGqQ5gVtSOtqAylUc7kIjzqyy3QoSrbDhYgRIRo8XxeL0I3WDm3emkTbA7xpqt9cmuBh8NSw8pct7Q6kuuNLs6NAu4vgk+RSgz3juCjmCgEy/tKM+R9AzJt/CQ19snUD5ML27RZVAsNsBniOThDXW4NTc1e8lLQXJ56+cy8o7HWKiN+Hc5GGFJoxVBUgb5uUq5La1gSOginiXTzuA9Oyqa2eJMJSF41UTecGaxsMKkEJkbNaBAREN3W5db6Da63LT7qpinIiklkhMgxjQuIUpv66fEt24+7/uT3/tXHru0f3rb/9sfM3vG2T9hL117+zN+tZlcumV25y0Yi8lq6Z7749QZ+5TW8qaftMuzFY7OX8M/TL5m99e1pjz662uFRs8PLYW99Z9hf/fbfs5/+bz5h/+rXL/3JPVd2ttut7su0DuZhnsE53cg8B4bbJ6NFIZDofPHam85aRGxqYCdRNlSWC+OQG5sUvRMQwWrS+3BVM3bSLZoDQbfVoFdowZBRfSFj+dVolA4zjyw95IqlRLWEy0AB0bHXGOpng8ECeHZwuG1TLuEUDK1HdPprmhb+3njseRQxWz0CBtrc5aFQCC3t2oAPVGJRZFPEcF8GlF3vixqklcsIKVZVjWzaoeE3cptRWow7OtrO6vPLDCqo8WxlzA5EoodKRCcikaQOZtAfvkADaOmmAjbBLGZuQqFYY0XNanNT/4uZCN1h9LmHw7RVF4CaSkbOmnS3KJeVtlJkNpCjcX20kylKvMFFpc/nrhBVfVE5D89EVO4XtLrt1cnGkTwsjeQvBpBkfOkhnqV4gOvPZFTAHUWIAWjMhnjgr+MwXcb8yJyFfZKlp5q1DjrnzcQDHqtsrYQ7tk3nhGhMtjS2h2F50pgYFlIbmQ1XkM1FhZN2ZQNkyWQ5Na2mG3n20fOTY8c8Ia5+eE063G5Gf5TLQmTUCDH85B1doDzI6fw1ORA4pZRsdk4prCe0onaNcig0ampr0DU74WsHNXKeSdPxkaQvrGNx9NG9uWJBQTmii6gNgGhgWUMG1dP3EcOaWtVMUdb7JvyGZdMQMS24+86BBg498ManZh0f1kS45BjK3X2GDbMS6qNgqACwoOGcRGrpjVm9pTiqRWi10uVa1Ib2uP79AjHcmeY7q9TBOEQw4Tnv/xvIPYJ2u1mZYk38L5P+mulUxQlAsOmWhoRh+PjDzAQSRZ0PJNFaOTqUW1+Nl0wVRKgOlYQYpm12AH9Fr9QGzSEE21ApEzGuwroZRxogZynpjzvnlpfRr7R6SulAbbmvZyd768mJXb37oV/dv/Dw59/3PWbf/e+a3T4zyz0z3//Sf/YumJ2m2bXXMBLmlV5CRjp6sb9f0MrL+cZ/ua8bN83e9rZm//GP3BzZ1b33mD3+SbP/6r8w+9V/afa3/t4jP3fh6OT77ty+8eil/bty9H3GpnrZ+s4Y0xMqzZhxovaGwbvJEnJEWVodKngp6NGFg8lAOBuxIfFPwZJM0lWu4Lelf5qqkVCmP7N+XELzzRuZ4E7O3IVgFR1/BesVSrKxXtigAxMiH+G0zdEwojHYM8MO2qT3hJeinlp/ncbBRib1zEjsIL1ODTMtZBSoUSS/09YWdYq05iQrzZNJ5haFYUJwKpPTxrg01cG0tzAWuMnnpMSwFHUCPQWROltoRh1EKxPab3MtMHObDELSZdbqkGVVse2w4HIJ+kKks1lj6hYnVTRPGc7+1DoC+RigFpMMQ+HhSxmUO5X1M8BONHZb3GWqbb2CXQDHI1A2dfug9HgPIbps8vrPjYZB7KlvymmSejB4r7uyyXBN920Oaitb9Dp0NDJSbcl1dq50EN9gGmQSBgfPxj3t95iYI6dkAuhjot7ff+UBQ/ezJFzFhltiF+tEN6NUV0syQVkRkvgj+BCHiyxYw0Zgh9Iu2XdQ2HjeFI74u4wLXO023H4mKpAQpMoSk7cOh5lQ7el7RC1NHB5DCH2UNEIaPBhV7oTyU5gB0OWNaLWpvN8kuRyX47bNdwi76ClAggQZ6ezCmS2AuL4IDX8g7ebiVfAeTF7wM4z+3LWgxWCENhUXJZyBBDk5m1JRy8jD1GgsopJJRXTxyhxq2NRWU8YsLCUYQFr5M4nJbFyfCLfzKak6xyDZjWASD8sVx7H8CIW0+bj4XAPzQ8X8zx6Qk9NT353tusbzgwfRbn30o71d1+zht5j96Z9WnrB9kTKnNvSLX/1J9Rl2G3nNuVfPOXr+scdn9fDD5s8+a9kH3pnVB95775zS2xOU/gv934cYde98m8y6rsOtljenw7/9C/R/uvta/6L99/s/9181e+Bes8v37/lvPPU+v+vjn2lX9vb+v9vHx1/Idvyo5129SBAJiTG1PEU4JAottYFSNSXhF3KK/KROq1adVRuskicU5IIjXqw1m68m91dRR72R04DB6fyAuJ9TQlrDuxG0apQAlnxuh9zObJQTX+l23/j9tD16sa9ZYDUlo6qopHeocRY2mvXLEge7WyThKIsbHZHAi7rFRKDYMIQmkYnS1gIPCsZpX9DoxskkJ6u4q+Crwcqj1h3mVCXtqljT6jRIOIs5JWelNh4/ifaDGWlo/DFbLErQ35x3tqYMTVLeEQMMXdBtHXCYemvJEwyGVn0XQJpa+apkaxjPLtc0gzgzkDLqpiTxWs4f83S1PIB3Fs/OGhGEd3F2dTDnNNQb/QAS1QMdTCr9vc5Ccj7KSQs6Qbxe4bnLsYSshggoTZSWQ47oe1Om/JO15MKuR1RNZTwQx71uioBjLJHPAVOklUaZOQaoN4itG6i6pJs62pM4q6xxf4WUieWL7aUP7913PfY0wtk8MSQsgtYovS2UiffuRZobjufUokSRS6pchOK5KXU2NXzndCsHS6hpZTq1chMfYOGTUgE3uI0057xxjPYBdpPyYkE1LloWJMu5jB9QGUbuQaiyBmW4tX8avHBNLdJVzKtuSW0KVOCUhSAPaKW7HYYUjJ1sCkuOfa4zsdHuwGuIADZv4w1RA0fg7wey0kEJV9KyziSEBRybisCt49uuzF19DgBgldOva8VkMqpRSIdX9dZAQ8WcvuHs3AEvjgAHNYohECbFgK0gFU47Gk9s3aA5uAblyXVPHElDJvrV8b+qIldWMPj8+kqYxU2hmfw+EQLTRSEgNwUTiTeuoePZhkFaqAnL2PTpbnsH4c994fTkl3/61z73p59+1vYO9uyxx3ZDasGEYwtWuNc536f6L8uXAhn96x4e1pDcfv5/8at7kbznPeZKRi5ftuEfT1SkJyP93/sH9zc4OuoW8PUufVrvrVsX7eBg3/b2dgMme+CBB/z555/P09NTW5Z9OzzcG8lM/53+Rfvv9y/7tkfMHvujC/bz/+huu3R5zfd+6zfG1R/5Bvvg//or7Wv/mp1++/e9G8skdm1dwyMoLFxEXY4F2xrjgGJlX4MLTop+huQ0fYymAoXnfANb4dQ79keDbDGjZk+2OvydHhPB4xGDwwgZhGtWmDKL5KSFKtOah5oinbILega4a/FXHGs1W4f4nY/xjItQkXRGLO7pmn3nGpzEJcaKZnTYacpL02FE1LkkACGCv/KtCfK0RgcC5ihwTrZCIVZ0HEbIjaTVMVjdrMMlrv/eQnM1AkUgnSAE4kZDzUHSPzAbgNUFnNkZ/oKFSe16sqBEC5zGWs7NUS3/eGjGSbeJZmyH83IDXjJ8gZd69Au/Y+uXv7iEmdKfwTwIsBwsx9sseWZzDhM9YtQenLNpzdcyF6aPXmW5KwcMQKMKrKjTZwW/mpe/S6UbzB8C8gvmoUgpKF4YH7OIQm6Ug4sRKI+pZQZUn+Pjy+yBXbUUeMLwZS2+HiTNrO3H73P6/xhEWZP8WiXLDXgHV7rXpwdNOM1XQG5qGfBlEwSzUjAlBbHU047mS4uaTJ3k24H8T5sJoNnbBhFqPKgtcFr5EGRpOeEsRzVGc/5QuGLKqQYn3JgQ1oM8HJ3QBp51NtnJWXTcIBrauCQ8iD9Rgn3Jw4fj3gSXMRiq34Gl4qO1qP60QIU9ujZWCT/aMMniFMl6d+NQwp7CFRrUkDpA3k7Ksaxq2AZZaycJyWF9BXriqB5u5JJh6xqE8cbGg6rZFZEmSEzJ0AjBwT8qX2P65Nn8fkJcEr1EIrsnnx7MHGqDm0L7RGyROXifvdSSNmLTpKZHb1fBYW70KC+53ZoSdjDXN1gq99CwtFxGmRkYw1uVyYp3KPqs5hBr7gDSeKsRY8bxFLV16+6u/OY4uAo3jlO7fNc9v/e7//rjL/3l7zm2D/xtt+efN3vmmUoqXi4Z6flCBx36z30xctLP/z7ln4kKERK+R//7nlMU3RZmn/605YULZg89ZPbgg2aXLvWEoxKI7i3ff/Gee8zuusus/9yLL15QoOxXf+PGjfERe3t7FrFne3thFy/a+Kd/UP+ie2H2qc8u9t//zFX73/+P++2fffg+e/SuX2p5+7ftE3/4SdvfXfzI0h0/225vWfbQgjf5GfZHFEABb9WiLiodICgRg4hUM14QoOXGZkFDXNbRM8VaudTo1GOw3WzFj0v0VrtJ+z3J6oIHGlbVIwnJSZSDa5SbM45XCAmGHmNkJj7r5gJX4BTMqmui3cTIgm7LDjoi2KYGb43mqJu8emzlv4n7grDGwxJ1cc2NJPukvljOL0T1mShgZzMa5fAwBEqYOho6FVyNM6trU/IAKnYZWaPa7Buo5yr8ysfcK8rAJQ01Gp1KizKi4V3dzeCsnSBPplZO0O1JU0KDcSrGjxBzA53Exgm4aRIRKdEw4QCHPb6wkCQ7TvKdbeYoWOGFhkss4TSpfKo7vS4/qfQRFIGFyDXiLKQiZk/4eCDRUjJixObgOJpGno29jI3TxVMLnvbCWL9RjhMUIykBjzQCY00M+sjfGz+t7nc9GfRUw8yuimURKi2ALSJ4x4Kn7E3AXjhmxBEVxYoOhHZ3VBNJTHO2YUNjUAcAzKQcrvCLQ07O5HV4l5IlnEISUq6TxMQWbckymKuSViRtpF/Un5bSpiSYDh5pauDpTI+YV7/m9N3o0SaQ0i8VA+m4agRGknt4fGaMBCwVBVPXQ1AZhzwiVimB6E9Aq5Nkh05NI2DrCfO6AJgxHo4T3IUWTZSkSv1pUG2caGrzp+F7CvVHOF3GyNwG1mVyFHPtAcc8ybp58yR0lgK1XlaZ08z4jH0qCQhoOmCidJuOLS4kwSiihOif1A4qodCQ3kHYXZk1rKuRlkZA7ozOak5SrfgSvMUt6rlDOQTrJK4/nAWjvCGyW2tAXvdKAGNvGfnNrZs37ezW5X/w1keuPPUjP2z20IM5kpCeTNAWmSBGYkp9/9+eN3RQoycrzCvIrIgt27y4Tnqi8vjjQ44ys5TtB2wzF/5dR0h6UtG/2NkYhrPYgw+20dZz48YNW5YFC7ONwqD/TP+n/27/Qscnbj/5s4/YJz9/aO/8i6f2Nd/5ruVnfuFjbXkx7V2Pfo3ds3/1Z24+d/KBy/fsHjk6OIrd2ShzW905RnjK+p2eczRmMPAnXGjSBUHaRj5Vh1ICdkF8cEWwzfxFQuNqah3JqGOgORpC06nayajx/A7vq5i2pex/aWIIRkKgDjFy+r1kw4T5mE5AGQurVdFAkNFjlilOgBWjoGobhOELg4Ek8ogt404dGZIUTnMBadvVtd7IrdRebgivI0LtlRMUmwtQjbOHOkiV94xuqRK1RBBCqZIoCZ8veVAjlaFwyvOdptJD/VkImFycndfITmB1zqlLJ5mvjq6PcukcQiEbIaYjOEWCORCFmhaYMGpg7YdZpKM6pR9FtbvUB3NRJCEuDN9FyabsmBVawEGO6hof4lUaqbPr2dAnAZ8n5wYZiGvAeZRgsLftcJHKsEI5UdbpTZaR4+wg04tUUC2KDoguSQTgPGxrYX1ObqzSIJpr0vgLZAD5IRh5lqoxAqd6S3i2uVQmjvE3ycO5/HZB6BSBRULCm7HTk6qAUmkGJseQ3x85axR4Y8U6sg9tHsplujkTAmNn7HiiIETHI1uCIhEiUv2ZsWEEnRU+D6wEEsbbz4NG366PcYcg1qq4IgQDOnrk4XXOlHc/Z1mrvWe6C8zhT5oYP6bPUlFu2T+syCej+qJFlvYzqJ+DrkdeewOrHRLZXFSF0ZOeY0cZ3xqRGc158DG/r/hxD4zEbTQkrNs/9DnO1rBaKwtAXW41I1EMkQkiTq9XHQ0FoFCHMT75IVofVr7ksNlvElC41/NrtG/GswL+4NCMJLBJI8QKMJeyHHLe6BqHhyuwoTF8va+CJeggwSUdaDJbLRX1596sC47AetwI9MxpXlynHjJcXK6juAXkDW+0uthOY/gtu/bsnTv/10/+v7/+5OMv2PPXzB64XmhHTzK6jOPlNKX94/rP9Le48zJGJK+mQQW9df6HX05kEpAx9C/y4otmzz1n9v73P2UPPnhszz57OAbmMRF5pdfVe81+/2MH9tHfTDuM6/b8F27Zb37wc+uH/uXF/KM/uW3f+++91z7+ay8+87F/+9lnlr0CxmKv9260DWVqTHH7f68Qcw4qM5tsq0jAtKKnk1jg1LtiyVvDUdU2ZU0zCOowBVE3gcTK/BrcupABsAGHfQH9EBtLf6X7wZz7x+OWR0MdDw1DYZ0DKxx4NS/CTJPSRBagPO4xoGEoP6OOz5kcG+a18q02r2Xc4jE2K1Kp3gg5S4mzaaJOTH/mC8ntm3C6Hqs+Y2YmJJoam316xwlHICM7dDVaELk1OzcAH1l/PZsehHwtsqznbbaRQKRuqGShTmJqCOJlVYhumABXA50fm6kBZ6LDFtwbAk71ZraATrjchQBiVYnRyI0INK9yO7kQNG8EkpKiRrgOi74ml4hrWx0cIjWrW/cWxwHl4qdoLTww5zZX3GgeyU6VRSOokjAuSZRn5RlGkdRAyFd+b9vICngMNKoNSBrVaIzGJ9GQ3Y88vG2K0UI4O8OXvQtpbXWTW3MySiXyzE0fUtW3ViPgkzxNI43fcH8MCBqbS3Cj686Rp1KpOpB/S2oEa6wVs+QkH2Q0eGOoxJmJqrgVQuLcX9gzqd+vUKbG3pIhQ9/dyKYkx+2PxjCstfFsR6NUw0U1IsWD7W9FKY11NoZHYhhUKyEy272QX+HfpoTBsGJ7yY90KCkVLUh24+1FK2uXeVKbbLFJ6gxXeJ6buEMFetWNbeSqhvny1hXZCE9j7Tew6U2b0zDADI8IxNdWbIe9jo9cJ3Ho1KY2Um8rtxTUO2ioGsKk1gAvjsSGit1AESIzvOL8kqqb0S+88qQY15rIFKdAIAHr9PU9FN7GsdqFV0EM4OhcGiO9Glll0rttEzFTi1LwzBDvNApc9UO1rUj1AnsZCdB61uyuiw9/7MnH71z/ge8/s2/5ZrOXXqoko4MQ/Z/OjPTEY/vPyGO8mJP+T6deXusr4X/0ik047hNm6cKTnu0w4+kJydd//W37u3/3MTs42Nkzz1RC8me9eqDpP3N0/4ldurjawd7Ovv09X7Cf+okn7O77n7XN0N9jAAAgAElEQVTPfW7Pnvrczi5evPef+17arq1LxN7ACLB6uiRzdedAlkK2sTMoLKnRzw579aH8FOOS7DCrPvBB7K4gFwOHc/1VYb0QtlVJibXWj681A3qQhD80Evaqd6LzlI1yCC8sFMR3nQWgVFSGjBmx3FglwqTtzkqktLRbmZraUbltQ+dhoDWkF/dd58IRLDUPe6iuhp4QTRKYtFJ3IYZDRzC0O0ZgbeaZleoQw2eDXETCPc6MGX25s9Z5VsTzisiwlOa1qroc48C3bTLM2gHlh0wvKANfxvkwvqw1W+Z5AATVJbMfkdUb+RCQplXC4Knl4ClqEnYrxqOswBxS0cT8+Vq2wXF1ZZ0oXN2ggexfcMEg4DawlXHLx8KCMYE6type1P1vYXKjXth4SEoVdBXTCCfcg79A0KFeWFZgmEKIA1TyF7ZHlOJqLXGpgfjvm2WJkldX/i1ODjOxyzc+CwXD+JeCM9Ymlz3Bdk2iykksIsoaiYFWOWU0Ase8rKjm14RuYMz3g6VKG0pVAoJ41hnszIRKsu+tQDAq0GCBoxkoQFb645Re67joQiZ2NDtz7rGUKmDg+qPEf/yZ3OxfNHWW41R5hyZQySjV41jyuJvWWHBgrF9A4zWamS1Y4WqIN7DMoSNp65i8UheIKmPPVK+ouJkhKdnkhvUXPHzx+zn0FI2dAhsOOqH4X0APVQFQ+AJzP8/yPEzJbpEQQPpZf19vONZ8xYeRHKyTPG9UK7VhIBCc3dEn1GTA15/NwixcGtoGpmFt3+r9+av5takroH9slEFBwn1/NTblgnEY3zlqxY8nV2Gy9+GzJq5nPzjBoTsLN+2P5IiiZB88wBScIA0ojYGCA/XSwYqGrGu6LObIz+v7ARaqRRljDycatHA+QhMAuhPfc4Vn0Vj/vvGZbIpKycGjIySf3j623Y17fuorvuLu537oB0vr2c//foL2f2dCQgnGF//T5R09MWkqdV/760tMz3yyXV/y53z1L/fkk2bvfveJ/diPPWY//dPvsWvX9u2uu3abwun869nnzb723af2v/wPz4072NfaQ1fTHnmr+YsvXs9/8LN/YEd3vWhvf8t7/9HZye4D7scPXFiOzM6CI05quzW0PIZVl8M4J0DBJsJNYJDkEAX1Xb9Qjwl8sJWdZhuy1qXaU7IYBHbH0f9JpnWiRTDvCGuYzRrJCaaUEEg9D313zpHiVUAkPRIKYM1wQQKglptTE2f0QqRqs8AHVGvoNgIkopbdpOYBY7+psgKKWLkxR3O7UbPJSaI2zaDdqGmMZGFhbG9l80oX0XpZY1AsYBBAKEIWECuP80ABLgfrwlM5GH/TmSTsmPgVbZU052UkTDzekapSoRmYJoVT2CdrxnYSlTiqbQkCJB45PJVwoQP2h+lYfYGS5zY6leOx8H6LejYCzhy/R84euWatuEYCcuurNfTx9PB0NhhEI/2NLgetAlSpDjZq9K9MvpLShdzrX3TtB62zAQtVlxxQeY/7Tw0CroGNzyHMU3ZM5Rw0OImGmkaOqESZnNlq1GvDk4zKBBxaG0b//yfuzaM9va7qwHPu93tTzaXBGmxLNjg2trENuMmCZpEwrQYas/qPOG4IdierWZDVJNAOTboJTSB0N90Lm6RpAmnmKc4AYbQxtuPFEDNZHpAt2bIkW7IsqVQaah7e9Hvfvb3uPXvve1+pJMtT+gfPqnr13m/4vnvvOWefvffxbtcENXY06HADiA3i53A/SQvjaeYcVBcx1unOMaEZhf0VrU+jcgj8GXmRihRD47DW600szPlbJqKew+wNCSNWTDgI4vUN+x+AVPAjg88b07nxRKXQYg77xwnZUgXN8UMz+tByK+LOgceKC0xspQJSLKSMRfge1l+2Tr7uTEeDu97krCIcF6JQqRNrDVaGqXQeHD6DY80MI3wi+aexcNy9yV0jcNjs9sgBDS3Klkerl0SMAO2rOAXjXMrq5IPtBBeD5jRFRrUBB8ZlTeieUvpVDxPOcBBPgAd/IWpRs5ockop22uQk+5TSG2ns0RXucAXcTB8cNJ+CPl50JGGdDaOSybbjpI4QQFLfRydDp2Iy+o9hi7lYWfWcd+38Exf2/u0b3//uJ+5/1NJKWHLUq7OzE9zRmmiwaXW1xzx/+tYgT0JG6hNRjjt+1TdTM6IKyRBWefjhKsnZsb//9z9ii0XliDy1/2t9k3XNHz9W7JpjxY4eLs1v5J57rTzv1gv2j77v/fbGH33Y7v2jP3vgvX/yyKb70qY02UpaAL9tio3kkTtLzkRXbmc5GKc8vpMce7vQiSa69ARuW31aEsJqaE/Ja6A5OIyRwEpVv1dakODQOf24C9xtmHzmPn8Ip8/+DiB4DGoIGlkotNgsFBRzsbX3mmLvhPNs7DVVEEIJkmQY9Q1PstkmkB/8yAIcJPJ9UxNLXqV8p6nNDORG5WaKJU/z5RJuoWz1J54OcSLEW0loMIC733OfHO4ZGCWUG22mNX2cZz96YyVmoDBW6OJRhUw6cXBPk6wbOYpPHQJCCgQu0qDcRHHkfZBgb8IXNo3RCSpBF8pgJ3JIQZLLGCDV0AUGLSLuWpEbURgBSw0Y4x8xiZ33x+WpROZp3MbI5shCBB0ocdVgq6PxQXvXdlC3dnUOA8GW4vbrmR19GoDC5GYyNrb3n4r3kg2HbCpR/GJAvSUO7iym9YDo0pnkJWyXclf24n+iveYw/0FLT2n2wCVPIEtzFBUJzZmhMnKJTmSu8XKSX2IsTTQ/WzM+BdMZaKbHONYcivRYn4mfTzYl2TsgB7s3MpyxEFAk8ISi31jkB8nAy6GbK+B7DygPXMYABFpR7qGBztDHMQVhxYMbEAEt5TaIBQ3DIMQkKnuIAxT54xYeTzT3GuNFlOM1EUtcY0ljo8CWAlG7JiUzU49gnKnkw00Wtpm4vxnxwjISZJOZ9qKxf2JqkRdR/thTpS1U6gkicOj2oRIaEyDB6lC3gglLYZCgll4zphx2PnGVYf0BnYAMIIvvSvO8HN77GVTl3qg0je1h9huDOxKzVjVdjPweihAwUbiBg2hqt8S6tD4d2oRTv/3t/OH4yBazsEsmb8Zx0+WL52394OE7zj1x7vTWztI+el/Ye9S2TI39NRnZ3v7Ubd6f6WMfMuLwAqnJyJWZTU1IKgxTk5GamJBZW/kjN920Y9dcs2Nnzhx4kv8IH/Vnl3v2JDvZOs+xwj+vfOXSzjxhdvu7H1/+zVd8wZ3J51tL3l0sVlLJe8h02zjUsO1KnGVNqTX656ylMzJBRPPIEV2pYqKRAuYlFsgqI1XBPDeZErIx308V8sc705VD2jDTOnMQB5/S3LmFEOeGDDM3p0Ay/LixAjWJEoGd2NAZULzA+W7FSbGOmf9FmVmcvCVGamdZbdfyINEXJzcV5IATuLrG1CQ4j2sMLJuYkdH6ig71ELqF1D9h3iubLfGpCYlODPQZyH473WQj0KS0BlFqPL/r4rfnSbyS1OkYKMXExgSa4FwJ0RV5dpEjOBSOyg8CN0m5t8CDCJO9k6JkGxaanqgFIjjHnU7N/KP9qWFBNcqnIGnBLG7f/NPcP1aiEqOAxImOU0Fq1Zh3EknAgGpOWISEEILil5D9guhTOCPcJDJL8JUvKTSPoKQqTzROpXFKaJwlKZwhkcbFS5El3dZsSBHddYoaUD4cso7ik1o02VM3u0NW8KzVeUYZyOFOccxAKQN/Eu5AUgTZ4NneB/219YrilipRStEYlFu0K1KRtiAb50eWBzm5JqFqKDBDAR8Bxvix/xNsL+EUxOn3pZo+OEYeFNIeyajX/ud8eq0U72q4on+KH8wTMOCiMMTqSzglsc3oDjkt5YOZzwYCJxrQVWX8dYyCrowHeac6btocHpOBtmL4Rk9k45pNXPQBR2oJcNRFdNRJSkHuhQ+B8t5ER2k7O+nCUJSF7ClzWhfPBHON5lRd2O7PbKCuY9S5od3ehMnhPFWolyUC1khsBDe0UoqGXkZ2y/oOtxF88XY5gkUj5xQ0ISdNPSfGwe3LzBc5DfByupL012dOGvJo1BnhTuGcQN+amDbnvDctdy5a3jn+m9dcd/T8xdOX7Rd+ccW+8CW7dvRoaV4gPOk+V49n3KZptOrcf2b8+cuXk+3tyaXpaR9XPu/115n99ptX7b3vWbNTp3ft/MVDOzcfO/Yjl89f+op5rRw/cPBYbrel7uemsWvmRNEfBvCUAzUjigWrJsLx8s5wnvRkFdvQr+5zSWgDxvJapjMmdQHGWodNFl3DaEIjcY+poODuLeDPY1Mm8kWdkyKYbBPpJM0fEwcw7W20FAXmGZszJ9h6RAIwtH6hBYk5NaShBJRZn3PGPFeUwhBLKBdC80t6zkB7ixFN0mc0WWMVnl5JZ8lIokJXgpw6Fdrs6suoUhV3DBR3SRJQ8RL0xyq1CK/yRCfUirSKGr9cYNfFjnNQTNlstf4ppEpGocU5GihA4y1D8ZACH3KkqfDzxowgLEEiuwS/rHS7JkOmnAun+QKiqC8z9YBOU0wi31oxLeVsLkrRTWL2buQLB9yXCPaB71x6ssAUM6oriac5FVojT1kcRHKZ4dOGOTvDeQXqxyD4DfQgWRc4ADIBfkE6sSt9YQuLbRMX3YnVuzxhp6Fng7AFdV8kuiCaODs1msEGikK890aeyfuewdjAyhOr9Gy9J0bWKhE8zlrJGNmHs4TrL8KsA0YDrMA1pQF2pAwj2LZeY7uTGXMbekgsGNfAGTzBie1ToIjaO8GqcFdiyZ3BCm73cwpKY7tmaJrNPLFwAKSMFjDUz1PP7plJdV95GPHAUQ/vKRtLpz6CATLr5KX7mbdnQOLXO3FGfYhmkNdVB48XNllUA6J3JUUazXWBSjNnc8Y5hH+oKJOT4cLMSSYLLQM3jiYXS1R1Js8IdnOZWWTEE1Y3GdMCnKWv8j22s3hShmED77xQ11KEAmniBXB0Wti36gOusOHqbeDINc1eNq+OpNne+v+++z2f+MjJ9hQnHtqzD91Z7BtfFSTWq+UFn83H52Q2zVM9JmiO+VXJLhX2+bdvyvaBv9qxhz+xZ5fPnrV/88Z3ve/Ex84+aNNu2yjTYgU8VvTpmPYXdl/VNeFCxLEFK2ujM3UhwSPsNbFyk2ZcRhbfeFrxb4kSPpRUuWtKjCxVdla7oKbCkxh04tRlYt+0iijI65ZV86UYjifFdmEUdigsHMKfQr40N0/U1H06DGmnIWUFPAtUpu1YNhbQ1gJaD9Sx0Ixo2DhjrDAOYcHFduFLJNYn4sOwV5ij6Elo74p3n1io0loWuykCZ279GTTLSgqKWCEDhC2YYJGRh+GUaJceegnxEFdq+CWZ92Sioe3vrHBLT/8drYSUCpMapRTGE6E0BSBJ8/HMiSNbI7I0E4jCAT0ZtLXCEkZ3HH5Lc+7zQOCZNfSYmcwxT3I1QhpcD4jCQbzJAX8giSuCBGl+UrA/gnqFBiZsAMELjBpNN7Z7QQUnR7yM0sDoxh8eYkZhSUCdQvQz+WwZCH+ALrK5lAJRRZ4BIqDXH6e6GJer5vLTHnsEsmLKGxUoPRIBz0qtA9M2PmaCWE/ZEZWZRsbyd85uwDtzQpRSdICG2hphcVYEh7VA/R2/3hjUk18xF4mHfry9OqwrlB7UfgH2SKnh7hlsSE2HssK2FrKH6HBhNWYmDrDT8IB76FQNoQWWVsxeoXQ1QwoSGWqG5W5TwILu325ZnkyxN3YRJkCTWcGsBqdxc8+J8S+jJVPrYlXAqOvShvMpQZHbPkAf91ysv0ogp55SajRm8tjoY53ZLU7sxFI358GgQorYdMuAqIqSOLR3S+D0zmHe4TMda4WH7SIBYibemrrPbNsrsn7uI+BN2kvnxD0MFpNrC9P55ET8JUUksGbEI7V/QZSNuW0tFOXZVjc3z9uB669/885yusOnbIeOr5n5up05v2j+YFdT2X62H5+zZKR+diYdDoe2aohyqDJu8fWs68xOPlrbPsmmlWLrB8LI8LGHz9vRQ8/6mWlKW9ubm2nylTDtsrnSmjNAchuPF886BYwOGwQOMlySIw3NPVUx8jWoC58omyoxADZr66IAYwGQAJolDvBglaBUnWd5F/I38121B2OUcDIVOcAEc2PkGwTtoVsR2QBvRG6wWqLJ52EAPxvxJYvU5TGQDwkSXO1dOlFCOB7JS+CxTrF8iWajIXrhsjp6oMjEASo7QzTaQKjyXb1bFPTOidexS1PuizEkGcyLIoWIU0lTaAzvP0ETGd5psPVntwtT8FwtJ3Ohu+6aHsERp2aMfIqUrSxLMXNH7ej+Jk0ZIm6+k2pUSCguIVJBSuGUJqFUgwYXvk8cuDZBdgVZg/f0rXFUuQYc16bEBEHUfG5MP0E2lIZEtSgzGjIc4SWMgXewd0xx7bwAlZSZkibZJbXcePWg24lLQcfMYG00g08sDlRYSRl1B0LidE8y+sT6LEQ5cZeaKCiRwzUEVyYiVPhQ7184z8ApJoX+PEEkUUSoKi6sLoUOh10EdKQ8DXuITVzekfDcKz6RiNYT/oAJ4z9KaAuTp3H2VqI3YxkyMXLBiqmgEK0jSKYTVSZOu/LoQJPEmopmTjZXj7oHcwg+ikweY5IfW20OG0IUNeGt5HxbQVePAVVkVQwaYJKtyrCMnWcHFLMeUA+cYcjBidnphS2mQuFyvR1Z9pSCkIesV3gyW9iFPViYHbZUIBDkFM6j+3TLamB5tGbpQ9dXKQJLU0FnCHb6wLs4BZmPmgoMY8uIrUkvejFp6FDRcTxE3N85JocVlit9cqAxIFGT3xt4MaGTMvb4nlBXDNFAXJvclnt+6fwFu3DT0V9Ye9GNTxy++Yhd88JrbP3zr7U/ueMae+xxs7XVTx7vaYiW8ydv54yGaKwZFjpbS5BMPxsZUM2WVxaTHT0SyF9NPB48YfbPf+qwbW0nW1+LF6mkmIdPJDt4zWSra/Gm1jZ3zdKqbecbfm1399z35J1LL17fOFw9haqOtLDgYz2mNDIWbhjp+jBinOzHSBsTxtdls775AUA7cQ8AmUXHoxPXkiAHqnF2z2myRtAmqeri/6YyII/EPZLcMcxNBb/Qtc5zKqJZBQHMYFEp9QBOXK7FhE6LsZhrG7znUopa4HuCW6Ah//2DgtKnbmgmysTZCELtnROA2q6bgDEWtPeSqBp8tyTwxBjsOJ9TVzsH/7sHq6zUk4K0woiW4/2P0OawjCMsJ1D9o9WUSffTPUOoBa2SwRGDu4wcRPiosc0kbF4203EPc+FYCOvtnmzioRr1jGjCkWYSXAJTdSRuCHvNdQeHB5LTKhyD8JgMZTJoC0keNEVliAZ2UNBW6QC7GccjOqYMpT4pNZleDJ5krSjoU3IxoNyMRjt46J5gL+VgxkL+xXCFb+5r+ekSMDygv0KilKn1NBTbWTgkVQ683WAmx7xShFOMyyyZg1DZWoALK6ueTJpXv6TE9gePMO7f0t+xmmCIjKRHZwzxGwI4CVhBHm8za8L2DGpptQDI5yoYzYO8icyY0pcdSob4eaU6btof0RQpwhxx5FThSSxyNkfU1R7iNXsIBoQBR5mLFNbFe7lLppzSEyZgzlO0LYKsvmOrZvR5k8b04PSNM7LFv7i9Tl60Wb/8cf7Vo3weCK2OMR5xATiP07h/2IJnRcOOP9NgTXw2crZyu4yepAWW+JiQE5Eo4KEIVNrs5Px0M+WE32YyxDuN85w+Z1gIfW3EGs4ssBqiDCMGp0ErtmS9LIuFpzxv28rKgbPv/LH33Pfw+0/Z2sFVW24ubT3N9ujjbptbbkcOFrt0eT/AwLOTeQNVNJXwyhl2HJJX/0yb+PozlX/KxIUjYxYcgld/qSYHlZwag/CeYeZxxaM+T33yP3/Pnt3zPQdsby+Skvoa7719PQ4rVDj1dQ4eLHbsWA4ifCl26Niq7W6bvflf/uHmq1//Be+/+QVrL96bd+qc9XlehkQcw2uJBBOON85HLNSI6vDwosoHNFAcCEkHGmxnkuoQXWysoKwZOAUTpnRmljRsA53faM/xBHWYAXqo+q2P1/ZmjkCKRypiXTQlJHlQsRHT0IA1MqqN7AcNvcsYOxywOPNntMk1WA/Yj3EgqxV6ryt+ZBqXkppfIM5kqIGrZWxpJ5OEHj9R3aTEIx10AUR0lxvkyELUfmFVrQ4buuJO73kABt7vGg91sHtlvMzwQFs2ndvqVSTFQJnD5pIntmqUQjkb8E6xVBHPFvhnH6cpqLpdpCDzJw1MLmLYMM4D6KXsRW5O0dspjeIYFzZ77nNxS8/DgvFaaGxdimzLUXL1gTe61HwJGxx6M4dmU5OhBZ2y7rvBOYMQmJL3GK+iPmbCv7bRCIBsOMyMwleJeoE3NWxflQFXgI56GvEJj8duZQCJtY63DsQ6vC2Ad0FyWmk2KZJg0I9SIYxN4DwnzfAu+5CgwoSIdzCGoRZlJkPEskzzvYFmz3pFPKSqu6DUzQuhOtbcsNpqv59A7UnMh+FJ36k0WIIWXVZOxC0cXdKdAErpTaJhbncYymAyof4tw6aJyY+Jtd4y2NQLLQIX/ISBAZQQuZZwO4W/UWweslIzxU9OwNl6LjUkokY/wsIGBD6uLJ3JkDAaoccY1KwDOhg2WT0MahRYnqWuTyrh/U7+SPDzxGOJT50zueewl4xhm0PnKTB34OxFbpvxv/BtIDco3O44eMB50Tk2Ffu66F5FUh01cjsuU1FfKM6qwIEmT2XOOVUOSU13z188bwfXrv3xx951+0efuPcxe9ZzjthybraIdurUZLd/cGHf+uqlbe2YHdiIDkeOCNNieJ1ZUw1Ra7JRj3pawlPoUuDO2ibzNs8yt9/6rWfb5cttXJAdOzbba15zoo2SaVlJ/aUYVhPDbvhEn4qMp3bWTz9xwK6/8YzNi8ft0UcnO7Ax2f0PuO2cm+zmz9uNkHcFhDNjkt9yOduR42v20v/yFv+Pv3ZfOf2x/IYbn5e/bnv30o2Hj1yXfd4r2CHGTgZbHUzNWdnauCONs61C+x5FY9AEnbypfh4IHPUYfpWAmxCYx/HPabICDaz7idHBK9D4pmWpf5gzMFYzvRAIRwx43k8Tiiw56hKLyukxn2kUroOxD/f07pUQOT6Vyt53a/FhJ+G8xwEfGBMZEcq62bFCPiY2Yw94tFYmYpVxNVwpDV6qV0AqcNkDQWQLSZLTfjWN5xGDG+wpZFsEzkx0wlt/Dpw0Znc9YeQ9QE+BhFcOOsXE2JkVCW+a9fuDWby9DoyZnkXurWQvDJIkCCtS81SrMibSnqz3z5wGHsCXS9EcK8iwWw9djnAiZlI1QAIFjv/Uby4lp4Oa1nrsUmENe9g5+nBsKMEiUwuzDI6jxPWiIlMuSRdVrYhGpmKfqpBoSjo16/Z4O5k2dIldJ1GsQzfaSc7EA9gMIH5m0K+Hd3wMn+yNUxi3pCD+ku8xQIONBJoSc48Y5w2KPOhSE1QhWdOudRo2UzoqfwmYSEEVby/3cCYua8uv0U0ElZupR+LczlLIQJG8A35q7M5GTpoLxyAxdgFDw/UCqIh8EIghCCbFs3WBB4FDY2ZkYySmFMcIJZOLqcWPut9Jq409zlEZhHaK5OMmmrfRHwmWvwQYHTOBHDI947AVo8Nr0ughMIQzhWtWdPownTIEakuki1KJzBNJtP6G0ufwgPY00tMBokUBiuy5cZUxUHQMIUKajOBRP+QBODqbMSAoBfQcMz6Aj2J9ksWl24AjJA13xQjkNvf/tEzTYsp5a0pp9cJbf/6Dv3vx/O7y+PWHbWdrDrZRMzrL9vO/uGZ/8Zcrjd/J1kp9nDvl9qKXzPY/fMe25tcR7ajJB/9ck5MKdDz4IJMStzvuOGZnz67a+vrSdncP2Pnzq6apvYbpeRViuf76yGJqQkLX1Xm2p33UROT++w/al3/5KfvhH77PDh2abXsrEpyTj7q9/vsP2b13rJgf7LT6Kx/1jZ8+7bZ68Ix9/dfv2jt/9bY7N67/krfc+vLD3zHv7S5WV1b2lrs7BDcYDoHLu0AOtnC6fzm0EBECNC4IqlBqGpDfkgSXGFapsU0g2bd+IcJCtGC4tIjswdWtkDqPEr8Ma8LCF9C97z8xjry6tRmmEDcP1WDBQ4EBe1/ssyYyEcKPWIiTe3ArAcUPZ01gFK18SLocPpyZUHjg+dnS4Rh3NV+7ZNJY3lGKGl1EzOk2BQ16cZe8Lw2Jp2SPLArcTEQZQzFd5RiaqswP1CkfhhaZwGMkheiEF4FAPmqvlbSyjCqmvn34Qsr3uTNhKItQe8vIEohGh+HWBLxMeEDe7AWwACdnOdimreExYy5ogqqzKH91ObGyoxUYWPhnguonMa5y3vZ/08gYodYvakhmW2oqsC7vvRmWliyGC4p0p5c5ecl4m6IUC9EIyCrRjYnNMSSXdFYwyEEa/T8jKJGiR+i9OEqJmOXcnVP0Wh3HwJpyQP0c4h97NdI/LNMhQgXlqPc++1bnAme8pK4VASWrwQblF6aOOJHIJAqyZKQFzF3v04jgM8Mw3TLkDEZxps6CfE4GYNq+UOupNDy2Uk7MJckESYW+7abxaokokvOn0AwoJfrfGaItzc10VVZMFagNCasWXI0ZTadpRjmfmsAnSCsx/y+UMzy8kf+Cu2tzO3RBt5LesDm1oxYIBm7CDeCROziHMQctQPi8e9fEjAcTHdrCdihDkdZec9KHMpY9hQiFNFNoRxG0IQ4bi7o3JuMw5UYjl1Z5XFz3tC955lGFDisRS1MLhviuF4xImcKygjOz2medPftiZcXzvDddvHDOdi4c+tG7bzt91yu+4vl28eJ2+tBtH88HD6+1V1q/phqfuf3JH3pob8vwlRf2whdfsmNHzR58aH8w58T/+mloDc8WU01ojh/fbTnD+vqera9nu+++g0+W9lY/kZr51Al8Vc5Tf7H6gFS0hAjKlQ5rdVDeRz5y2F7xivP2hvHppAwAACAASURBVDfc3bzpTz1hVmfMbO9U+W6xH/5fLtq/+rkDdv6C28FD3Z9jfNQ3v7sz2zd+9Znyd/9Ottf+3W176J71H37ui/b+5tby/AuPHLl+WvqO75WQeYo11FzJnRZhqIO4AQOSiCSxrncaUpXEPbPPYLVQapCnNtqSBw7n1UPmUFKeYO5gw/Q79AFiZDjb0DW54DmKGNU2dguUw/HGA4CHete3ZkUGzMxJgBcNrkJN9hI5U6E116SK03niij4QiCPoqpGizKQ7OYGYEiAhWszK/FyCFDAZDBUnvL6HEUUCITm0AdGadKpCOS6GPRUtWlIPMC1QQ3V61li5zG4ceU7FHUt5COrJ+Su6dgVmILCTgU0KLQ6MEpdmYZ8S1K2zrJYaJNfkdXWkd/+crpnzDpIkLEU0y1D/DjZodYcj0zrj9xXCHLrODj7xg5ThcKW5bZnJy4Xgk1dQ4sGAQYaZOGloEXXCTe8MxB8TIbscQGHpuz6VRFdASiQDUfIRRxSZVvoDK0z3MVIUxzjRwdgHiWRVOlt3qQYTdhp8OpGyXp2gUKUtCmBE7+/ew1FFJeUe+5fkTLX7j581On/iuUEARMph7IZmmppj5GFAJQEZBGueZ95Mxx3jQI5S5FJFIR1t/MlfLmjVdRc+gY4uoRnQpsR5iHQoLXx9JPy5p3xTgj10xjzdgkE2YEy7k/iAUgqjWvpkS2b32u1yCcQoXVDoYvwk4hG4FF1FlkVki++GH673xluOWc+8Pb3cQj8toMQGFZAm58LtiiMziSPDIZch6FuCFNiONvh1JFhbxz3Lcb51Bwar+py2ZxOHV/ZODBKGBvgg9cdn6qPhSX0CSZcletfrW+EuJCO2cFWo+9QBcR1zOAZa9ZNSuM6Chc/ZfE1+5TXx2rWyLLtv/VfvecvpE+fs/kMLO3Fir+xcmOzyhaswUJfjX5K94pWX7J/+wKY9+ugn55o+3b/X/OHw4b2r+4zUOFqRkZocOJQwN90USEn9Pg3PzMicdXvVqx61b//2h5pct8IxjXOyjP+ePB2ElR/5wc3GzJ33rt7+qW+4/nyFdG6/0+xj9092+wduO/nsF77k3S/40uMvnOdlmnwq87yXmvKTDGNH64A1CkFYh8GZzL8zBAKMagU0TBTiWNvR1nWi2hEJsqy6uX7DTK0T4ZEL09gJMGbJcEguOv1ZarXaJ8VBwE5+GS9GG6yZXUPPjKKNfmwVOPZZh4Y4kMU0EQzxlhXykHUX9GvQTaZpLer+3pgEHtEd5VmLjQaHLBlJm8Fgiu4DUoa53JmTNxi1spzr+k/HkiRDY2igYmey11voKoLUSnBohorUyW4YLCSVAfY4WQaSpxmJLEmIsCQTIGkWVeqZnqBJGaR6JbBZxfXTDTamvl3exSvH3ptldt95bKNhgm5IQu8DH6nw5jhWUOeCUPLhA5bUZYScKOJoh3nU5UaZlaPp0+WaBLmGCG89V1fUJvMRLVB4fehvRs1wM5si96Ee806nUFTVZWaW4PpkBBWdoD8rWtbnbMOGs3ZAz4WoHBZmQqqU85P2Bxg8pUN68MngExQi4vr4CqbGYc20JuvID3KdpDjcrxEJSmDiel9IRvSAL4gNRw5b+PfiEmXtisgbsEoyffsYywrni/cFJJ4T8j8NqywiG/Ho5MnSW2Q8LrygtsHayoWcL7xDJACl73VIurzXBCaW22TqgzhRaAwGsd6CZBoJdlvR4dakehDVsPll5HGP0GixfpiTWAiSWDtj5dDkqD0xibjsm+tMzgDyj2BKcTjxKBnsOAfGEGEecO+0aMSd+uO4dSVk/OwyJ5G0sQqdCBouhqsjW7+qs/neculbly6ZLw/82KkHL9yd56Xdf9dle/kXL8tf/9I929x86gSiAhZV7vu610V2Uvkin43HJ6Wp1jdUE5Da96mJAqfz8VETluc9b8++8is/0Vo6dWbNleTX+veKslRkpSY29edW6sHVRS/GZbW7jESn/szNN8328PKMlcsH3jDvLr/50t6Z4wcPXG9TSEXFPwRqVVxaQ2wKOAOSx6bWNjjupRsEwx2V3FMjOTHPQQOpNXL23nWJjjXMsEJsIw9PYdAF9jRWdASjpSSlTZFPCsIgcYp+YBBxoacqsIJgk0Eyk5ChZLK147zgBJ2G/WaFKafXN/MT8QwdSYR+rJT9bUilCzKEpfzGxDuXzYMI9mwS9USOjMV+nJOMqZLP4BKT2xmVoalMzQw7AqsmoWAwv8O9sRCqtPB0I5qKPAg8PCWIxkFTTCw64JF57HMGBFswvJZIH51zxWNMJoPGjDYG21Hwx2OFxAWpQpfwQUO6EsrrolaYRtkQMqmd63ZRJye6O5CLqaOQ25OhuRhrM4GVAZErBrwa+QqwCS09U6JiMXAAJpDtXyalor13anD1MnYg2/0D4OMYGQdrzCRWgFMBAzZYwaw+wC1UgnOODyknRkK73KeGBNsMfA48S8Jwozk6AE5bTuBsjQ9As+3eSoxpebFvp0r/qq8xN3przOKHR1FS88LkPArJNx1ycYEyR/jy/Q41VcKQ6p5AGpZAUo+zkAXcs0R+2iBPMguFiU+aelXQR3ajYJBmt3et2RuMS5nAO8a6LexQUpVlGlgxJNgzTrY4PJE2ogtI/SKOvXBLwTolA4QqBAv35LAYYOERViFkBSG5zdg1OEow+VMCLBLserchMwPMbuLjeIz4DI8dKtynqNaopQKKYuiTZt1IVYBBWjd4hkekKsP+KKwpwPKkgYukS6kfTLgZTJGy8Eh6czaNGBcYnRR0fUvMNmjPv1isFc8XffvS5sX/8MY7f+XRT1xqb/lbvnXLXvttywAetveH5vFRY34FDGpScvLkZ88e/hlpZuoVZ/+Hsp4xa6rfO3Pm6VU49XeafGdRURK3hx462DJ1Tu/gI8gv2TY2ZvvH/3Oy647v2S//+7/68Pbay975gi9avibbEV9fX8/bW5s4V1y+5C5OXXOtSGjCFNYDmcdZAssuMydgsxMHfh59s4JUzdwZuEmUbJ5Sro1Qlo9M+Hu8TooHHjJO6yvLIQ6hYYG4W3RLqIjJXJrPNCdsQ9frOkEjQUZDWmEU9Xx74kxTIqQRvfbuRrEm9DuTygWRRCay2TGoIKYYcADGVCpN2ytyskKWsk38b1aV+O2CQz6wU9o6Ul8XfHCXjzPm5GdoBRMFVRO8T2ceTlATYcQVt2msD07kTRjEgyNqMqYx6qYEYFYyWBnNJqKeILOpyK1WpY3q4T2zijBvyScOz2e5MiCuwtyI3XBIH4hpDWrniAog9nVWZ5znrPhTZNNTL6YKYyDycCu0So1HqBhK6ybnIPcTvOFOlMEuW/8AVQivFNr3x9XKKQ2Ac+H6gjCghaxJuRvO29LcIIdoOqlB5KhCQbiCMCxWYKbzfnPCiwx8LkyjO6NSpXUg9m39L7zOOi0x2b3tl2kKymkjcCYqOmRcjk0xeIR15nMOyqepnOKvzbKzS86waUIUM1ADCTITtmE0wlJmuZJjpELjMMQkleRsRKPkN2al2MvUnxCn2Ofbg+MQ6z2jYKoVFvtXnUXrlI0GAlcHwkyt3MlMNaPKSl3chzmXObsUcZGfJmVTVUJIpy5WTAwlcesS8z+lVQkNXEDGLWOKK1LafD6clUCTMOKHBaUbncoI712BO9OLm5Bj6s3ckKph3ldcakoSjTBUhHfM8dEUwELxAAcnSLrI9TPo79xoJxbnt7L9AWghU464ZOgfw1s56ASYfJLoaYUyFuJ142yXGOy+srZme/Ps29ubduTg0R/cOnXufrM9+4ZvnOwfftfSnnjC7O67n0zFKKX/vSYhtQNS59ZUcKESWz8bj09ZwDsSXvn3Z2JyMj7qh3rwweN28eKqra3tZ8bWZOXSpYU9/NAh210u7Vv+1o1WNk/YxUvH/o9pdfk1ly8+ft011z7fF6urZbmz4xy+LNL2YJzYWctFphKxVFzcPx54akQW4yQbELmSeGisEHpkISGW0AB1sMSbub2tW3uDlBGflioOvmVIXEoPV+rA5wFhVU8F/ClnM5mlf8QraUg0x8GVBzj7KkzXMC3XuTNwjxMDWcdU1KPHI3ZOTLNEKZqhCUBvh25vTGKMp4gabMOC4sLneYi2k5NEQ99F1MUqMGyAmPm/HM6lUcQ8TAmkxnYmwZUIPWkQHB3LcKz5XWzPsKorIiuXaE/H28G0z9KpRkLXXaf/AIUpl9Sf1QCPWwv+YCH2g6ZUFeUQjGIpKWDXnD4PCqow2uvhbHhppk4FpvHUpgF6Ej9kwLSK9ZQ1nnQv+o/tNQfL5Nk7/AKWiLOfg9hcaDkcEkrXWDrnyMcZN0WpE00Hu60Ve0C4mDkaLKhdZi17bq7s3AvBj6xD+gvp1MVk6cL7RIMpEyjfMtbSVHOp9EPSxVu0nsuT28nlGYTKRjHI5OHDaC4wUHIBCpvOZcZOIRyi0DpgI2EuEUBGZg3SNw33mpatqSRycUQBoSpEEq/BbgyNegEpN0hMPEOsV2TRceKip1s2jNa06Yf9wRxSJb/OLj4mvgKb1qErMlL4AB1zLCb7gszJhaoBsrOZpkE9lWBPA6fruFn7duFe6wlzb+cy9RFYwdOFQHGOmXv1j3NIyrmlqTSI+ynbHgFGLNWmMt6f/u4YO3BOlegS5MkXvlhMfvHS43bxTDl526/f/a//p+/atOtvMFtbz3b/xwNYqMlG7YYQdBAR2rpfSBWmjAnKZ+PxabqJfPqPGMJX7Ku/+qGrPkf9oJcuJbvnnqO2t1fsxuec85e/7L8ob/rNh++88fprv+Pa5y1/48LFMyuHjlxTM7xS5gypa0ZLj7AowTj4JMJkI8o3V15OuVVGCmKMaR7fhYAQLeOknnUpPPuIkCvyK+bHiRqKAnSe5djkvfGnIwWVDFscOITzMGsdYEvmYcYfREBwvTArqHg6yBEBFrcebkIVQcSHohcUL8wJ2HylopFHgA1HG5m2Q5HRey5oXTA4xLAWnDCOuSEqLfcFuHhfhUCCmmzYZvx3XLMck/TGU6JHXuY+vVck0B8HFy1uRdspAHFgBkrRdqbNnSFsin+oV3TazZnQWr0LxgLjDDFj0looCW9Oz9Vs2HXuZOLCMY8WizwK4YzwpXRMObiCMXUOyGJJejQmBiT/9RNU49FwJio7BqcYtNJgPtK6yRSaecUTEhjq5+MScAxDZPB0lwRFgtJkqZoQOohoc/ScS7yBZLv+PGvlLAOvIYY1km8kJBowZvsqA67y1r0yjvuwUbFAxMecWitgdTKpSmijiOXT0UzrrHH+ZuTqrOi7e1VmP0PNBE4chPcKOdnY7XH1MHAE3TeMBIwNT16shaF7b//wTsQVgLJORBHXTNEyFaSF3rNy7fCKV4Q0D8VFGPU2vDLjE5QmejEqoZBmMFnHuoGFHIycotR1noyeMhNN3DL8HRZmPFWy1JaGk4V/GCCviBrQAXuAYikwkYay+D7LFiZh0SZj+UHKWfsAGY0SYqra7U0lVfUQAZ4mzDzglqSsMFOh01V+unJ63znaU5LMGLLxPnaLFYmKKYoPzVc2VvPW5rlpkbIdWhz9wT//g1Nnv/zz9+ybvtnsvvtL435ciYZUcIBeIXxU/mela9SEJSX7rD3+s86mGT/kPHdEpf6ZX2GMku0FLzhrX/VV52x17UR53+332QMfvtv+/f/+p7/78Q9e+KOL556wMu/46sYarcoiWy4uYamCeWMZJLZcYoFO2ZRCqAkAIiJRzoJ6m/IxDVdh+IMrRZkseXfMUv4TMS9BL8H+LZqpWb1VTB7BfDuvXWgTOBORH1YaoC9mDI1Qlg85TZtuTrVgGzdaYkhbikHb3DpE/VJz6EZNE4oWZyveVajDdCWh1mZKRDHgCB24s8rGG1OiomLa5EfO7WK69mPcSIWiHUDM8mUYTZRZ1uHWBvYU07Mx86y959SG2Irum+XRhLcMsJW3Tlb5nHbRg1pR+DatncLrH/zn+GjQ8aQY8x5XDEQ4Y94D4Vcc/LGOCmuZJPcYzpbBcKAMvQpr6/pm62dbqEqLOlTvOtZonkxzA5lTE8CGDXz9/Xk4iKjOabJUuKYC9THjYMlCaklCxxPrK2G9pkKeDpIftAMS3gMOVDG+C0TognXkdWrCGDL5CwM0gnU4Q7GkUwahfYoAi9jLCrjupUn01LbGa/eq+VYlZPpJ8lEqL5jf84yP60ubjey5tYLgdWBgh8aMkt5ascgr48BKIcwwBqboQRZn0yUh/w1EloosqpScxUDxrgasb2vq6XvyzqjXsNDUCUoBcDCwJtZLHAIUXS5iksyqYw2F1Q5NcAozufpWILbKCes9Oo6ZABS7xKToonvnyssAd0E01VFenM7tHkyUFsZlFteC+bJLAs7chCUTsCaFBaOuy9DKTNFFZA+Vp1w0XvtRH9FlCiSxaN6llk2s7ymkYomKvrgTaLho/5EsyxSYl3tIvdja0tmAw44HmIPLSATWCFSvrKzVOzhdvnTJds6svPsdv/jBNy+3Ltv9D600ikWdykslLRGRkSM6JiOM259NVMT+/0xG6oeuKAg/cP0z/74WEudmpLK1tbCzZxYt2Tj32GV76//z4W8/c+LSXcv5XBONTaurbYR1QoWLOIa4UFjKR45feFWVUdAKjIV+p22xyejRz04ivqN+yWSYKUTj90s469XHjDUSU2+ohcNKLIVEds+kOGIAC7DBAOlQZXpgeobZEa5P0ZencL72j+EH6nwDoY6LMyieM3PFEkXuaEvEnZK7yWwiLvGkJh2vZHUqR7Ymfj03bScHOnZMGTJ+1+A8nHMgU6SU+rg0KZE4ZW3ISTjugWGFxqWZoYfRsLCklGtaLJwE1kGzk+mGnSw01PUhSkqvyxHtTvTbEBai7gGfBaNijMN/cDsZsfuRSV8/yQL2PZG8znn1C80ImL4yv6MWWIi0qq846pJMkRKRLrm4FOmFWjHIYi3Rty9m7tAlZ2ClSIbclampQ+/KIYSCtHc3caA2sxzIxYUyGtyfsDakHSUBwTHuKAevS7GcMIABEy8zL2WUKjwJGgUlMWdqIaI0cpE4S729Ycx1gC421oSmDyGSgMlBlQsgG+rPClphGBa1T+GL+jiPwwBEe0yGkbqFOt/GGfJ+tIhF3LExxMJIYyvfpbgAA2cCEgl9luXXOC0H+wcIaHDlQ+PezqZUKdRM6Qc7O2AYMK7TG3IpToj7dOpnKVTFc0Orr6T73ODoXDz3E6hPHsRYOx/303h+sa4iXtCZrbpmcbP628XzMRNKHfMyiQK8b1Fxq1TDJq5zoVEdEkb+3uuxEtyhnvSQEaiLQnqjXh2sqfj5zCa84/+maWG1PbN9+YKtTBv21p//8I/82Vs/fMpsy97+NrPbP+DNjqM+Kv+D3M4aj6+kZXwuH4v64pwVSw+Rz/WL14K8IiA1E6NTW0o946rJyA03xEW5dCnb3/t799ujT+zaJz4+2YXHlydWy7Ef39vd/tm0vbmyunFouTVtL9rhVW2G6wTMHI430Au0EymVnq5ifnYwRA3tu5m2Slj5yPALVY2EbYEtwxZ1xmTZcGQIWKxgnpgDMWY17ET7NWLDyHqIYztRG8IVqk5r4Ig4lGUJZvQjDIQZZF4OGDMfMgOaMQy4X/NzzARRU06wtULPgil62+WYfRLxp0UD6Ceg18nGOTOK1QV1d9K+Fh+cn4+IcimaUhvlSU4QuqA1kIOEUVJSNQ8vjz7DxwirG7wUM3Q2ukqRznXDtODyh3+mpblLmuGk77DEYNnILlrxkIEpsyVu015BSmy1fsLTaa4dXvrGApuZw/jOwrmRgVemBalnHkaqDAzUMiVPbehQkNpS7zQxrYMtGPvYFg7TyIrDeYabkrAMUXpxwIItEiqAFJah5DwY236hF3AOqs0Z2DnK71BAutODbabmhzlpJ1MU4OUYEJu167LqhcJEpke+LAJuGFUhfmFCT0jCNbCtJPJMmo1WHbnaNhh87abC2bYN1wqz1y6jyrIGdM24KkNrqxB/A/uAVUqccoZ/Bb5UgomcwXj1qRR6ZxR4qEYTAQ5Z4N9OCTahhXI+3PncUR5MybPsakGqXE5xjeIggpksVWLSpdfOVst35PkfnwrLSdJe3Mg5ZiNTZFJw/Wgt3Xjo3EIzjrbMHZ+d4RT5FD/5bF0+5EzNXUMRpLE2jNXGziNZC16DxEqM/cjuE4hmfXWDa1584boLiN2SzFVZ3AQoleA7Rapk/HIiB7a+0Kwxj02aU+c6kmjWsT/XFGL2nipj3+aJBz9t2qIsdbd9sAc1v0NV1O5npVXNTfcwT1M1GF4pO5uXV8+fvWAHV27+0dMndt8eN+KgfeXf2LYX/rViZ86aRCb1qQkI/OdKROojPfe5EfirsVn1EanJSf3v1SAYElnGr6f6/pU/c+XzjO2ZioDU1zTrqp3691On6sXJ9uKXXLDX/4/b9vznW9uNv/WTt73p5H2X37U3bVre3VmspJU99zQH9imkbqaUUkEYfV0cKXNrwDob3rH8SsHI2HrgYzpHcNwinc/NEwHpwUT6xBDf2mpIubkg9uOp0Bln5mCQBEpsUBFUZrVqLBvKlyoQ0QnSyjegca3kSgkzx/CBOdgs3AVrLyoht8G0B0/9vMR1QIupo7g5GJ0mNNy7tbFYKgmIOitglQmBj0YQ52SSNpWnD+wO/1fr0hmjZxXrqrlhSwSV2jvOWXVPHEJNTU3XkxjykEnrhCahnmKwDG/vlpMD8cZbehFQcXaOxXQAxJk0NnJo3NTqrUh+5uQVAFEReRI+X0sooklDubkJ0akju/FRQ9HamjxYWvyMxdj6w+QOXMmCvDTHCWcgGhRohyIRRSqQSRLGYaZBTPSu7rgPcxJHDG/pHtLfkCmUrEkz0Jc0tWYmIoVLjzy+NX9abaHRcDKfjDSjrSGHFWFpO06hN6593c8cXKPsBvvTqewUijbQgsNIUwJhpfYad5tzYIZlQDe6NW7b34EQJbqp4gaKpBj3S+gMebtO+L0leTPbO2omogOYTX3axqNAVY+UvUX0XMJ715hiNdwnQSExt/ZgKWRn5e6qZUbJcPsufcIAd0TZl2ODtDUUx0xGk9EJ+ecmjEmhw0pkzCfCbQ16yqa6iplPpF+x/qH5RetQvI04KzLWE2nUJWzpPGDNQlkk4m4mwK2WVPXJmqH4pfFSJK61Xc1UBOh4IhwO9LM0E2uIg/pkawSCZGWul2jK9AjsB12c3RhknOG2qGPFaL/Qkug6bNDR/eZawf5pZwcEw70LQqo3jHJpukKCieygMAOrOXni9TNtgqjg3CuT7zXbs6mNqlvsbJ21wwfTve/45ff8zEP3Pmpma/ail2b7vu+d2wC8+qgdipGUemX8fqbx3a6SxJBbwoRneztxbdfF1r5S1RTXZKQG/7NnzS5f3m9qRsTEhl7R+FXKk3kfV36Nz8WfL9oa8W/VV4TwUP1+7WExQbnvfrOXvNjsV391tpe+ZGGP3FeWWxeO/YNpfXHX5e2z7tNqssWKtbFmKWa2J0y7RgqSMjsSTmDQOVG/jy8Z6QgAKYN14an36MFSDqPNRMtG4KY5Ni88vPmjbeZXLPmoHVmplkb0qL+ViyIHyQfqYVJ1Rlt3WG5gxGyAAjn8GQsMtjqhH/83EkxTgXurU182Ec/P3ifxMJUieJnl3xPBxDzUbR69FB76mWz8pB4mPSDFly1CN41CAwJFifbJ7T8RPtrI77Bo60Zd3j2+4v50/l07MZMa75KtApUIJCOlOPkiiYIAJjMcIyimYcsVU4WmMerQHSaYJMQxlWTDh59NLbM1ZkWxGn08nNBlLGxniUkLwgRM3NtslLZoErSB8Q8Jfnvqg4CeRKLEBOA5Dq9A0pKL4dY7iDS751FDILrRIkA6QURyU3RK6jJIChZLC8SCBtrEdOWSOnQeiU1kbgL60rg/klMWG4GozY/PujJYd2VM3FrPjyNznJ37GIQbfUrBlmzSty1BviTZ4cykcX21MY3DXwhRQsIZoqw40xgh0acqhWO8M1sHzsRvaJI5kyOxJrFKHJBg527CSGNIU5lkxi6b49wri8AwA9/RCdyRGucUQcxjycP+VB7hoely5Ussh5gHW/8gARx69jSuHwoZnZ8to2pRmubsXQxgCzKzSAKQmWD0eaZxBs+ohA8OH1egXBECnD5IAw8Z9Cl3mjIUlBnVrAHGT1pYYB4LOLfma9reNNioDt+gON/RGGxnex3CWBslqFozuUJcP0jkQ4ZH+9eo25xEPpD+Y4IFD01RsVrKgxyrD6tM0Xec6hCTc+cvppU1u/i1L/ro96ydu+vhne1t+7zPn+2HfmCr+YnUOFvj7hjHRz5n7V5wCu+V8Z/xXRnVICTjn+vv1tjOn6/DcY8ccZvnDVsskl1//fV+9OhRm17zmnBQq8lA/cVrrw39MDObipSAk6YkYkwqSGSpH+ZqkE59IzXBuXy5f48fuP7e+EaXy96rqg5wnIdDk5VbbzW7cP4G293+r+yBD957em++fPvxG9Lf9sW0sb5xsBo+pLy3DEWXS8ed9+Vl3m3QCrS9petwHGr3jIFpSaQSk+KSfWWWSWhlOtv1aTjNUYym3v1NRlg1Md8NP43EQwDjweKApOefDhCH51/x/n2oyqmANZT3id4a0hZrjHa2QBUH/3ciG2iuRxedHE4qawOPx8CaMDjg0pOOhkcc3RQLmDDqDVvAom3HFDoa8frjNATlOFkZ0CfTeBFzmm/AOBfW584We+QjMA/ROwKyDHV2Qagck3/DkMAUcbwav+dsPX6CcpNd999NxUQxyjELbjtoCc7RNk6xqml9mVxde1gh/MrWBnNODldp/6appLz+iG5tiFKD6mFZXcjdJiUIUIqIOCBAdzEiKNhYfeRKmfOhZnb8Uk4KUqZsDczLbKM8Lc6E1kiNmRnkcXsyIAHyIK05aArFw0TiaXvW5Dm7gWPtBAAAIABJREFUVhjXP1RCwQbPev9gbxjV+MNi4qQB1hZkBSUvqErBveS6ltoFKUDqWgJkPSleJwYMZk8T3O699HtLPkun1PMFevJZoDYjk4iUBNJact9f3UaU3bBENYm2teYvorUXA/wIFQlSslDhBy+r7dnUmRFk6DS0SgNE0eCLZQSH5KbwpcVhw3nIpTF0Aam1drbPnPMEQxgVPQ9oifvB5P31ceeTfKRUore0l0MsMUCfTB79QMH5kcLWL8lJIJKYwmoKM3v3Oyc73joc6Pp4PxcfX3UgbSHZKHa2d+P1UthRIqnH+nShtJAyGW18RY7Cb7fWr0Heo0uVYoiYr22sp+2di9Pu9uXd5eXj3/rv3njXH9z1wU27vL1qtz6/2Nd9bbZzFyLe1hhcVzNpE/WrxmPG6vrn+jMcCVPjMVs6NXeotIsq963fr89T4zgpIPW5ajznVN+jR81uvnnT7rrrusa0rqlePWUXbJnwEKq9ovoLdEE12//v44PIRn2jy6Vd9dFAor0wSaGGuT4v/RPsCkinJi1ER/hVL0Z9X62NtFPszOnH7JETH7eTp1f+8tYv+cr/UOZz3z5triw2Ng4tN/PeAgWmy8E4OsWZ7eZYcLOsaHx4JwxNNDlu46nQWXIZdjIyF7QZm49aoe1H+xmOW2j12tzirgr1MuT0cJjqYnL4ZIY4JirOcJIlDZXLFoVUQZrMSaIldX9ndveN8yepzeuGtB7DRSnaDGcCZ8uI/c3C8AjRUjBwM3n45FeA6VcUeKrfVc34W32QeeHU14nOV0y7bsMjMEGd8HohB4QErZKRR/KEx82tcLf8zWKmijoUYWuF6qtQRZIyZ4hLy9suRQKVX37QiQzfwnSWK4Nz+uvJPNUWbd1UtLEjYd+s82+8sC9HvLjei7mUrtsI/7TSTD2D9xLJ1tR0xMnzFGYrmpfIA5I9guQdn2Y5h2vep4z1rgRqNJg/QPwERhWB8b4wTcczn8dM6W6QSlynMAIC5AfglcgHR2MPsWHmjsI72ySViAAtjw3BhikU1L6AqZ1NgGE0TjgCWxljaQkcZ+5TVbFR9DFNdgAomuMAjAY+0k2RkxwWe3S5H/RWaD2ojOVRV4AFMkqRf+EcqAjdimDaNi04Th+lNRDzVXZ9M4/MXYQaMibn0F/ruhXY/4AtXThjqhA/bHeQY+bUWMM0OS5FiaOK7kicXw5mg9Zc/3cdRJFXO48esY9SBmpNsE5QZuf80keIIKPM23k6GZj+PsE8BdK5uJyZaBVTAkKRmvMrxVsCNFO65bQKCK6zAGIGrTdwLfDXSJFPGljK+TpQ6cd1a73IDEJ2ohcub7DR1wod2I6Vh6osYKIM6A3u0vVWTeurKyXPO747X7Td8+knfu8nb3vz3e89CzePZLe/z+2xx/bsxhsjUWCcNevGpQQMmHQ8VcuGAbKUDkoQLRmfZ7ns+cCzn71pR49u26lTG7a9vd3y+sWVScZIYH2qJGR8QzUjqh/mqaQ+9YUrU/fYsQ7TcFd6zL3x5TJIAfxAdHQbe1ftd/fMlrtupy4+YevXr9jL/usvs5W//pIf9o/d+aVnTz748sUtn5cOrB9cbm1vL+osi452FpaQLI4bLkqjc7HWmzYvyBkjyONkQ8mG2wg4FgzaDKg8igJ0arUZ3dPw6pmVhDuboXROIMIfnZ4+tSwlovd0x0aHvBPCHeuWLcz2YwAEWZTE+9H5JKpAIpitszjAoficWaQUEmUhakgoRRv02DisjNlEQnBZvYvunCFjyhjTy7BHXCRBL5PFGARIGnMFDfREVxiVXtvYPpCQoW7TAHhMviu9wYwClE0oWBtA7JsycXS6y9DsNRZKIpM43Ff7MRQqqOKal4aZG8zBUOIQ4m7pU8LppGGAXZCCCzDrbJ9mOMISAHJX5zFcyUcAguczU0O2V1jVFiaEcelKL3Sly0B8ITzm7NvRT8PBZCpE65GFt+M466JrPzOl60IUg6m3EplSiCi2S5WU17HEz3SIGp7WjRQFYvyJGVOSgAj0KZUoZpThBJNU87eDz4qUNMlKsPvbdwc84wxgElx43CSyLZlXj9GbUEzjWAIUDcpvgfhVF8vou25GyxKwkHJ/omALy38uuV7HJLAiDlxyF/bx/JBxCZOafiLwU9duUXQ7ckdcMnMPNr/LKFLiDc6wTm2lXYn5FGos4NDTZCbXkEt5QRcyy1RLFWK9NGAZ33KRISpQNx4JRmQisc06jLjzoZPU8HG0Vtv6lmay2P5JuYIv22bPgZU5BQNYgj3lHxw2XQN3+rIgURYFS4bmLRPcsT6RKdZw7kAbxQ62WFkti9U0Xdw6YxdObT/wSz907784/fET7TVuuHGy5z5ntxX9tSOShkb004EOT/fgv4/mp6MJ6vjvfFy+nGxvL2qVBCuAz9j0rH6Yino8nflJRUTOn49EhL0nZknzbIWZFx85d3RGux/c9ftO7trFfNGuP7hhD3zg47b9fSdP/Lff8JzX7D7r4J+cPHPyxltuuHXaWFnLl/Y2c0oc68luioFP2Fr47LaaFko/ZAZjStSC3MuKJyVz+hnjoLGcCGRhhhyYPUsG6t5N833JjfUcTZbM4btDSkZQUGmHHiN1MdGMeZuaDmJ8kM5uGPWAshLSsgDricZmYbult6DRumFI0I0qiHLsU8RZlDl71egFz8OjsJXBxrVTKdGFoJ22wMpHpFhyCZ0XMqP/E/t1MPCKPlSEm8Q2CLriRFnmjO3sbH+xFDPi2RgWIO4hYzc/fYbehW8esofeiyLCLxjBbQzyM4L7pN5MKoqFKELrze7td1WcKMJobjriv8C8m6l6Ynsea2s40WL6BncAOtVYBRBf5DZ7hcbvHqxD+HFBwuJsfCdABgzPhiF1fNO9NxJRP8jTcT/Ct9vByyjKLUPaLLTHlKlAlUaKF/VohfmQs1DtqFZiH8uoaqMhZwmnqlGbHG8jF8VUojimndxQwfArz6QQoRnDl2887PpcE0E58qHRGcyJ+5XQGNb/EKbYMWC4s76KHEopNM+i34C1Zd1gV6orYJgclxWjWwMG6JvTuWQ98gwM5G9uboE6ZhUJ9dfmZJzUlwC9ab1lHjgEkolJAlWQsFvXHWklJCbZxwDdeucY/1XUliqmtGqfLTTc4RreEjlq4i0w5gnif/GqIo8ISLiA8VaiWR6iJ+gro/jMIQDn5SS4yrQpUys0Yrz6c5SVak1jjxXvxtkBhCXwWAuxcGPzB/kKjHgCySu+WCzK2trqfHnn7OLMExfsLf/yY9+/deLEY698ZSWoJvvu757tuuvMHjlhdnkzpvHXuXOfioP65+rxaScjhHWYVDzVh6nJR23LVHIs4R9mY0RJrpQT5/zk5KYyfU+fcds8N9kt1812+HCycuG0PefsIfvtn9u655X/3Zf9nWtfcvZ3Tjx679Hjh29Oi5W1vXlvTvKdaYI68vrUNR4pExis4fTyIqHUYyp1a2cENpKKejacbFcI9RZni6CbZJO61nF1OlWY7EdKKDTb+RlBkuBkB8TjJOHYC3AeQLmkVSdJEIBK5OWH4pAIpJ42Ajto+E7fIyOygnyOyVIWKaVhi+hV5qCTBSzdzx04zCeSZDBLqtDlgzTC0VA1cBVIgDL6JC0zDfuWPk+m0BmOh6PJQwTnX0n9bB07E8ZmMMs9Aja1y+KUZ7DZ3GObDylfURdAnA8P5ZOhxRIGrd7pDAP6bprcwucEL0VwWoh8sHhjLTWWIbSiUTKGnpy8FWtCc+JaMIF3LoGmy7Vo/3FmRk5q5bO2MuEGyMVdriJhdGqmoJMLqHP8fEZQQqc5/j1cMzyXTDORtpsEhkXtDaCl0l3DqQc9J95cYQtTe1M5Zx3m0AcJ6o7tC5aU6tMczjlkWmkAFaS6JEDbWGsXdPZzNNQ8AUhnbqWGogxBB5N7ZUYt3Sp0VJwk7yto74MlOWd6JAFTSyQRGIXEBUy1RK4wiwSO/8MFj8Oiz/g2QnKNz4yUnU1WXEUatpFli+w63kKKQS1FnU5kC+Ezos5CpC99TLT1kkBgbe9ZFfhC4oRud2xuHmKcBiDrWXVneLmzgAreLw5en6JtmTVwIFYtRmvnuj/7DGFTvhD9DpSfGZropOmgXgf58HwsOnEiCETzFG6qel/M9I1TA4bUfB8eE3/KZVAtdeNtLm1xm9pEJqImig8+rSzq+eUXzz22dub0Oft3b/jYf3/qQyd+/V+/yew5t1RAILdOxQMPRMfCMHG3xtarzZQbaRTPtFvymTw+I2Tkyjd4tQcTi0paIRxUH7W9s7d39Q91te/VVs9tty3s/nuT3XD9tpXqFrea7NGtYrf91f12ebH9x3/r9V/yt1cOrf7qpa0zN11z5Kaqsy5znjn2s7ZVZ2C2ExTzAz2Z/K/2cmk8mLo7kIo7D5BUICWxlQT0HTR9CnpQW7juLF47xrqStrpvHl80QwiscmqEz0bpSXH1zPtk145dw7UM6EUh2iIT2JgiqqwDIHm0Wooa2b3+jF9MSuBaXypz4LEOI7gwOQfADXVPinEnhA46DN13djsp2WkFaVa26a66g0LXmuL1SYs4+5xq2Nz6YxqDXE/+COdJ1Q1ZEcxgZLXBqRZyrJd1Z0LHpYSdQX/7xIT5eq1pwshsIlv2IciLwnou47gdYTJdSZmn+XDgC+rDBTQmqUwHXJ8Ri47QOD9tfX9M6nj51Fdq938K1D8BTaploPo9Du/ZXqf3QzFaN3r/RDdKYDVsMYTMw8iRzmxnABqKkiG3xCPSSEIyDE1a+7z7g1s7mxosThFfRWGO7ktBtt3h+yEwUHXFS5aYVLSgiUZ+p3BzKgqwIIeHeYeR1KwCzloyOA1K3U0CPH6oAmAzdi6N8K04PQfEDMYN6Hul4WwONilz/PbmE1pkpQzHdgBFqdOnPJeJRuVGlibCcoZnB2CZ0s+HDLIW0YqMJgPnbtrYviWt00jbYPBmyAetHYlfZCeZ5yOHjaGHmDoRj6mcNLHUkxtKI7pHgQ/LG+DiqiC/Kk2fabpNmhsUa0uZJrr46kETlOKeyLwgbKcbzxjtRZwsXfiH6af4I+kx0ZmqWXjOe3XLlJymNlp+ZWVlXqQVv3j58Wlr7/LOH73p/u986K9O/Npzn2N23Q11FlzQH6qVOzoSUs1WoKB+n0RWPqiiHZOR8e+fTSt4+0ySkfpm6Jr6yR5ETiq3xLA+qq8J2bafymNvzra1G4387UvFdpaX7ed+ds+OHHjQ3vAvzr/zeV/15a/7oq9f+eXL2+efe+jQNXt5b87zck6TTygqW3lXOLBUJygWUsbCVcx1jVGL0e8W/WVjsztDGS9gnugiCsoGNwCpxCYx6StRrOQwc2hUk1kcj9JG9go8wLsMRb65mk9s1IaEoC3hGdE0gaRK9FjHaea4D5y6cIF3ek0JUswDZUC+aaWP2OFskPEqMiQUzMRBm5R7VAyKDAZf6p1+cOcyzKRipQlRChiTh3qK4g/CCvRKmLZwMBzVii20JrBli2YY8oOCxtPVx0CtcO4O04GMKJOZmvkGn67OEhRlfuBzlt70KTp78ZTE0uOkl5Ob5sV2y4bSh/KiM0WaQKQA9VLN0WShU6+qSsDACDdFKEzMEeXQMfS6NToss7EkCCHWX8qwrEuDRSYMNBrDhyOKOyUqhjzHnGneWkA/CQA+JfjDiZ70jU42jneoC8VZ7nGF4apTlJqaPEiIInWHUnqHGSWDuAtEIsLzH7zLZJylAmSlTe8tnbfT4QeHd3jsyYw+lhOgQ4xH6tQq8hQ5OPd5kU+MKZi5jHGtR29YTderO9i+K03JHQJNcDmjpQZm3sUmKuSyiUPcPuzUM2Hgjt7DKAZDFo4PTaizNC5CxXVCcjAbLeSijefDaFD0HygamQFtJZVZSJh16oH1gStGDVvOI8AY9y8DBBV9ngsJuz4uWBooosX6J+aTMcfi9RVvicenev/CTepVh6FPGC6RlOOwR+xJGIMRGU6ZyKvqDseiK5gD1LCY7L5IbUryuTOPLFaOrGyW5/+1b350+4E/4vFS+SHkc1QQYCSjio8574/ldSuMycjICa0/W9s711zz5Lk1n8nj08pt+GHqG3mmX/ww9L7nh32mH4SZWPw+oOrsdvhQspe93OzYdWa3/eV5+60f/9M/fPiO5T9ZbOS8efn8YnWxURaL1boaZ9iZRS+TMndjEoGjAAhvJ0n0+hYwYIx1YRhBJgLhA5JlTiRh8dgNpCKbN2OZRtt3TmBjTAoaefiR0pqQSM2UAHXG6sgonTDbiSdX8hi6xpVdCqf39ukwTruOK7ZeIqmoJQ59EFh7C62WnXopGUJGASJwUQX0XDgLS4FTcY3gbETG0KORdGG8FMOwm0xxJQ97U3z2ANHxe85XUGYwkDVofxGSWQ4RkEepQH88k6xpvDlUkaRQQFOhFycM7JizFRbjuEI0UQO6M3F2ERacc2iaZMydZQI+A6VgrLVdSC7SXBTvYhclqDz7CPLCYisEo+FNwlEWPAFJT3Xdl3rQtQWXBxpoNAuaNBspEZRl6nBAwJwjEpDDI/t4tp8M69agqtK5G/bwYecUDI9IsF1lcWQ4LUuYYMITo/YT9sdA0eUNxf8yW+GiaOzXWGkpxr7tQ8oKE1DctoTrG7YAWdmAd8cWMwp920rpAhIKKVwG+3G3MnXskULDwN3ZrwO6UvpaVgOIOhZ0Bll7E4dOAKgg6UoYBc0BQiIQK0Wmt8dw/cDkSZzjHOs/k5cZrc8wEQSzwlVMGP06EINh/8HMx+j/QZOc2sVq9zclWgo27RhAhUJrRLx1fJeDjFUqtQ4pZ0QDpE5Z4KoKC+52JKQAWxrHNmCKBv2W3Nce94d32ApYMtm1JP4EF3XurWmlVEK6ex9nGHGAkc0JgmUoDErY79ZlPuWUFtUEr0yLtNxYXy1bW+dWFhvzVt46+Jrf/8d/+kenPvJoG6FS+zZUs9hVKBHjSuHjSl+wK7/qv1dla01IyuBD9pk+PiOg5ane7NW+Ro+S8Xef6WM0Yhtfv17DA2tmG+sh/91bXrZf+6fv+jcn77n0M0u/YFuXzq+urazlxco0RkF2OZ15cWATPkWiFHsgTUDJkWYU5S2iHTXyId1JCwnyEqCxpCyj0ikWfCcaWng9lpi5ntBTClrglIqIVz54qELJIq1bzY8mcmzFd4yLVMKslYu79MigCYLYVb1dLIkLre1T1tVzujlQpcZ9Ghz3WK6saVKSIQHU+cYMRrtYUoIc5ahH54cRkXU3TUakQ8Epj1n1TueozgZOUiUgcoi9gqO+jRPzjuESkJazqjsb49ACoczv3RhDPM3C1oauh3OKSDJ45zmVUU2LJ3qNIx2LKeiocfmCGJcCs85CAYfLfHQ08hi66MZZoznMepN3TiZsOBLWV+p6J7ia0jKmRP+8ESEh+U6FAaxQ1YRmXfQJmkdLa2FkWoK6E9FSKYhhKK1iK7wlFpuhxCgmZ7RLQ/uLSUHLTlKEM1FBkHwn71wxZSNge3bjoI5m4TPo9uKza95lUX+IOEVcowKGCtaO06M3RAIEltrayHF7Q+7vGBArIasZmS6ga2hUD68VlqRzWxmGbbVcL4dTi2ofH3pmsRoLk3SQcFBzcPkml4FiFpmt7aqcwAIxnhWFvtTuhahVYheIxrp4GZqt1fwqySKZEFV/BD1WAyILBg2FjzFy5WhTJM0IxFNBD00/Oe+gULtovP5a0ipKoHKkL6XGWzE3qmEAtN/c+0WlYPglrz9I2fs6NSkNAjJXqkooKA4XGFgKGG1hiRUtXVoEnJJQAPVanVZvnhbr6+vT1ua5Vfcd29i76dXv+MmPvPXO3/2Q7Zy4ZGmxZpc2DzTLw+uvf2rF6xiLn2nrpXJMaJTKD/pMH45O3Zkza3bq1LqdOrVmp0+v2fS61wV0Q7fTyqythJb6qN+rXzRDGR9EN57Jw6FVHjM09+7oRmMVXhReNKpp6tcXvsTsscfc3v72A3ZgA9rcEryRo9ft2YfvWbHb7z5uawcP2oVT5+3Bu87/xS1f+OzPXxzYealbnjY2DuyBgzp1rSttEgcXRU5r5WFviTuBSkNGnUIUMDHJH2gDCNFqQLjOheGc4OlQmE+L0a2fVcubfRrFRq1N1gjqkbSgMRmpb9SVYBEIsuW+JQpYFKRSd11QoxuwLLGMXuGmMqRn7GWRaEcggzGUOQOmhyXWhzzEraddsStZbHSHASciK1oB2j1yyzSNWNdFK9SawKys/0vHovpHJr7PYJxQxQctaMBNYdAVGWpSd0djbJAeDhgrExh6UGHmKO8Uf62UwUeMd3og4BT1ETmQmt8FoNB/k/cDi831jnUZMELSqBRVn5AED41y4krVesOzoc811H590D7BOBuQCWYELjeo5AShh3a8wnvH7Aq87gb4ujBrGMg5/cWGGwUfe7aPzJgTAOCn7bj3mUQkj8ork8od3IfkqaeBRqKRbpMIZI5uErMgpuDgppAm0Uryfj+7KdxAk5UGtihccZcUrWjRfmnj7KJOi6NB1elgfSP6E6xqxPGEjtSNlvq8tkQhpeUiGtMNZpsJUGeuGTmjRaZ5OIGTkOgkHZ7kfN6NoX04SW28XqXTQuJmNSw+YEoQYAjJAIKQkirpRDdlpHr/fC4Qe5iV4a3RLs1EFxnjA1cxFmsCiUdbiMuqE9bahCtCXjpWjZVEswgr1eb94MGDaevihWlz55xNO8de/7afuvdN8+OH7Mabb7Rn3Xi93XjD9ba2cpOdv7BmBw7s2MbGUnPhGIvJ6aRZ2VM9xtYOHzQspYilggH1efhztPwgOZYcUeYDly6t2rOetW233rrZTND8He+I2TDVfr0+qglKJbPUR5Xj1q/6ZJXjobhUenvmmXA+6hut/JB6EfiBCfXwwlwJ9dTv1aTolueYXbho9qbfvtbuf2DVHn00hSmaRf29Oyc7cz7mZV9zvNhiMvvib/qS9LaffVdeK5eue93/9VU//awXTK9ZW1m39Y1js+1lXy5zUNvIhorFkrsoxniyt+FJnjRhkbHJOMCy+UTAZKxQqMMTqY1cAMgWUgLjcnM02CEPiQ/NESEJA5zk69WVpkanSILjTBggd3Dv9myiwuEDgSGImWMZKh+VKPv4Fs1ojZEFAYF2BBLRITVxUiBYSaHrVRjTx4SGhuOlx6+4AZi40opI0AByeKmF6iTmXzg4HAZ+SyiGQuPqAjcsRoMoiWOfi/Uh7aoEePFoaddTYhg9BS8Ak7doeY33A54UBYxh+Ymjwo56sgjRQe/E9BzUFqAVE2aWRD2gqQk9oOArvmesXpMxSi6JPevu/AiiPt1q4xtg74BEKqK2rglCZMLAFF4EzAMLqoBDXNDo1800pZg6MMB1XSyaINMmRpbQ97TaDWp7Ftth4COTY1NsYF6XySyP5yuDl0y0tShIGwRlM/7c5W64XbRCJT4DeG9GU25C1FZTN2Ytg3qhCY0kjEy4WQNMqjE4cq+in6A2WZTwhCyiaYle71Q4XVFmrtEVLKYEk2pgcWA9htAAV1dxrq1onNbUcQaS0G1clTYQTMTC5bVGTREDabLkd/IRC5wgfr3t8MRyIIbRxdNLL+Ba9UWpb+meRrFtMihDyPQKnXGtM9FNfS1YZXN8S0NTQR/2HP4MiZ5H9HfQjQGlxzDPwSktwItl0tQ48lPiqhZOutF2EGmQ8pIKXfpZhZMpk7aDBZ8RUab4qUpUrT+2trZmawdX/NLmabtw7pwdPHTz977tp+/8v//0Nz5kX/zFr2jzBZfLZeNV1mtw9z0H7Mu+7Al7/evvazG3xvsad5kYVGsO2sFf7UG+ydWSlbELUoGMKlRh/K6oSU1UOHSvqmqJitTvVVFK/XPNN+r7WYzZzsgFGVm15GrwTfFJ64tf7UN8KjyQ+qjZFBMg7oL63O9538Le9OtrtrFe7M3vWFiait10047t7A61hxU7vIZsazPbXim2Ou1N3/Df3FS+5mV3n7r9zjv+4Ymdl5689WXpH1y4cGpx9OB1ZWUx2W77gFKiFsm/xElqjq0zWhnNVr71xDMNEBinZbfZB1rEE2anYY8QdBakPP6s0HKaXUTgLwn0p0xcVichOf4+7D22kIIzMhoGRWwlAM5squtdBr2Y9YCongvsVxwMV8u9IGMf2XsmVsBqx8gHnJ2dx8AIyQBr5FFeEXTY5Ke3UOqlCnuyQ2dcvZ8gduGXi14IPgnOE1gFjCSw1HSoqRZItGa/83QrPTmInA6m4Mg2OSRWdBb29AZbJjaYdKITmBO9FOmIa3VjRaY+o3MoTZtJXyGFqqe5PlxF0jvBXe25IfLSRLmkam/BfIpfzvGl/XNgfKKLUVR4jYpzNpqL+41skbQZWhXj6uN5ZyYb4jIiew36bla7rJRx0KKaT867W9hBJOUSS4VBufeJDD4vfWZ84UyfrKEErjOUTbokRgWCmPP2eMxeE6ITfFAY0mR6rQ7ZHrMPXL/2DRUeEIMqQyOGatDWe1G6TeVoh73UU8KuwQYBrZ3ruxBqIl+IG40EKRfJncsKXRwSpwW8JNMUrYjSqaIiqRMlNDkX54WF42vgQaVwjwXdScSrzvbWFZIlCedZsNnFAjPauSWkj2ly5LvBnk7q2HNIOs6rkkH7xyGD3L82VZML14x6wmWdy0jEfEWWhTydh6a3Glgmkna//zzUY+EJOK/fnUtkdeurK+aL4ucvnLJHTzz2+PqRa/7JO3/l7l/6T79xux05csiWedeWu7vNXp2JYw366+vLq8blGnuvjPdXxugKCtAK/unaMZUoy7EyBCzGBIb5RX0+jolhTlGTlunbvq23aQifUOZDDXJ1T62PM2ci+aD9O2fJjHNrzPablZk9uU3Dv4/mZiSzjh/k2mvMfu/3V+zP/njdjhzessMbO7a7uWfzznL42rO83LN5t/53tq3NXXvo9vvL137Ni9Mrv+Ur/XmH3nf5N3/qwbfoVfVmAAAgAElEQVTvrTz/7ps/z1955tzpaxaLdV9fW291b+7ZKCA3Fcr8rk4uZuOdggBVCUXCNLHJpJjx9LcotOgdCkOzkjizagSyFQQo4ACU4CNOjzJtH/NbaDCqWflC4ePIzAF3SUMpiVeTWdvRjCHRIDojfeHgO++J8x9a5zcqcZ74sJHuhDUBwBxlqfK8aLlAUlTI9i2CfxLHpNOBgdPRfBQ1uSKaQizVERD7wjaXGQ4yvPDjDE9lGyi2pWMqKPwCVJ7QD+YFQ+A2OTjEp00QAveGsSvNGojAyvOGoBy2GjxqO12FYEEAF3EsZtVhWFLQDKMD6B1qJU818UMWdh/7mI0itNl6v46mNnh1VP69AdHTdHiSDocAu2nEIoCucEklZHfOVgDt8wYDQsHxHQ1HIEU2kuTZFzY8+hRFzyWEUbostEx6LuslKa/04hNu/6A6xvg/H96V7r/r9fOgNGIs47ECA2gEVXnNWd+zPnzGXkOztgkIkyt/uEjcdmL0MKyZegFTGfoeIFrpEFQix94c22rtp2AGClVx5JhZeqNe8sSlo3lrX1EhMIRlvcSwgKPidsCTvkGjvOM9fLPlk/q4TUJBWROW1JTsxNhulqSUltcPpj/CmQt/rGf9XMVIJ+K2447R8EkEdd7YtuYydylvpvdEpYgWtG9hZ8ai+P36RherK2VldfKdnUu+tXfWHv7o6bf//k/c/dr3vvmhd9z3/ocaenL4yCE7cuiY0aWnuZouatxetSNHlvYVX3G2xWDaajD2jjNonuqLs2meaihu/T5bNvW/7IIwPzC0aajAHYfs1p9p3ZFXvWp/IlGTkpqx1HbNs59t9t73bthP/MSLbJ537UUv2tnH6eCb5H/rV+0T1USiJjGjQQqTETqwXpllXWm6Uts6R44U+9bXLO3BE9nuumPF1g7w/HiKLxT46yvJTj26a7/9W6fsxmvP2R/+/rbd/p8eu+slL7/1XcduXbxqa/fikY2VtTSlldzmuVQhRqOhNMbqnKsQtOn0h1IRXm0wXVAzJn4kS2QnhocHzd4QKkhfElkFVHnRJECyZwSLjgQpjkWtU0DJ3N3JaMsVE+uDhRciHR8b7iwE40hLISFJBPl5jAnv9XAqQo/C4wTxYTtxHIWs7lWTIvNo0BBni3VSIAub+HxgnrDiJ33GkKq0rCUZfG4pouKhmeIV4tM2XUWTLpCimBPt5HBodWFfRMakjCbTmVb1F8YAqhHM+8sATOdGLzEGow8uE3QSynGmeR2N1/HM8J+QanqidUd7+tzSrhQ+KkUCAnwWqtKF6sYINSdVqQbCvC+LQC6B3pTr/sLmkwQq5rew4hpfoNvwCC0hP6dQjc5ssLQ5v+ayD+H+UOpRV2/GS6hIBIeIrCAqYsMM0035ppShAzmCiSAaF9mVe6CT1qkeDTX3sEMLuCx0OKIlGLJp7Qg4dw10s5KUkinLGLJJBmIfmpHKQguvP28hYw9Iso7KgD4kNOADUuBcq2hlgSCJvjOAg5ziBHPuAU88TSD46BRfZMZq6w2FF365bpEGIeFdhQFvYbKO3MZi1eBTCFjz7tTRqyY2ds01mcPDp8ngkxI/nwDJUsCmfKkTjgbESHUJK8ZOMYmTjC2iligOuK2RN8waIScbVgA2DbdRsO6c0wL2nU8oNTPPJyFanFUaOBMndUV2z8K38HRuOFI0VheLlbK6skiXzp3yXdu0vXNr3/27b7zjf73/g48/vH1h2w5du9He8+QrduTQUcvVvK6Ol5xqS2ZhOzuTfdu3nbRbbtlusb0mCjVWswvydA/G+atxRq588PrwitUcoCYezC1I7RiBilJ6cpKubLHUJ6g/8NBDk73tbdfYr/zKF9j73neDPfLIWmudjA9mPIRa6u/VJOPcuY6ajA8mJbwQT/eob7r2nOpz/bMf3LGXvmJpZx+fOn/qal94jdWNVbt4YbNceuzxUualrR02W+5csF/53/74Azv3HPymddv44MlTD9vlzXOLlYWvLBaLRhLI89xmwoRMTcTm1IgQHnoXsO/bnK3Cc6x1iZ1mrC1sw6kbYslmQEbdHpdaCWZXzFkv1MzIfSQwxMTApsDQS0wMPpXOLbHK4GA4JA6lEP9OkVM5eQvUbBDBRpeUR4T3DMbEFMQBjuZS4awT5hvAiptdUKLFBbdglFYV3YgkJBqo4LwW7vJMtZ/meOWBJ6rzUQR+OsgWNnJTjtGgasuw3zFivYHuc6wKQjN4AwUiH8MgniJDcuLWcS0C4e4uiOpgQeOJoZo1LU0S9ylpGyJRhJnEkjeO0AlKgQLcIsJzgUELL0YoFQpNN1B0F2VO4QhedPGkUWK+WdCkYG42cE6Zh9Kcw/tENMpW2xPHwY1UDnIb0P69T5U1AP5hdwZQPTkXYuH8EPq3ZoqhLDuRDYYNg3INyokklKGTg8xUw+Lu4qLkaN8XZRwGs0LxQqmB1oVCPidkLM49wBfOkqClu3TeEDrD7ejalArTCR611FgBxkjsJU5sbWqkCivwSGmSrBmL0giP++8RzUART+wP5kgUw8KMcvxhFRbIsS2x++RNd5ycDive282my5R0yeNGQSGcIOptkhwX3OMEQYg9YeAFET2cYtn6VJx9VjJtTWlF882EqiGAVA0g9aJZAH2oJyBw5tG57R/2TMLeB1PDxHpCrgk5WaxICvDb71M/DqiQR6t+MRqSSZ0ZcofwimihxjMvbGmT71ZoaHVl1dKUF5cun/J5fWkb+fj3vuXHP/RTH/vgo5fq7x44umbTIhntVvioF2t7e7IzZ1bs9a+/31796nMK/BSkEBj4ZI+ehD2zB/meJLPyd6/smFz5mF796idnP1UG9P73H7Yf+7EvbE+4urptL33pGXvxi7dEOB1bMuOwHSInFWGpH5j9ofo7Fe0YFTXjhbuaHW193s2t+Lev+PI9+8Cdkz308YVtXfan/NrZNDtwKNnRw2s2HSp2/Mhkj3ziiKXpsE1l1e78iwceu+PPT7zl+S999qHDNyxeuZw3bWVlY5oWq7m0jHLPag1AbwAAgN5PBCogMCaBuHhROHY2Ebz/nXrbsMGkYFAnXEIszs6DTSxqSGMwK8sV/NTeYVUURK9RYEZEt4e8MF31znplGTtqdiCjZCuZDBkeV2i14sOzQ93qX2gPE8sQFZEUyhQVJ66u1tCo6MiHGg2BHTXlP4UjKEYhikksf6IzP4QgSRM0AEAXlSEticLPK+DSmEZ2pvq1pw5CCJAdkWBjXVjREfBGy8AUiSR3eQIrJJz2cMrrwbSgkG6ShlYcAhNA7cZwGy3UOgLcU3TiHUlQQfwhUd7Ip0+qjOP/iS5nuuPz+IcjF4b/kHDDVcuJ2Gireccth0Zdu9jNNzDeDqXOiMzOwN8JAy7NKxGSxGsW93/sCxXnJ4uGD0A+G6gCziH0JNOIolnQbHFO2XHdFqOAXkwGbSbdhGQyD2C6Z5SnaHAxR1FDlczcPzE+I3VCScLq2wizsSFCXGKYo0+WckuZeE1KP1m8NyF5fnA8YcTzxGgaMBYuCYU33sczcwpwb2YT8CMo0Bn9ifY6SiGQ3iXShzBxwmPqY6fn9nY526fIJkTgGrK/yMcS0E02okJgn5T0dMlisnEv8eRJutHGJh05fY18G7cP9SXBN5f1oBIX5qBCzwAh8fq3/YGuoHGV5TRNZWV1dWVne2u6cO6xOtn2fPmCz//Od/7CPT972+/eEeTUSgQ9sGJrBxd25uRsmxfX7dprj9s0LVucfuCBA/ba156w7/zO0/aJT0RcrsTRSsOoRNP6VZ+D3Yyne4wUiqf7qq9R4z6Bi0/GHx2Rkas6sMYTFrv22l3b2Nizc+c+NVcTckiqEufAgVhxbOd8qhay9SI9/kTwR37g+zftHe9YtUVNcK7yPFXx89gTxf7jO1ZtZWG2fszt3X92qx04uG6Hj+7aLbfc6nfc/uFy3wc/euJ33vjB73ntD/2NPzj8nPyT5849dMvGwWsXq+vHZ5tXbLmz66XsuU9dFIkHLL2LGgWDdAZahtbjAXXkiuCniOsolxi0SuTXOMoSsc8ScsMIrtnJcgDTzJOGrYDMPSDV4kmgI0A+mimiMWAb7RDEVYz8Q9UWw5vpU+iUxWcq/WVBXRsnUrKhHdYL/P3hXTFhAG9LoBeaRAKwi0hzxjYZftb5toNvFFUlOs783cJ+Q2ZSU8DF6R8JP5JpGtBBesYUUv37VewEo4EYiDaZyHpoyqTWPEjg7YvbIlJo2qdWGCpQZZfquCXANoNBJ3XXFIIabSdmjC4PuKj07ITPzZmNLNpiDpigtY7NkW0CpADUmL5iY7XBcjIUAsPSYZjPnYFUOzFTEialjMuZH3SsiZNXRktSrX+Ko8VPNFPHLBIK7b9xDGKnVBG6cSJEhIw1X0eoXItv3RnK9Q4ijANG6vefK6wzvrMlF+zHewF9LxbqhPWfrV8V9luijdFlzoFGMo2hcLnx361oXTJhYDI60BtAcssTwiVSUwFw/QwoHMmro0aHDPTocRdTCcUiyxe9996SE0zEM4CpkBOXwOLpRZsjke2ArZ6HYlmtDw7zF1cEAwFd5BT11HAschi3kkySR4rpx0tRv67nINgSmiE5tk/70e/DtVRMiI5s3NNG1V4sbPJpkRYl7c3nLdtlWykbv/k7/+d7f/zswY/ftrcJpikWy3I326P3T/bil832hS/asjvvyPbAA4dsayvba1/7iH3Xdz1mJ092Dkcp+2fEXXttfK/yQ59qPg2TmApMfDL1LPme7s9MaTs+ntIOvgWLfYP0P7UHe0P1Q5bSEZRP51Ev0olHItv63n+02xKNq8FLFYVZ7pm98hUX7ed/abL7PnrMXvy8VTPfbj//yCOnyp4dN0sr9tBHH9t5y0+///dm27n3S77xxn/2RV934DXLveU0paO2unFgnpfLeZ53UzjvajFJ+Ma5uglpCIS+6GNT2tZbbdAuJkVzU7DmuRCidxSUnd0maEFELN53VtjtmXJQF5oK0cfxjt63QO7anb45EtOoTNKuBvWx+hTFEklXn9QyjsWDy3ScOHlQhaAuCFf4aKgUeRSy/d2Q19wKIpP9ehpOi8IKBOkOngG+oE06l4EmtE+UR84apU7opZHcNwy/4+h/mNPrGMlJYw2B2eiCXvECTae9z86li4K1PjQkTLOhWVfDqrTNeC3wOu/wOVzZgVxQOMkIiWNREkcoV7ILJG5XYC6sZiMEZpMjVM8qh/eGc529xmZUR324GUb4RGYeg+sKtWOlWSUUdAcY/2hy4kTAO8HYo/uUFLeg846KmWMpdTUK2RGFmi0uN/KEuHNwf6K/WNhLzRREWB96rfEFzGiBjvClu3Al4/0j08VOxufEOzbmHySsFLYEnVx0HhTGV+3MliLtWSGOgpdJXM5OSrim1Q5uxez4DkhW9Ov+P/beA9ySo7oaXVXV3SfePDmPJkgaZaFsIXIw0QaBSAaDbQy2wQY/bIL9+3/Y2NgGbLCNbTAYgchZsgQSSEga5dFoRmGiJs/cnO/JHareV2HXaQ0jkH4bP7/ve/19o3t17jl9uqu7a+9ae6210S1zuwja/XR3trFdKonUoKj9lCLEjXQlVtIqvYxQ+ZTN95Dx65n88StqxsL83SWJcJOfs0ge1eU6U2Ua+Vgv3eVSkowHXIpIknUzh9sD9dm3mx/pMSHdNCPczXoyK+LwSElt1lmeFNuVGeSsl7oUVFDZ3WVHbi4n6n9XicW5UEwYa2bEaZ2n7QY69WwSSf8Hb7121zf2PDa30LsmxdCaAdT6KiZyN2sx2kmE8y6K8YH3xNi0KcZdd+/C/fcPYtGiGNdcM20sO3QMzsfefJt/SkjIKv5UCAklI/rfzyvrsJw45elu/6lGeT9vo9JN/uRP3ihaP9nfaBB1QqJlQxpuIljnVAOhB+vyyxIsXzGFr36D45GHBlEohEhTgb7eebzmtcfxte/3oN0KsOmiftz2zd179vzZxDVlDH55xTnNj6XhzKa+gVWiVBqAysKs3W7xVGaO/ehnYr84882kXCTgTnJOLAgK/Ra4zpX67QmqzAkdua+YUyGxm3Qw7/RHj6ki02VF0wenWMhcYYXgEd/YnFpaKUVVJU4+mg6NN1xeZ2joPTFoFcUIm6MqA7UlZsi1IPGXAu4zOZNjgxfQhO5YLKprb+QYe87CWVnDb+eyT1Vt6koK8kOEpeI4hKMr+WNdMSplLUD3muQ65bghtv8jffkIrkKV92bwOZzTfIL0VH4e93Up64ZPUIq/TDnXfuanb5+Mwq0EZZcI6lNfD/K4JM93XqMYaJR/kjJWj2mRCpoUIxYlUIzED8onS8Re9Z3W4br85jAxSna8ZZYPPRRnzNdz5tebvsiVSyG8IILuLgX/nbR89JRtSVBJV3jT7WvoGqUaaw8q2nNQc1vn/ULQfv4KMnp4pXudK+oQS3YwnKIyuqoN37GHsnLpQEsHSkqn6UJ+cHK6eWp1pjxpQnZX7lQydM3sVI7YbbND3wLCgS7WmkeSfp3W/TRVGMaJZB6wcB9iBLN3M2HFnbKZWAx0LRwlzC2xuMvJu4JWomtKr9YmRMuDTHQb24upqMqZ893zYMZPz/+si3D4pFWBUGhOawBF5k+KMkVKdT2pDcTtUTJXlXapdhe6UK7BB/Gxu9mCnzloJqMaFnFlcskROVt7XNW/Ds90Mt0h9dzOERYDM/u3Ww2Wpg0EhUwtTGTf+87fPvLeyUOtI0mQ4YV/8xzMHGngyCPzWPzc083uJudCPGvDCH7/5cfRTIA9e4ENGzo499xRL51tOZrDk0l3SYyiYyqZlz3Z+0g18/O2n0V2PVXZhvKEX2gyQozan2eoouEfPRgnZ13MsX011+Tn1Z7o/fp9R48By5cqvPud43hoh+3Ol2UMfX0xnvucNsBCfOrTRezYOsY2rFutgjWj+I/rtl2vYrbt6vee+4eVc6beMR8vVHqqy0SpUkUcd5RMEkN784CpnYlIPdatjvhzd5KZPLru8xg7VTo5ur3xqU+sfWiZW1XZNF3Caxk8L5/gdNuty7WtZ3nZJVVz3HdKVxPOLeZzeQby/Ff3d05qWAeQSreiI88rV3ntOqxzKn345STzdgauCk3KUAcf2ETDGYmQO4SrRSl/tFTFyCFBtFLy2s18yaiLKimfx1Ck9Es1EuwSJGtZvKw7PVF/DuYypVw+5noKMd6dwI1VdbcrL/UT7CYiXpnzhFIPddrLR0sLvT8BSidM246d8umq52J098ufcFG7jdJsJq2Ih+PuVu4pUUTxyeP6nOjR8DobRSmhHSOPW7n7R9JFUJ7DR/m7S3RckCKFGW3dMpAvKVC7GzcA3bTIVkTcqOMJCQpy7QAIuePu6AhJ6q5ou47cXd0X3X+At+hzelZ/KI605bp3uySiK5vw/WOI0ABXtXH6kNxMYVlXHppyx5ezR+S5RbW/PO6DLtdi+YnfI00uzDgPfzAfHOmdkrz0GbVuo2HxaYJ0+hhKcDjzkIenkxCNiea57jWku8WenXBOAhb9MwMhJaP+w/Aey8QYpSSZdudbGTF6qB1e5BR9RKFxd4xLJUCrF0l0XHcOXcjIOZp081Wf4DJQN39z0k7p45EqR1Pq3pJ0/0np60bdnCenyDfLLZ0s8kBFBYEkS/ncfB1pZx6BZNvC8uDH7vzSjhsO7Bht6b2uvmgFhve3MDsa43XPHMYZaxLU2kCSCSzrqWO2BjQ7lhKhkRAt+tBxV1cSnkrfGCrF5OfPk//+dLcni/eUeJysqDHlo6f/NU9v0wmG5nIET1JaoRqThoDyB8gcqZWkSMRDIe3yqfaVN28ZG7cX5KKLan4AdOZ3+AjwulcnGBsr4xtfHVIXvGAte99HAnxtol996iW7Rr/wp9v+6Df//qobe1fEHxs5sf/CJUtXIYoqDEKwJM1kmqX20ZP2KeKc+KvCdQWzszD3MLQ/KRcsVd5Dw0OsFh4hlC83xbuPSuUDAAjAJQTET4I5mNavOH1dlghxDkuW8EmBbyHhdkbgIpxa0M9VLgB6pzgC3ynk0O9dqwu/LJZWJmNf47Zu7goEnrfij9/x2broEHfAJ2U9rhuPKS0L0Lyi4Bv6mTdKN2SEZ5Hmn8KG8lLsLpfXHhKXLofgfjpRlB/ZEgnjhMzmeuH4n8TycTIOo8Xhrl+tmf4kJTmkP1W+Z6LLJBhBOIQwdEkpptkQcp3vHJrBPKGYJCzUNMnHVgpLlBoz5azDpPX1cyKtrpWU+aDsMm8cr8n6xCianrmpchGQ063KdO8A7/4K55qZe25dsEbuxa4HIVVDaMXlTjeX96GbRJOIJp/BOXcfK/cGCb+Ydeg196sDDpyu0g2xzYS4a4roTP98Gq+Qu22I90ChSSmy8HtCdO5CUR738XTOXBJNqSvZwRFhRXXvT/O4GTkoJ8aKLTlQ4m/HmZJGp2Z1TxxzTXUc4Z18QanimjdMpozIS9P8ysQPBdE9aW7rTj4E6TDPvOpeK9vMyOY1nEbedXOkxEK5XFjZ+8s/1cq1sqGDoSvibRUcim1gZ3sZOMkFJaUdvngCYjx10yaQvS26dBKfoConb6MyrMo7/vkrrnymbqEZM2N1qcicyzAQOi0LOklT909DT0HWES36k6/+1bavDu+9f6I+3zZ76ilHmKlFkOMJXn/hAbzygmm9lraqKAmcmADmG0Ahwn9qeyoJB3FBft57tHhFk2JPRlkoF9DAA+1Hv1+/9xeOjFD9SBNZe3pOnUTQIJz8un6vtq3VWR4dvP6nTzRNnzyD0wmIdpwj+EmfqP5Mvmtwow2sXFpFX08/puan1dbb5jBdKaN6Zh/qu47Lb/z5fT8RJfbSF7/53Gf19cx/dKZ+fF25OohqVXv9l+IkSUSC1Pbq0ueoqEm1Djv6Ccq6+LrHJonFpk+Wcd1jXVpEL+986HvTKkZt09xanTq2uaYskvlwRs6KXQ2OtNA0FWXJ2sL1tPK5vqKFq2ebUod7+EDHuhXpbgsOD0sT38H2lM2oE4r0PkJgORacnz2lsppPF467bg9ELvT93+2IOR9yHWsFob5ZVwsAWmQ7XoLKrMuFr9u4ujFN7PrvtibErfjWz52Ak/s6K+4cNCMdQmAnz64dk1/aUX7GHRLrQ6e+3pSf5XQTkpQKimBzr8lSystjvZYcfhno0GpbquO8a7WRq8TYjrxWE2YJNdSIVhFW78jPTPhQ6nciXcGIeV2NG1xnt6tyu+kqaakL9BOgdLKap+TVXETpuusTdCIVuqGF+/27eOM0msgLQOzo0aLccQWIgO3pRb6gQnkMI4qi8c1wsJo0Cwjna4+8IIRcvpV7GiwWZ24NCa+DdjHYy0mY9zKlxFgSpdLpTojpaCucztuYcjar0aC83c4JiqhVTvPfff5d1krKPE/bMG3euqozRQsHWhlIP1zM1jo9F0o4eb7T3StGGKVHc9Cdirpzh09LbBlJ+mSoS4uRVEyl0qotXZNrL+x48ic0yvYdYSimUDNApVxTvm5dkdo5mG5DvjU/Eei8h5zL1uER2AyUojADM9tcVLrcnnsElbBWx/4BzYDSpvQGc2F21cxl5qYGByMbRbt2z2NcZWkjYDzljbiFqbEk2bi08tcvPGPnVz/8J43dO26dNU9uua9kjrbWLuDqS2bwkpdMYIA3MTIPZLKraNWxMBDd0gihDnmOZv51vejPe4ABXXd1baVxKrUrckmGXtD/rMQlL989lTM7xfD88WqwQcf4XzgyQoiGTiw0bHQyAkIHRUxeGghNutFJTD4box43ZDl78qYvzOCghavoYuUvCH2fvj0mJhmabYVWK8Gx4xJ7aw30c4ENZwzigguX48c/PjT22ffv+PrQhp6Hf+39G3+9b6jz7rmFI6Went4CE0VARZJJlthu+raZiwJL3YwqfKpMBvPKUyBs4M3sAyQZtVlVgryQzXxlHNM4YamUyHcXGDJXmjZPj2QkXncPq1Equ0cLnCxjpeFkOnNxRc811V2kdB2AjdG4I5hL7eDjueKKGuOatEbzVKSy9q7OfYwohK5QYR9tbi0TjRePuw7Uaxy03HHzEvON1E27Y1dfNlgil9JNmcpa5StC1DVmLm1ySNHeERLJpYLqR86qSbqFC6clkLbgsm/V7heSmoM4A2vmTDl9YieJI8mJ3cksXqbTTPtd3KEO1KTCMyG1L0Hme/2ZFStNWRbJl8z1RJcWYXFkTuMSp6iGo4zkxWNR8LizrW7A6kK569Jje/qT2Q1jmXIsU8pWFTWIJmWKpFoKiKJDi37dJ0FaeqoH8u3Nq2wiZLrxKttCwcYGD8F4Ro4zNDdVSHt/SGtYagknBBPZ8Te9wbo9ixV3i1zn9MmkrzjZQMYdrzazD77tBJ3ZNIQzqUjEJmnE7FPICeEnKEA6Jo8i4N7ZmAirFVUmuDhpA5eKehsoi6hkdlXu+mQTmAVLbFEO63Ntbt34u9nBUhtsLxdigphWUgrdp0ZK59Rs9iwFtbJS1OpSKnJ6Vs5N2TE8bPcn/bQbLxhzv0p/fylLH7PkLQOOKp97W2s0yZUjm5FNun5Bci85o6IJdSggBbNySJv9Ik63q1sVKYeR2Ib7porjEkaPujD3KZNAmTUfd83xyAmfcZpkidprFXTU2ycHnBGg4Sh0UlFx3HQY1jOMyackc+U0PR8oYw7PHCE/o9zWsWZt5sZUak40BRdhkIqCuXGjLMm4FlMkcg7tWgKW9H72vq8c/Nz3903ev/PyOdx2k8KiIWDz2RXce49b7UmBKy+Yx1nLFfYcsfFMl2J0UlAsduOp/km26hRT9e/58otepOv4OTwcIAi6mYLtE8dRKKQm3moAIF/eIVCBOvSSF9mpNuXUOiebmyGXFBFZlmKyTk70sf3CkxHksiVdciH+Bx0I6ZJPzrh0wnEyLKRUFyXRJwM88e8nO7zp7z3ZU19fNI2WbNhQQ29vjFYnxNq1MYayEbKvTH0AACAASURBVHzmP1bgRNaDl617prj4iuVyxfEfq5mZhb33fnHw/de86dzvl5Y2X3tkYuSa/oHKsv7BxTzLREGqACEXsQqCLMskMtOuXZlb1s0iKanXoJyHIJUyFXx6pPTURbUQZlXydgmoXOdtKtPY1IMz3xHYBaQuOcGtnwg0Nn/PSPBvv5SkCp6K77zjaa0lCVSWyvXo4v4QmH+7LZzbta2b9GljXXWkpHOyU6pH0503upmwTEsvMJ9aOHDYTch5TxLKIYTrrKKkW1QySewdJsgnDcqHL0ZcxS547u5A0uhkjLrqsC506+M3Z5kNlfoKShe5HWRClBc3vkx1daFGpWQxpczYgUnlsHABsqGitTgjjj1B/zZdNQIp6W0I3CD4fqcOlSPgh07aaxnNBMqchS5RAj1aZbgFiq6POQLexdtpCUocY6sVsstA35bEdnHqAuaOwdt9bOkno3jvgIacTxqT9vh4tzmZrzVQ7UF68xfH+7R3vJRu6S3plvF8Jl/AszVPwnnc2pn5uhFYl6jpbnpffHBWr773g11BWJqXl73Y3IATnkNredtrUvoKF/OJmB17aXMR3+SF/Eelwy/drOck8VS6oMesm9XZO9tbJCslyVefioZOnsV9/kulGSLMKKIVu4yUTJ6tlInuZhAU40gcLmtyVF/XDtnyZLkjWbhCkPLskq6FE1e5SYlyWXt4Hrhxd6J00yGXeY4J/U05BwSjfOwu2UgM5qq0JLXJFQ+JYs7cnCitcZ2ix8CtF30HXV9Hy8EsZgCMbbed0ITehwqEdoYQUirJ2812KMIMMmujMduaUu3oW7ded+Dbo0fl3RNHZlvt+jxuTxlefU2AZ12VYtPGBrZu5SZuNZo1RCXg4HB3xiJfL1roE5pBHmBEWNUAAL1vyRJtZBri859fh2PHIvT0PLEU0WwGWL26iWuuOY6+vsTE6e4d2C2xkKvqqTbmBCRPBhbQRsdEiYmO2b5RHqEHhCbYBCHLOawyFArylDpkGpz8z1PxOeiLSeqbT0Y0kkGGaJScnIyg0EYHT5lgPhnRv+vX9aCRA6y+IMQohktYpqeBc86Zxwc+8DCarQCnrW5g1RJg7poQd9/Tg8d2t9XqVRezT35qN9qtMfzvD52mrvu34/fO1PbdO7ew8NFffttlZ51+cf0jYJ0Lyn19BcWjKJEMIijIEEFqH38N3kmq9TOrLrNgmSTZpCvBSFvVtEaDFIqsz2YXU7T+PlwRL5Ua1rvipKvlMnQfYDgBj6TVrOWTK0U8AhC0qcg6wYWqNKfmdSCIR/G5okQCbt0nXQ9c5r3vJcvZl5Ndk0tQlCTzcA+lWkKL6+XqfT26xetcOznmGtiZ9aBX4NqyrPO/1ANMJqKK+oUyH74ZNad1CLKDdHUjLeFmeiPpsXiGmw/1St/322A+RNsZkeiL+eHPYf1mlW/ezPUAc7vI92QealpiqgZW8+K5EDQjS0ezIWqz5IQ+MydiZLYNuhs8J9Fw+SX3+IaTXZyU/ChaH3rZsfLkXu76ndpFjSUaO4qsYyAxL62l5rWEyltLeIcuWIsosO5N7bMEqvS7CyStCZwTcBMcTnbjlnrkG9fYr9Sxi/vGBH4u8OULl3FwVxmiTJvCqyvrs+69xomfKUxRzzYd464gQgsLL/Ag/g0z7XoJcOx6YXWjJ2fdHjWK2O3d1tVZruzBuoUrA9Chm1lJ5oQ7uSIuSFDiyxvuWiuyLSSDMHs7+1hMjfWEY6iSxM565Zr4AuoLx535neL58fM0Xp7rn+WqY3n2DndMGBIS5V2B3VzCme+0SUI0e31Et0xEckDm0ho4UJoz4TlClLTbMhBMM0m3ftJIoXLOwa4QQ9gME05gLX1F11eKXI3QpjrSF6ksLCp1UYyxMArBhcjSNBNZ1hGSNZAmLbRbScJb5cNyIfrwd/9h+0+O7Z0bqc8luOY95+DIvojdfxNTz3x2C7/xlg6mZ+2i/UUvkiYu7t6V4cQwECfd+5r8usjDi+ImNbSjmKhft4kDw09+MoAbbliL0dEiSqUa5uefmFEIoXDbbUuxdGkb73rXCI4dyz9Hdr86tv68hnn52H6qjfIASqDIhM0kUfr9OiuhIK5/X7RIf0Cg3eYolTITGLXHvX7PqSxdCQqi7OlUpRg9KPokNCSTP0lKLggFUerU5isnf59+D3FQaF951IQSq5MHhxIYXQJav1732ukYWOr4BPDKX5nGK145zT7+8XvlzTf3Ys2aZbzTTNWhyf0onbuBN+4J5cJIPH7bZx4av/vr4iW/9r7nndbpxL95ZOb41X3Le4YGBoY4Mh5xFkCIMHaEEJ7peontkE/UqC6T1KzxZbf/uW9B7xvdcU+HcPVYvZeMWlhYIAPUkYQoFXqxwN3nnYyXeaCA2LEW0ujK0KSfNtz6rNsFo8swJNKtfYAl0fC8eu+k8wNxRfy800X8Le8Rrss4d1QV5sWTetGtbHmfjhimy5eJya6BNyNrL3t+kkDXbkQn7NrNsNxP69TJ3p6OQe9dEV25EXXj78o7ijjEZEVicVySSVugAa7Gge6y2yclNPnSgMIyJyhH8sIasjewwTazmVcuAHihlEfEufR3CnNNluGqIyA+kS2FS1cd7yonLPDdreewvM8N6wZbokQ7pZik7jp0ovZhfwL1mOKlwx7cwp+RkszDOQZFkyBWhwPUnUm6XSFZ1rDBmZgkJrJjdnMoz22AT9GIHSrhYXym8hGQe6pkjknq4r9y/Z58vHdxPrOYgOp6MNFlsZ4dXe9AG5qlhyzdXGjHgBG0AWs26p643HMsu6wHd4iuKbZjYhOLisq8pszget5RFYtEHbT6kMTBthm6TsAyD8OB5goyAYBrjOFrVN6nw9VdjLG+vefJIMaluFSR7hZSbeXUCoXc8sabRpL/o7s5QIkVJ3MvSvdpLdW9vspbsnqcwrnP6j1JL2niLvmhOm8ebCVo1fkNkCWeUr5/mAVLlS08WumB6Cp4eCQQBIFpI6MdU9OsjrjTwsJMu13M+m4f7F36L9/89L33735wZKw+1zJj9KrXBPiT3z3Ab/2RVENhhrPPkjhy1J6ppjPoUszOndobCxgYsHGXmtLpWKndU3WszTunExeEYiKVQ8KQ4atfXY/h4SKe85wim5rK1Pz8gj5m0L0Rxxw9PSk2bGiYGH0y+TTfZybvwJ7f9HHphT8JTU7e6DO6vETIiHV4t2CEePnLu17yum6jT3xyMsC1125EqxWgWJSIogS7dhUhRAcbN8Y+oSD1ikYf9Gsa9dAHrAeKVC/6HyUxeoBPzqpUrtUw9bjRn6HEgmpXp0JbyIhFv0d/Rl8cPRga+dAnp4+H9kffRWobkhvnYaKpKfueQ4eGsH37HPbuncA1r5nH5MIUbr0lxbJ+Bp4EOPfM5Wi30/Y9dxwbffi+47c98N1DXztj87o7Kz3B8rnZ6bU81NhyKrJMci4CLoIgE1yve6w7AHMKHLPmzM8+3YUNuWvSKok5QVo3jPmw6ZWnZnHBXRwhW2KSyXdFlfDkOuaVkIykIZTMOK5lrm+5oxLQ0clufuQiFSctDRVh/OKGaIyuqIOuntKvo5jjm8AHMTpVMul2KYNvI2x3QyACY65e4lm2vOvO5BR9xMexuDBh7JQhkWoWPhZ1GZl2IS7zEhArR6BczNuBS5AKgtPi354Lz3NkCKZQ1GPDCQ5pdCnQUNLRvVR+4Kg1v3L4i0dFiF/Iuhwj1gUi/FrbZ4p+/OGjl3Q3FNUxeFf341OTbpLfhZm8wtgSB6hnGd0RJMRxPJocp5ACACEqOVgJ3YKD9P1DXDwnXoDPX7paTAqLfk0rTlqouxDrmZ/MNthxyaNrsqeopOh8MhlxtDyJRPmDoXYm1OWkS192onziaHu6MSNqCHP3l48MXToqbbz7sdyqxbXyofH3mKfvbaAkzRdemUweGowACnhUy+FhilHLHpLP02XJ52beAY6x/FXOlQC5L+3acZZ+TLgnnSp0u41l3kjJ3Wxd2SzRjn31hUnmGShkjah80p/LhIl3nwfiuOPRe3M6P/+A1lC2Zikdl0vR86tvJKF4KCQXpu+PvtpCFHSi0uHz9TnoIJ+1+NFI9f7t9Z989L33/ODoF48cWti558Hj9fZCgmpfBYsXrcfK5Ytw8TkncN5Zsbr0khQrlkpMTtmLrk3Ihoetp1a+LKJPUCP+OlnRaAJRG6gvHKlWibOhERZNSVi0SOGCC+bw6KMV03lfqSbSNHP7tJPg6GiEV7xiGK9+9TQmJ38aTMjvX++buu/m/+nEgpQ0TyYp1vvR79P7iZwCiJIb8aY3WaUL1Xp0InH99ctwxx2rsWJF25zoypVLmA7s27cXcd5581i0KPMEFMq+gC5UpL8sj0zoTScsBPXQgNGJVSpg1MCHyi9UttH71vukzDBPgqE2yBT19KYvkB4QepIp0clveWhLv5ca+tD+d+9eiuPHOXp75/Frb2phbKKA22/sw9qlFVx15QzCvpSVNlwoxmem1YY3npk2JtPZ7d/at+fA7tmbzjzv3Jt6B6LFU5OTG5O4zZKsrfvdaHJZwAMhglDIIAxUEAgStbppgRGjkIQKtipP3Qy4p8MbNgj3dNLcoo5IgmQTja6u1TkyKD/fW9WiTUU4ASDu6VZ+1ercFymJ6bLcXV4iCfinIjmnwrZfdBhchNu1sJuPmO0G4W00GUlC6PD8LCTtqdgKlcdjOPcFEeoD5hFoHzLt9zNf4LEaGHJL4z7AMbhmhTRNu6I2cyxUUM3Bpwoslx+4kpUZXElNyLvdLlzw4669mcwBdQ4k4Kybz3gMB2R8RbgRmecTcuw+BwLguS8fgBan3GItxs2LcwJmLCfZ1VzIFMx8ASMuro+eXVYKz/u7wPUIpOyH08FTUYUxbxtiK5KMkzOHS6h8scfjCGR86goWTpUCam3vdbFU37Ndnpznrn8aXGChJMiZrLg+a13CDaB8ekwSJ6tpoYKLaTBneCrUqIhzagfgWsoQPYfge+YDO+umd7ZAR/2jLWdcdd35KAH1vXfp8jmHEFLnOqGVy+ZsdstskdEOtaDs2cVWyf1wGeTTcpFyrRa4z5/hOj7mqib2lGw/THt/us8T8ET5IaelkpfvKt/VhTmQt+tWR13rbEtlVyFi5Kbkcz9O/ZPguWtd7337FZzSK5fgM6J4dctUOcCqm+HZ+UcSm4WeH/JYoltcuQzItSbmgrOgEMqoVERYCIVEIiBSIWXM6q05TI1PozbdbPZU+z5XKa58343//OinfvjZh244und68pI/fWZr4xvPQFZPMdgawGD/ICrVAprNdWz3XoE9ezI89FAVD27vMW3+V6/OTFzSZRKKlTo+6hhF9IS8bxcFdx27dCyjJEDHTf0eQk82bEgxNFTDvfcOQqkk5zalwYcIV101hXe9a9QABvn4SeRYqmrQ/im25/8xZuP2qZAV+gwBBxSzaf+mIqL/o3dgMyab4TQaulncAhqNlnltZmZelUptLCwIc+AbNsQmufBzH3viv1MFfv0d9Ht+c1mdouTANMdr2jKKPmhyhSuVnvg5KhedChKi4znVRp/T+88nNPmsjzadge4/KLD/sfVYuWwAS5YsZu/6gwkUyqP4rfful81agGyqhUt/50K2/csPq4FzV0xsve3gxNF79u+Jetnq173vuWt6FwdvGj0x+qKoHJajSLOYWch4CJVxhIUCokKEwLD6OTJNEDdwiqFASF2rllI6rRzrcgksy4MsrsmygBb/zjLAZhnOGonIXK6sbLUaRKKgx9u9URLhwIYLIpZ6BV1m2SdU7fHJExF2M/sV3AGaSjrsWK/ThFmBWoNL5Tj1tgmnoyN4S0Pme2flTPUNAVjS4tyB4bZlKBV3rIDSpTnSBgQFKpKDyCxw0Ajr4kzcZ1QkkGTc2ekq6jTCnK2D7UHOLPNW39YuIJOJOBy9lkK0dGQF7nEtWsXTqs2FG5oDDIOAc+ZUqsQLhOdYME6SCGWLU5xZbMnRGaltonRAi8NRqHJJR+OCt3SKS2sxYusadnFIpSlGfFgmSXPCvIrbyYkJkZG+KOXOBs5UXysdjNDZFF+4U826J9rZ6vmUhHS5hE245mguJ5YuBVR0jxLfyt8str++kk76SuVPFxodp9I7aRKE4nIKx+Ageje5tliOlLujuA/A8DCc8vcOoxqQpFoCsbwdQ1fCk6QMDcaVQ8iNh2UEiHab8Xh6g+Rdwq73TfRgjWWJKfISVOQtZlMbmevs4vMPUJoJzzoiuFW6DMwWzmDnB8clIezUTS0ZEcSUo3Ebsrd5t9AipozplgTcHBs3vCwri7Wd8oiVxDzB3j0+3I2/8jmJuz6EF8GVjx07nOZ/OjulcowoJuHxUupKwDNNGrPWK3QkyEQQ6r0IKVPEss1VXEfa7qATt9HuJOgt94+WZe9nv/+vj9x8bO9Uc2hx/8H+RYtrgxvXINk2ip4VFSRTDXb4lsfBZ5hauXQVm23NqE6nBc7H1P33lzA3txJCBFhYCPDHf9zE5ZfHBtnXcU8vwt2iXuU74yPHz8wvxLv36xPtL/Tvu3droKGF5ctjjI0JFArdQNzpCGze3DBJgUZT8vE0B2+fkvbwn93y+w2obEFB2uqTdRDMoNUhems0GkhTfRNx06/mVPWiJ9vyZmWn0jCfXOOiZIUQDVLHnOo7f1bS8VSOC3ji/k/+Hp2pPr6/gkceKaJYWsDklMTddyfqoouAKJ1Gu9mLyd2TaE41sWhNv+mZs++hA5g8PD0OYPy7f7ftwbCs7qnXGmte+c6renpXBWcPHzxxdSri84dW9wSMRWEaQ4RhwCNRRmpqgpILjRyIEIKLTAgjF5AqNSoyYbuAKCltnxFhQ7TMbFwxsKFp0mKSGAM8SyeBZZzEirZ3eMqFvpqa/WUWjtw3v2Xd9RNyPgSwFWamMpkJcnbXQh1jmaU4SQAMfUHZ4qpbTEqphCGoZ/r7pZKCpkDVpY1oJZ21mLIMO3dIBvCRimVuOtHnkUkyadQqOgssCSps6w/YyoyOfWa2SV1VSfcWVA5aSAz7X5DNgyOmSIeE6wExQ8acKxSXBJD7ukS3TbFxzuDMyiOhDOeRWgKbeVXqzrq6J5wOO9xRMC16YOiR+qgCy/NUxsVCascmT4M14y6Mr560ZldQKbeAs08umXPKsKPAUiJ0mqY0zBOJmXstIbjImMtbcYtbPhqFskuqBHEUHIeyywVwEhUzPpmjP1vxCJdcUi3EDKVRjAtXvdNIoQUXbK3E3CxadeCOkEzWLeNSGusN/Vebt1iPCm4b2XBXqZEmR7IRVNqmWqqL1zMh3ZSuhCVu2Rw25w+nHIuFO5mxlaYokr05VqnLfDJnrSfM/QHpmgwxp1O2NRTnU8Ms+9UBgpYp4dvBmAfPpHCGAml3bpN/bsi/To0NYlJ5o0ILoxJPwzBZTLrHqU5i+ejU8QaZpIdaUYyW9oGwLBzlJkR7qc21TY07l/4sg0qc3bBBIIwrgSSbdMt0kYrWM/qIzQUg0m1muGFMuQfUhFQmfVVY2Shg4Uj7NyU9jdVl25YHQhYj0rT8l74rN1eO4WYH06at0l05Z9nEAigWuGcps2VOaUizUrKMKZkJHe5SmSIKFUqVwGQkcRqj06rHcaslpyYb9bRdeHT1wIovbf3Kzv0H9+xsDvb1Pbr7/vE0yRLMDY8hqsziDMFZ72BZsd4KpvdPq1athfJUGfPpnGqlLWRZimazjWo1QbksTaf4clkgiqRfHANd9J4SC/p5cjWAkpST6Q/0fsbIFoMbJ/KTY6Ymr9brgQEMToVonGr//5Ub7T841Rd4YNT9UQihV+xPO/jnOSUaSiJyyy/qpP7rNyqMJpCZxOTkrBoebmPDRn1yEUTAEBQD1EZqqtBTQNrJEIkAlXKETpzi0GPH9DM0lrTV2Hc/8QAqfeLWyZGJa9NO0vfqd7+Ibzx/0Za5+bG31Tszz0jS8XLvUDksVQsCccbDMCoXi0XBEYhEJx6ZgtAPkzBaQ6E4hxAOPbbCj8yu0PW0zJkmIHPjMMC1s4e0/grIbLM0Q3y3vTWY3hXP7FRipLYmA5AZc/ZrRqqWkXhY2ZlPY4mCuwbfjHMpTP3brvmkm6K6mhFDM5XKtX7VU0GWWvkg667WIVTo6KVGT6HRooxa/Fsyhp41lNBxjaSuzhKLmDNmjsmY7fajJ0Hu+mbBREOhXHdMKd0qSliBofMLcJYqFnGjZjeZQ4WtrYJZ14Gllu6hCfjKLnp92xljzSDdIpFx/XnmuJZc40WB9X1TxswAWjLMuCuRM2sH5/jMJhmz6hl9rJmdn41JmgHQGCkkzD2aSaQG4XCt+nQAt961bp3BLHeVmUsqpTMxIyKBQJfbqQNUZu8ZEyPtKj+T1iaWZzqFta4RJgERzOUeRCUIAnOMJCexPhfcNeLXLwlnOmHShYxbEE5ZLy9rLiqdk5nWSCh3uPqeFDqRFTodZbbUxnlm4Q8lhAnJAlJw4tpy21ktS00fXC1CzhyXQZlXtAw8c/oJoZxyCM5kw95PKrW94mFzRJ1SaKS+W1PR97HmGAtFBrVW0mUyES3vVMw1flAmKeLuyWBOPSJNMiddGiBpUW8NYPWqnZoRKgiboWjiqMkvtX2iS7gNgVVIRgZ/EoLkH8w5q3hGhjlFbtE9rs/fXL7QOA/b03ApIJPGp0svFDIDl2ScGb0qU85+12ukDGJEpRGe6QWRvqIBLCjlNPDkw2JyLm5WSFCuKZZrSGftUdwKRXpDZerhz5WQ2pJG2omGc/tZCwhxC1hZPFGvAjTyL/Sb00zP4faRz3hq/lwqRjD7S2OkaYJOO2mCyVQmUTZ+rF3PEjnSN9B3c280eBMOjE/c+cWDSb3JFnqKJxYe2zmCNO1golSDvtUrfRrl5hBhEdPHp1VrvoVSpYSwHMI4D01rzuQCsiAzi3odU9Mnaxhz0pavPDyd7WdVLP4nbr8wn5G82RlJjJ4OovLfveWRkYy6uCm7yNJJlX4tikIUi/ynyDk6IdHzioiEFQM6WLPaX0ZYFGgsdDA7NYuZ0UTPZ3NBb3Xu9pv24+7vPXZ46vj01nq70wMuxdv/7KWVTZevWFJbaPbVavXnjJ6Ye36rVlvSO1AoFXsqoZ6ERKCCqFoIeFQgc1KtbY/iemLmS03q1omSnlucotIp7kyrdmGlqy6KWHDFPKBOPmricqb1G4wL5clh1PrfprDcRnnS9+gKIFLrFEasfV1sRq4JveOIuFbl+vsDy4EgPwVFRt1MQjcmzExakgVOK2INsE0ma+YY6ytnjkU4GaUF4hW1EFXSVQKEW95L64xrxkJala2JJAakMbaTwlH5ZKpce18zKIErBLnqkz7+1LXZZ8b3yCy5nFOYzvikgxTs/rmpwulkVuixCZUDtR0lWCGwuYhJOHX67hCmwNe+rarYREsLjJlFdd6+XZl7Q5+AcpIYsMAzQSwPVGqk3DHx7LFzAuRNr2fHBxHo2qI7OoYit1CpHBPUfAEEAVACEbnhgGw4lDtSTzG2beXNNTf3hrDSWaYE9/QU/bsxbTDyS234ZOXm1ijX8oWYqfNwyn44E6SQNc8qs7Uz6U7c3HNKBa5DIFhgYDaTEHDzSRUqV9OiHCZJHArGRbd2zhw7xhqo2fGnScItx+29nxmcyqE7Opt2N44k3bU5RoiQuLY62wtg1gwKKrDQg6P56j+HNLLmIXUWNpa9yh0/U8JnhlbpbIx4ct18Cv4Z1GOSZdbRTFuC6pqxY3qRuyIsp4hY8ALuEgorLrfzhBCWhkaqLNa9N7jqUrsdJcwes3lnZp4F7kspDk9TqfeCy/TviuYdTssbs0+ZpvrdusWtPeZUOv6Eli0qtK21ndDlb53JxHFsEH6NRhhY0QBZKkWq5Nixehy3EYeyMFUol3/C+ZIfF0XfkaiMzg8++b3m/h0n6uWBnpnFS/plRUnUZlNcfOlKHDsxh0WLtP9EEZ1Yojnb6jbs06qWUoSO6HQLYG4AtXolp8L6/7f88Pyi7OCpJKPJMCRFou0XCfc8ne1kCIykx/qnljlpHTb/z944pvQkkcUZAs5RHipj6JIVYJUI6569hm1Z2aO++JbrF1oT8UK5WsKNn30IP/z3HXuSNEOn3f5Rrd78RF9/MXrta84Plz1nYykRqj9uLawbPz5+QaM+tSXNsuUyyaqiGBV6F1eikKlQzwptmcb1moYB0iAUGY8KYci4ENyueWSrITMVp8iCQJaqnAsmA7MK1Uu8DKrVyrJiJBCGekll534NoFiLMqna9Y4UUSB4GPB2O5MiABMhcaIUGnW9OJUolQOWtFLjBFfoKTIWcp7GGUvjNNP8mVaLy0KkVBQhkFaoa1ZEtToynqWMR2CZYqlMBKoVxoNIilRxNOsyDTlYmoIVCgpB6Bj3lgGvlGB6xkJnIRZpKlnCI1R6OQqh4qnBj1Ss5/G4Fpt1VVSNwAOhbFE6k3E7y2TGuQg5jyKWJc2EiSDgPAwMvC1lKrNWyoROQkNuVqmckU5UyaSTmJVbOy2aMNFTzZj+uI0hmnWg2mkzZYlUPJVRVilzFCIVKlOmS9DqqCRJQkvl0bUFHotqRbAw4CxJFJptpkwuGrdVFkMVeyPGIu4KDpLHzVR1OkIFGhySqTGGCCuhElrjp09fyiReSFicClbuFQgiRXmgLXRIpetaqtXkHGlHiVCyqFzggWMUJLHM9O2UxJwVIigRmuAruVAG6m4uyJSnCbiQIuVcxVmAapXxQEherzMZFrhGv3mSgFWrYGGgOPl46Um92RRJFjNVClIWlrnqZBkLA8GjgBuBWCZV4giOIm7GMoslj4zdj15uWsVxowHVjiWrVvT95ZAIU9oCW2gFia6kRUy3deCqWAlUMXQdrHWW5Ci7Oqg360pFBYaoaF3D9AWtzatUZYxVejSxK84E4ywIAwMzyVTxRkMlhQLPohBBq5bwoCAQFUw+xZ3tWrryNgAAIABJREFUiv3ddluUnkNkcBIp0nqqU+nMNT5hhVLgyDzK5FpxI5VJIlSpGuhnN031w2NQUn29zPWXOiCKAmcaorC9wTV0FOj5KGgtdLJOGrByj2AisEUjbtNATr54JtnJWFavSxRKjBdCy9jRqEi71kk0nhNVCzqNUipVFuSwPux6snDOt9y6dui0wPTDMd2aRKMOVQj1uCrIzOUvNp3U5WXEjXamm8BpaCaBkMWykMXI4tT6uWo1oUKZGpAwllLqJKRYLShZFLqkhFBwWZ+M242GmK72R+P9veXhQhKNFirRHErRZBT0jQSdeOo7//C9hccfnUiXbV6aFAMxvbQvayxZXsaJExH2bZ+xrUzGa7ojHdRQCaW+EIdPzEM/g6tW9GK23kGz1frvDFv/IzeK5081rjP2xHKQ5mpq0ut/aTJC9Sz9k2S8p5L4/L+ZkBA6QwzevEKHvE6uvvogjh/vxZEjJVxxRfp/dqz66U9s1q4Rk8rKXiw6bzFEJUJrponJHeOqffYyseFVZ2bhjw7iipefLnbccTjb+8AI7aFVXTx4fPOzLsXjB8fwna9fD14KEQYxOkn7G2ma9kkpS51GGqiy4K/6+xeKi8IoaHZKQbMQpyurxaAyVCyqZj1qz8ZCiaDYyDgrhDIrLeZJXCjJQthmC9OtsNmIgkiwoFhOQh4FWZZU4lYz5eVSm6dZirQt9fSiQwNkyNTitawdMLDGguSiRw9eqlQ7DfViO5ZCrlkvkiCIVK3OeXEJeFiAUq0MrWZbsipHKCKVdmQWDKQ8jjO+0CmIYkmyKJK83QnUysVpiweRajVCUQ6TLIwkn52FCAKwIOSqMJippJNBs2tUFrM4S9FWEQ9SA8wnSqUpiyJRPasSqCxR6DTQaHDB00yVexnrdPRHeFo+vaijEmtNxaoUatwAQdZqxdmiatIzEHGBJFiYjxkb4pnQga8VC52fRVEpy3iAVicOeBYTj4MxmfJSuYRSf0+nFqukEKRMpJ2gNg+mV2csVFylur5SkKy/ggJaQSAyNd8QLOkoHpYyVSxwBAhjJjiLeuMgyzpI5gWLE73wS5koIKusK3SaLYUgKoQBT7PGVEc2s0IkQsUqJabCxciE0AE14p12YvgRXEpRazIVRIamkJYWRaqnJ2Xz8y01vxAILniks9ViyGTIdCqRyNIqFoiogHrd4NwsVRkipjE3ododGYiSFImUWdoRaagVjwUeQfGksFSnagGUCCKWxjyTqcqaGROC82BFQXY6PCkWmApUKmZnEq4rOKmMGDoJ52Umq4tEHBUF6mnI42aTRUJwnXA2G5IXAp2I8VatpWQUsJAv1fT8FJ26ZPr8NcSVdYRauYiLqKBEo9HJdPCQSVgoZCmK1TBlK8NEV38kYqhOyrJEizRDriOsdiTIFNJ6JtJAZnzdYKxvKN6RIgil0vbeWWWlSDRw2GxqX94MaSthKVMBKwoe8EAFK1lLQ2ZZjEI2JHmrI5kuFEWBkWSaul+7mWbKCc2Edg3St0WSsagvRLSskGapSBlP9eqAtWspEo0TIuDVsmLhykKaSqGQJLzdSGSmjztjKlYBL/dzXgy1q4BSGY9F0uioJA1EqSwY68RKhVyU1/eqIE6z+nQHLalzOFssSkPFkzhgQmQy1K9kCmsW695bAdoLKUKmmUgFRMujTsSkbM7okkdH3wSsnUYirErWU2C8VhOG9VGpcNlsGHmCKJUhGrFiBRGmGxYx2W4mupwqZJpkohiCB0HQaEgehiIrrSxJhGYVp7SFWNJG1k71OapMFIqyZx3rlLmQk6yk2u35bP1cpJQK1WOrYrmqFqI2yHHrj29PZm55vBOVqu04C5rlgVJbtZJ4bkrKwWUlzE1yDB+eR3llD9b/2iW4okfiOf03Yu0m4F+/BBwU52JpqQX++Aza0pBLDF9nfr5tUKNCQRjBAfv/DufgF7aRsoe4Hz+rAkJcF7IHAbqq2f+SZIS+nEioJOP9We2L/zsSklMNDMmLtISZtrynv1byrFzZxB/9URN33lnGzEyERkMYrxUPej6V784MCoFll61CZXUveGgdQJJ6jDWXr2ajO0fVDX9+R1Yoh6bBwd5tIzJuS/Qv6UF9poGeRT0Iqn2YOX6C/c67Hsedg231yU/bfb/+bc9orNy8ttFBiMmawu03bMfdn9+Nw02JA7s7GFqd4Ev/HqDa/0u4574hfOnr92DvIzNgLEC1EOOj/9KPJRc9H2HrIXz8d0/gwV0VQ6Q6dDTDqlU9+P3fOxv/cdN+3H//BFYsC8F6ygZ9aI/Mobq8ghf/0ytwyycewvAP9+Cd770Ut901gj0HZhBIgb5SHZ/7QhmHk+fgLz+4D7/8qUuweGgdvvLO67D9h0dxxtmDeN1rzsWeHQfwm28fxTe+WcQtP5AYHAAOHQZWLevg2m8VMTL0Khx7rIDz0iNYvO4BvOe9DdzwvSI2b8rwj58N8ehejvNOb+PaawV+dKvA8pW6Y1RkSgmZvphC4PK//hVcfM56PB9fw0f/eD+uv70fVe1FVwigl3ov+vsXY+3mZfjGm6/Dwz+cwsAijp6VJbzwd16AZ/SUMfnQQfzojuM4631XYNdXH8MD1+5FqcqwYv0gXvLul2LHDx7A3rv3oLK8z1A2ZJag0xS49M2vwgXPW4WrN30ZQ+owXvvmAew+HKC/miDVQJHieMXHX4ZfPrMPp6mb8Ad/NIt77ooMRB5Evfiz//s8vOr5ewAMg6OCnYcvxQfffwwPP3wMW84v46/+dB7X3RAi+ZXX4pxLl+MH7/waph4ZRa3J0ZFFvO0jL8TvvOwobtu/GqObL0YRdXzlbd/F+H2H0dIo0+pBvOvml+E14VZ86F37cdu9VQwMKNOAa2JCoBgAvT0x/vxvFMJLX4FDdwb45sdvweHRGgb6C3jVNReh1h7Br75kHz732TJ+dHOA/iUcczPai6eDT36mgJGNr8EjWIkL9u/H807bit/70Cy238vxdx/L8KXvFfHyl2Z4xfNSvP/DDN/+boQVKyWaSagTX/z7P7dw/pbF+Lf0Knz7vQfxyi09+OGdk9i9dxjFQgHz8wKVQhspD/H6b/4KzjltI778wa/ivi/uQ3VxBQN9Ab78ZYVNKxP87gcD3PB9jo0bMtTbIVr1DJ/+WAvPvGIpbsYLcAbuwl+84zB+fGcZy5bD8ApCrSpoK/T2SvzrP2vDKIbrvggUSgLVaoZrr5U4c3WK3/2/IpQq52FsZhyPbB+GBhj7Bhk+/ncpvvKZDq6/cwBvveFlePjT9+HoD/ahd0kVczVbqiyGAtRi2nA6OYNGRFUpxKv/+RW4vK+AuYEiOvun8OUP3IbhmRqCJMNMK8I7b3wlXr98D972kp04MFzCmtUcHVFAOl8D+vpx1d++FA9+/C4cvW0Plp89CJFlWJiWpoyiFxTX/PuL8d7T9uLDf7YP3/p+EQN9EqJHw5MJQpZgbIqj3hA49yKGT3y0g3/8pMKNPyqgN2ijf0kBL7j2jRgYGMKdf/BFHLrjGKLlA6gUJGQrw+ycTsszFCsc7TZDpShRiBhm5xUaLYlqCfjidQI33Rrh05/oYNm6AFk9xswUUCknSIp9+K2vPBfvWLMb27AFm7EPn3rfI/jCt3vQvyLEslIdf/URiYnzX4bRaCNWYwSN2RA3f+BeHJudQX8iMMUYlr5oOT78+gk89PUC/uX7KRa/dh0O3TWNxa1H8cG3A/duA755Qy/Kz1iL1olZtnOqhjUXBEqVUoxGa7HpFRtZ9vAhtY6Bjc21cfTYgioUApOEME/ENiji04gKTx6nNA3gfzKN4VSbUl1UQ1t/kBiEzNdOFd8pEcnTZaiHjrj6avsCZSqVCrBvXxn79vWiUrGfsARWhU6H4eKL57BiRQJCpwgNIfMTQhtOZuXqA8038ckfHDmy0ft0lkRaZdJK632fSo2jByNvR69PMt+3hjxKCBrKl3rzyQppt/X7NKqjk5XLLkvMOd999wBqtdBMRNpGfvXqGHfdV8XwZIj+laGpD2sOhCgEaAzX0ZpuIokz9K7uw9B5S5C2U8QLMZJGDJlIaNg/S/SBSszPccweqWNuQkN+Eo2aQtZJERQKpq4eyRpe8px5XH4Z8ON7ehHzKvpWlcTkyAI/vnecz8zWWKvRVqrTQW2yjoPHF9CzXuCtLz2Bb37mELZOn86mT6ugM7kL7/nVYdy9bQGl9ZtxyZZH8M8f2IHZY4N48+uP4eUvmsTk8CxmRqbwlqsP4PwtR/CTG+ZRwgBWvWELwvOreNP52/DCi6ZwYHoJ7vnWY3jL845j2VAv9nXWIbtwCENLevHK83egkkV4/MgitnnFHUgWF7B7V4SbP70Na3+5D009FQ8WsKySYXrJII63V+IlZz6GdDLG8MEJ/P7bpzFWOBvbw+U4P/ox7r+jje9+6wBeceUYWgvTuHd3iuiZG8E3LMJZ0TYcnVyJhWgDXnnVLlQu6semM5sYuqAfF288iG3f2YfaKEMYRhgcOIjxwUFsf7iFFc9djqHnrcLd1z2GpWPH8aqLH8Tc6Ay27hVY+8ZNePfrTuDWf7gTn/v0UWxcW8SKCnDT53dg2ZZlGD7ewIFth3DhpgJWRAnEkgjRZcuxdFMf1Jo+PHTPCeD4Y3jZZdvxwE0P46HbehGUl6B19hBWVjgKWxZjZU+KZ2/ehcd7+rDzSBNnlR/DCy6axfKeMn7yIFB9Xi+uXHcv/uUvZvDDA6djZsNaHB/nqC5ehOD8Kh65cQ/iAxIPPzCOyayM3tNLeM2Fd+GtL57D9TdOYSE6HUNyFv/61/ehcd4iTAuFfd+4E6+75DjO3jiPZz1/CqNLV+FzH3kYC+MCr331FF5+5SguOX8GM2NT2Hr7HGozs7jwvFncv30aG6NtePC2o0jmypifm0XzolVYdHkJFxQfwOzuEoJwOYIVg7jvrjGo2jEs6ZnBkceLuPGz2zHfHMfiYoS7R8rYvn8G5w0exSPbppA1prFl4ywq1Vkcb27Cc688BHH+UhTjXqjTBjAq+jE4/QCitIFVPQexMLoHL372PKbHp5HUp/Det89ByGlsXnsCcX8fVobb0Np5HPc/WMd5m/pw5toS+qt78ODIeiyw9XjjS3egfsZy3Pq9cVx2Zgvl5Stw80IVY8069jxcxo6fHMf6gQRTI02sHGL47TccwhUXzeBwfDrGH+/HkhJHo28Qu3YcwbLN63H/veO49pPHIFevxeCLlmNF0sTiOMED947g/E2j2PXoAu54IMSKFy/Gr266F89fP4o0qeKeOxYwfGAEF5zej3M29WKozLC8yrFsbRXNc4fw0NZj6C31YeXSmB091ML8wjymezmWIcGbnrsHJ05MY364D5ee9hDmjg3jivOn0VcZRO2cTXjVVQ+iMTWB8dWn4cjWR3Fo3xxWvnwDfuul+zB1YhwHl52NRn0Wu27eh7jcg7l1q1BuJSgvXQJcthwbRQ0vPW8XllywDvXBszFwRQ9YM8F3/u0Q5CUbse7C0/CiDY9i07IAj4sIZ7MfoFKooHHRFrz0sv2Q+xPs2TWCP/3gBCqrluLm60fx668YRgH9OLhrFH/8jnHM1mexZ2gLaiuXYtuPT6DvwkU4Oppgabofv/OmeVRL43jG+sexqXcfbmmsxYmdMZKRebbhrAG0Nw/h4OFRLOMn8MOtczirsA2r2w1x745M/MeX7pYLR2c1hILZ+RaqA8C6nnk8dEfCplkFpVU6ESzgDa/u4FXPaWDzFmDbDoajtSEEWRtjD0/gtOU1ZEXglsc3QiYZGkdnwGfbbPMZi9jcfFslSeZ4WJYnEwYMWlzQrCfGkVULCjR8W6iWENdjBJUA5aVlK/6YZWBt2/QSxi08NCoaHedmZ7XviMAll8zgjDOsqai22qAqA5mGEgJxsncW/Y2xbjzUsZbiMIEEOjl85JElzpQs86iOVtKcc84Czj67aZKKk7eT959X8uhj099F+QApYElBmyfQ5mNv/m90nj+FjOgv0wMzPV3wnc4KhQJaOuudZaa7HyEelN1QEkIn/XQ2/RlqipfXM5+sn346G32ejGJoIJ/qPvVndEKiNdenn97CBz7wOP7yLzdhbKxoZFBPeWMMca2DtJlLAzUn4vicyqIIY7U+vHDLcVz+vHm0Ur0yskS3rXco3H4XQygFCmWOpAlsHauCnbMJG4oK6en92fDOUQzffxhIGPpWDaCyvBflM4dw4S8JLDl3GXvPdYfxwNcOqyZuw+AvrWMXPaNfXfasWRyaK6DaPMAeuWFY/fgHZXTSCM9+acRWrk3UO97JsGMnx8RcAytXAS9+eRk/vJmjsG8KnYJkfVcUFEs7+Pp7t7Is66hNFzB86UsHsGOsyVY9a4maOjrLpsOi+pu/S7H7wFa84Y1t3PLF29kjO3bjiitb6m9/b5bdeFdJff6mEGcHMY7v6EdjeoRteh4wVY9w2TNLavXpHbz9PXMMS29X6ZWP4otf6MeJfVW89qYZ/N4fAg99Yg2u+zzHBWctIOnrxZ0/mWWjcwqN0wPV6KQoloDpuQznb4mwaHYS3373Lfi3yhL2zj8s6hq4ChYthlyI0Tg0x+oPj6kbb9yFs/4iwe//KXDgMysx/9g8tv5Lm+/ek8ixZgu7dk+xHVsnsHJZQ73/D4+z4YOJ+qePlXH9F3Zg0dKIxdUiCkJgZrqFE/Wyev0bQvzWZccQSuDff9iDG74n2LN+eQbhORzz0y3V6IClsx31+C0HcdO3FbZ+J2X/+zeEetblGV60fp7Vh6T6wnUnsHlG4as3lbFtV52d9YadKphqMKEnkUIvdu1YpdZ2mpgaOYB998zg7NetB67sxUVXLLA3vDFUf/WPW3H42wmLg6Ya/ciPsNCu4KLVChdcASxfBjQ58Ed/sRP3fYdhcSVhF14A9G6E6hXAr78VuPWukvbDgWZYLByZR7s8ibC3jGRcsNKiitr18DAaMxxRqQ97H5Y4NjHKOtUKioVI/cY7C7jsshgf+cD9bMe9LbVzFWN3Ll2J/i2LUFo8pEZbs1i0OIUKMtz9QILR6QLGDs+yxvpQpfU2arOKffbTJTU/PcZetW6v2n6ol112WVO96GV20orBjEPl+ecqrN0IjB44in/8wg9x9fPmcPVbgB1HejEx22Yf+F8Sv/TMXvXY2CybHkuxcElBNWYVzntGCYsG6+wz/zSCbz5QU635GdYXVrFqfVmlLENYZpiaZ5qtrsp9MT70J3Msm0mxZmkHM2kNSwaKavddJbFz+xI5226rRx/Yi07favSMN1lrto5YVtSe3U0sP7cXvRPLcM8nduL5b6pj0VLgocc40qyKFasUZuoxZh+bYhopk50U1aVVqHKoFi+q4O6/v5PtvE4ibXLGKgxLL1+N6oRE73OYetZVAT76vx7Bivoc3vKbwJEDwNYvSDZWm0NroKpe+cJ5xM1vs9Hnpeq7Pasw8ngKuUXirEsH8OAOYGhRCUdvOY4Pb8vYudesVUONBkaPLbBStFiNjCQYrhbxprceYfF3E9zwo0Hc9fA04npFrRcpjjw0yhbOUdg49R+4/ht7VNIjcPDxNnt8ZA7nXxSpRx/nOPMc7eTZYQ/87QIqVaEGlwnc+5Ae1xKe8YwGxsqL8ZEvFLF51SzWbumFaqToX9OPX3t2BWeubmBgNYM4OI1rHwO+uf1RHLqLYXlPE3/91wu8vWOF2h4sUyNpB+XGApKt47j2jpHs9oerLEubCCKOUjEE+otoTrew79E29uyLVVwuojFaQzzHNJ8Nk9PAmPHyMCwVBMUQYV/BttcPgVJBYnKkDt5JcfTEvOponpJGPqWujGXdQBxy9BQFxmPNo2Jo1Rh6lrCfWRGgzRqECRNT3/zmE9iwoYNisWX8r07VcuXkz+aTE1pk0+v/HRUH/R067ufj9snJxqmO+2ed108lIzoz0s6rV145ZXw2YJINQ3wywXlw0KIieZjlVFbtT3YSJx8Mc62OydGVyij6xiCE4/9kI5v4fHL0dJIbMmjTBjTnntvGhz60Hx/96OmYmSmA88ZTO19pOZGaec+7xhrQjM1UBnjWplFcc9mIaRudSJeUBcCzrwQ2fquFf/tcFe2YoVgAjkxVMN+K0N/TQuvIPHoXV5CdsxTzexdsPVMwmFym3sHE9hNqYr6EdmkRwsk5VTs2g2avxNg40FtOETSH1fwCMLg0woF9DRw9mqnNm4HJKYZ6naPRYJiYUGh1gIVaG/zILJIIany9gvbKmVlIVCFQmJpmmJrqYHTfiKqs4ZjbP62Ge1PESRMzM0odPcoxdiJRSS3GWZvbKI8sqGiugCBehJnpBoJ+ibkj8+ro4Rhz84mBxycmGLLalAr7+zA+WYZqxXjzr9fQToDaFHDeyknccbiKzngNnYLC8IEZdXS4jrErMkzLNlQlxuRkHdNDGdJiHybiIjZtOq42DzSRjTRwtDqE6WMllBY6qthfQDJbxPBYE9UlVk1U2zWJL9wdS9YXYfGQxPRMS9VqApeewzF3ZEJtWQus29CLu7YKzDbnVJwBy4sctRM1jMd9GLy8jUovUNctu/u1YmJBHT/SxGBfAZhpol3sqPp8C7PriwhaKXBiSo2OZBgZY8jaddXfIxF1lkEmCgNDAjyaVnxWYeLxKdWeaGFp/2oM9WWIh2OgpwjZjjF9aAYjayXuf8A27dDmTEkYq/4VvdbkoZOgEzPThEtPEjXFDQlvcLnC3P45dXB/hs2rAG4WIswLRDSB20jWlUCzwTA331I9PQGCVozmcIxkjcTEVAt7ds2raKiKLA1x2poEy5YriH6moqFetGtzqhlMozBfgEo0X8jYYFk7aD0k0xJH982qsdNTTCcNTI50lOhtotRpqdmkgMd2ttQZG4BmS9+X0hyfTpTGxjI060BLCLTaAjOTEjy1AoaJiboql7iR3k8dnVZHH5/H6IjC5EQLenx5u6naC5PgqoJ4ZErNyDoGh0qo1VO021KradTxEwqxYkgXptX48Rbq0/p+KqO/xPDwnQ8amfPgQADda0SvyOeOzqmGDmC8ZNDl8QbDwkyAoXILI4cS9K0BLrxwHFIWcOSIwPBwS5tKGoGNRk4HGzH6h4pGZRJnsWoeb0ILXeSsRHBgFs2GwvAIUG9ypEVunncduIZHgbHRlpppzmFklcLa0xWKjTlV1fNoFmN+pImx4ykaMdCebqAgY5QHS+D1BVU/Oo5OrYVje+bVsn6BZLaFkT6GIw9Pq9HHGpg5dDrYzBSCUojmZBMnHp1VJwYSTDY1naODkdEA921dUKf/0j5sHJjB0c0CYVHiwQeh9j88g7QdYmZWzxEt1GrKHGurxdCjFhCPL1ilU6tlJK61BRg79JkmR381M9ohw6bP2jhxaErt2RmrqaNFsHY/IiFR6o2QlAqY6XDMzDdVuco0Cd3Pu5qnVypzVCoB5mCVjroLmFX05+LBqQK3Uk4ZyRGFAvV6jDi2AS8fT7SifWzM/IZ3vCPBfF3iO9eXMDsnnPLoyWOL9vw4fLiEt73tKH77t6dNnNHtSHSMzfdpO9V2cm8Y/f95vzAd+35RGyUeuuLws47xVDSMJ3sv7ecJyQgpYJ797Hm85CXz/qTzHQL1YFH2RpDNU9nC0Kgf1FNBTvQ+dWlGf1fe6fWpbFSzylvmPpWNPFFOHjy9L52gXXhhBx/5yGNmMiwZb33pJcD549Zbs2V/mZ4R6M0CNJpANcpQjDLzmalahBecP4Hff/EIRmaBkSmgEIG1WlCGwR0Bb31jG5Mzc9i6fZG5DuUoQ6BtQjQZL43BIm5KPoycsLUcMMmMLFUrMgZKKRDpCbRgiK90fDoo6f8PotQQ+MOQI4qYz8YpGTQZr+nrwxFqEgH1ANLXRquMM+WuU4BST9GsLgqVyOxL11UrVY5CMUG5L9Qnj0arjbq231cRhP5OTQDTNdiq1efrAEP3WrESQhYKiDOBP/jtWVxySYqpGUPLUL/9ggnIu3pxaKbfZOalami+PwybCMDN6kirF5pNjmdeuoDNpzWw5cw2+vuA5QNzuOqMOfzr3ZtwuNkLjqY5fy0yMQ6Hmi9QCVFRHcQ8RcdApAJZOUCSpkgUMLsAtFv6vLlGAtDWSqxSiGI1QrEToB1zNHUL7YKVZhaLelIMIQo6sRBICwHCgjAQr5aEoz9CocAQOAqB7gelz0Efk06OwkJovAoKlQLQAwQF+8gKYRvNhsUIUTn0na5Nt+pChFLZmq/rSTWk6+/uU1NWLdgZTys1ikUrX2dPsiKjVY++F8zvgd5n4L6TG3trUY6w0GCoN5hJqrmx1AMK5QAVzUfQHIlU/dR+9XkW9fFHHQRcIIwEZDFAloRmXHr7A0SFzJgw5l2X8wiq5nLoe0ol9MwKYyIVhjEK5UgrLRCGOtnliGeNchZRMUJYEij1F8A6kZUqC+u8b+8Je7/rYytXJSqlFO0ogoK+D5ykVkmE+nrq8dXHrK9nHZhaiHDxZf9Pe1fiG8d13n87M3twuTwlkRQviRSpi5QoS7SkSNZhyZJ8JJCvwk4a1fXVBoVdo3AMBAGCGq2Tv6BB6qaGDRsNkhpBHCSwowSNDcdK3TZFrNiJbMsSJVG89uBes7M7x+4U33vzuMPlcrkrSrbs+gNWIrkzb96867t/XxrfDJ3B6tYsmn20X4G779Zw4oSGZ58N4sc/bkZ9fZ7NUV72oK7Oy+aKZfb5vQgEA1R3jZn1aX59Zp6daTzzr7hmZYnPAe1RL1VtpTNb8SKXtzmkAu0tH218MFeyx+KrwBfwwhf0wWuYqAv5uXXAR1ldXEWV/PXw1yuQQqQ4cTd0wNmrrPKt7IMi5fC1R0xs3zqFuiBw/1fBhAo6tykWjsGoSDQf0pxrgQkK1P86BUbG4H0qeObFGAh3AO1jWp9SyAvZa0IiJuLOqCbrN81hiNKM9QXr9moRrXuyokAU8HT4xeQkxRJa+Na3LNx53EZOK2D9YBr/9FJxlrTPAAATOklEQVQLZsYprsCLUF6BIulzZRKo3zMzPkiSDw89dAlPPBHG5ctcEBGxFvShMAHis+X2oiiYJ8iNzEr8g8bf46kcs3klJMIklhJEaiUCW6OaeHPCiEhrbW4uCiWCOQmTkPidYNJFoGq1AgkJuW6I2qVICBJXYnJaysxVjkxz/h9tpzAQCWE/+1k7zpxpQFubAVnKIxpRoedoQ1GgZAAw+UFvWBIiMRndnQWs7pKwfVccQ9symI5I+LdTvchpPjQFDIYDvSqUg5oFUs7C0e3i+NDkxOPAxoEc/ue9hYi3lIYnBobcRtmchGzSh9XNEhTCX5KlWmJtr0uizd/cmMfwBgvTYTY/Ngl1TT6gpzmN9yOti3abhsvIedC/2cT6jSbTOhIprom3+oGWkIkPkhICi9wvGP1njdyB5p/TlRMxp0rni5qV0d+jYXOPgbQGqDo/Uy9cALq7yfVrgFLSP20Bi26yLA+a/Db232gilQXiaV7jjM5MWbm+MaWWS8TkIxEq51HAt59JY+eNNt79I2DowM4dBr7ZdBH//bYPwVYFv0/X44OZEHosHbblwdh4EHfdNYV77jmH/v4M47Ok7AqeJcIJiMfSmqGK8uW8CW5yx3S4M0SBpSvgV0vUvij3XyljRsgL9NzSoriLkYhx4fi4TtVeksboZreFQDzUbRqim+la+psQSKoRANwS3FIkNKAroSvZCO576LkUb9LRATz/fBd+9KM+1NVl8cEHDKsSb52yEQrm0BO0GOiO5SNm5weyEu67M4Xjey3Ut4BZMPJZAyOrAcMcx7+8vo49iAAcs4aMnD7/Hd3joxuAmpEWnUyxAGcm/di43cSxQ5P46XtrQJ1paTRZhg5p1sTU0ykfMroyBzBWC9H98YyPlQhwF1eqhlhAMUnwqszM7LVI6mJjkRCRF5uNrE462LvIS2DAkElWzQBGuri+CfdIs7nQuGwMGaGlWGDjYxtyzeOzJBGmh0Xj70fOkDloWo1EayBnykhmvXPmX8PkbSZVGYGC/YkJJzzgnDItZBimVCzTehXbZ+s34bT/Mb0nQdZkshJiWmGOSQiNl6xGqroQkvvTRmJ/Rme5JcXjMJRSpY54SSIpI5GQrhuMqeUQ7aFwWGJnyne+k8DwcB5n3neKPdF5HAb6uk2MPGxSfQeMjmn4zVgHTr3SislzQfzlwxfx5JNTbCwmJ4uWaDcJgYJ4rMg0qZbcaKtCKBFVf7nVxAuqtcPXJQcKpNgVVeWdKH2W4MMkiFB/lkrdFfeIWBI3vP1iNE8YoRsbG6sPQBXXtLbye8mcRI1VYpy1Smif1KKldyOfL5mNXn55JV59tQe9vRlIkjFn6OaZeDKUnAL9bB5WJ3BwaAo3rk1iXVeGTcDUFG+PJiSWAQ4NJSFL5/DCm2sQTfm5udu1cErft9L7E4PRdAVx1Yf+ARVfezCDgzcYaAjm8fxv+jGb8aMhaOLSuB91Rhbb1yXR3Zol7B4w0C8szdRoXrNZieXWb+lNYDrnQ85SEPCYc5UxF+2fxFPVojGJHb6dAzo6VjmxRnmnUlcN8+upME6LkSiQfq2gkImJUsEpMq8cWJPCR0kd4xMrkTVTIHDZKsOoFiU63FOqjIIhYWRNHKcvGRibDMBvKGioRtvw2FA1Gal4Peq9eQx3pZjWqhlAnWJiz2AE+kd5XDjvRUYrcGVimX2uhug5qbSHxSXReqB6HJsGdDTUW3hvyg8160GoZXk94YK6h7lJSfDaOKCjMWRh+mIAclar6M+/lvRpgeVeLs3F20W5ArJhvY7GBpPV7kpnFSYcS1dbcP8YSFhE6N2eeiqFkZE8s3ZxhO7i/FKGNX0oVb6jycQj+8axKRBHwfbj7rt5fAgp8cIdXo6EQEI8tjQVtloS8yCEh4YGGx0dGk6fDsLrLTgZrhLbg729uuNSm9+4ECyERaRawUik/QLls2BLibnm3NG3tUhgQosnIcadTVNKvEAP/1Qb6CqoNFDnWhO9E5nH6J2ee64Hr77ajfZ2nVU4FAG2mCuyxy0iqSk/htviePDmSeR1IJLkZdkkF/OkdqcTwMFNSaxs+BDffmUzEpq3poOJLU6n9kMq60MqDTx8TwxHdyRg2MDpc8DhoTjaGv6E776xEdG4F1/9syQObUuir28K4TCQs4raaKmEyxZugYKGuZ+XNszw1hzWb5rAhn4TM3EJFBSYTlKmlQy/LC04XMXP0zMKwxsYXJfHwX0WBvom2EGUyvCgyLjqxQo6kJqv7uQ6VWQR1/x8E1GmlqNZ0CZjm18CElkfVN2LxR09lZ5BLkyJBeKN7jRw4OYcdmyJYmyDBz//vYzWgMbH2VcUiKol6puZlxBOB5BMybj3eBaHDl/G6BYdl9ZI+NWpFox5mzET82EVWc2k/AIJwsPRxDEV9mHtVgs3DU9gd88MupqySGbB8GJCSgFfHr2A41uAF/89BK9SQDbH0K3nUIn9vpq6viTRvOumhHhSwuA6HX3r8ixgedtWEyPD08xUrYTCeGu8GWejrQjalmP9qm4MRVo/CTlUAbW5WUJPj4m/P6KiKWiyOJ+oNYmPPrCR0j7bboRPmmgeSBE5eMDE0SMWdu+KgALmCXi+I5SBIhcQUwOoh3l9v4iLiLGOj1Msks0sIiSIjI9Xvof2M+25SALYuUvFmrUqJi4vjcElyJ4rXLsQybwWEsJAKGTjxIn3sW9f/VzbdI51dFgYHc0x5YBcbYv1pVZPhe0gmwtvy1L8TsEVujXEffQQYuBCciol6gzlTBMzJ9dHtQxY5CuL4nrXmtyCyPe/34PXXutGZ6dGGX5Myyo/AKx8Bny+PHMfJJ04m1J3CJuMAnB5Fhhoz+Ef7j2NjOFlFpNKxIrKOVUWCXGZGOhshtWFxUP7zuK27QmEKWBM4+PF2u/I4m8PvYuM6cc9t2RYWa4PP+SChscCNg4aLMjQtjlTpUBPsdgbG2y0t1tsrsiF1N1tMSaeSgJNdawaLhobPPjiERV//JPEMFi48MKFgHBMQSLpwfCQjiO36jh2i86CYMldQpq+XAfcNKwinbuI1082IxwJwsxnl60lieGOZQLwSxkcGJxGb0uaWQGERkHCsKWwKjzYuSaK2XwDLo750V6l+4gFjVkcFO+22zK4444MhodMtr4jEaBztY0nescRSwBTs0BviF+bYe0v/X4sVsj0IOizcHTTOFp9WXT2cKzsaAwMFOyxB2K4GEniXH8Av/1VPc6+o8BuLvZfkblrz4r6MHprEo/+RRwrGm2kM/xQFO4qspAlVQKZAh5/VGXtaw5OAMXVZFQPMgmJ48NfBU2ehIq0Roi1NtZ0mth/g8HiKGiN0SFPggjtv1u3RnBjbxSvv9+JX/46iOmoj9UUqUarojXbQGCGjTb6+g0cP57B4cM5UNwsZaHoJnDv6BQi3FPKQL1mEgF48x4EPq8XctWI9hvFQTxyIo0NgxZ33zhK0GwG2N2fxN8dPYOX3uzFxHQALY0OWvV1/E4UA3PxooxAII9nnuGuGbKIoApLrcexqFAMIJ0VAn+jWhJK43L2obiXLCzkbhkdLTIeOhNE5mo1FoxaiQVZu6BAKrV/VcJbBNBYOWFEaFrUIeG7qoZERo2wplTjq7pSoj5S4C5Jhc8+24OTJ7sZCisVnVtKu+WaqIcz+woRxh7nn0gaaG/KsxLx6RxnIOWI/p7OSCyVL5mVMdwRx9eP/YEh/61qyKF/pY7xCOaeKz7U/qoGCxubLYxP8/4Q86HrYNGY2ix7gsb2yC1Z/PCHIaTTEjcFGjY62jkQD80XMVP6eNwWBq+NE/dlmGWGMkKyWRuJ8QBCKQVbN+Swd5eOkRGNHS7kPxWL0SMA7Pw2Ttw8hT0DUfzi3W68+JIPMzGvKMxZE4nr0wkFKVXBcG8Sa4Kz2LhaR1wDSwcWrjC2RgmcB8De/iiGeuI43V6P//hpPfNn93jyLJbEHfch2o/HFRi65NQtAoaGTHagJJJFYKGUCqSd+ScTLEXI7/1CGr99ox5jF4JYv0FGoETo8vASxnAAY5HOedDXqmK4Q2VrYzpa7D/FztCnwWfhwKiKTf0adr7jxb++0o6xqSArbJKmtPwOC489PoNDN2vs3kvhhYefOBQpdZuYNB1Gwrq5ImTjH5/W8MabVHlaWZ4i4JR6JqFCblTwjS+fw4HtOURTxdgCeiaNKTEssh6Ggja+sn8CN/YpOHtewWsnvYjHi2nxpXuKPpGkF5NhH750KzA4FENbm80UC552yYUeWv8zCa4QkZXu4J44Ci3jePF5CYmkD+2dHrT6Pg/uXQ7RPNK406e1xWJnBwVgCv7ALK4ZYE//LAZXJvDeeCNe/q9unJ1uYNba62nsGaaN6YGueRBLeBEM5vD003EMDRUwNlabQHG9kBDayeotiOaGDAmrVl27te+Oi6kkkFyzqr3lOlTrwSaCeMS9pXEngvELBNdiCmIxTaoaEnnZ3/teL06e7GIWES6IXP0JIgZBjEb8vNgzyOe4rt/CYw9MskqdISmPPetMdr1OZtDMXGXtufGReJFVZKhgZBpoq1voRhFMQMsAx47l0N8/zaxPtEBpoZai+83ru6PlxBMOA/PZ+OKX0vA2eXF4fwz7R3g6+EykfOYGE2ocjbi7y8TjfWPYvDLAAqle+N8Qq4ApSUtb5j1OZTEtJyEcldG3Xse2DSoGemaZFWAqycdBKnm27PweVXmq9bGdKfSs0FiVUSvHq7amNB86FRWaoWBqSmEVZke2abjrzhTTsmmsjOT8dgW5BVGyBg4MmHjy6wn8+i0FE3orErE6BNq5Jk7CWSztY8G9VASMsitIUCQ4A8NaaGETP5K1R52huKYCbr9dx8rVM3jznMysNrEkMNhvYcc2i2E2UBC0XILUKITMcloQsxiowJ7dFnbtsHB2wo80BbZdgZDI3FlhergXq7dY+MZfn8XekRQmwzyouaxLl9ZullvSVrdZ6OkiLACLpdLzas9cuxMWVlqLmiFhS28KXxhS4a+nNW8zlwxp56XpjTy1HdByQNtKA3917DI2NMt47U3g8kU/olGFVYyleLHPqfL80v7L6RJMo6ho0biRQkdn0WycX1s6/rTGppMEkVPAbTck0LMyg0uxevS2ZpHI1O7KvxZE/aQUfcKpIWvx5rUavvLnCQwOFnDpUhEHRBD9TutSnJ+lRGfulcR8fJbIHUOymECi1BpIuNjfK323HHJn8JQjWryzszJzFZC2T7U1fve7VoYXUG3GBEmGFy4EcOpUhyOIFOZZRAq8DHnZokhLpUu6g4IrBqW63o/aJNfL5vUmgnUmwlFm1GDWibl2UeRQwook4PaFJFpJerfyRYZJDIiEkcUsV+53FO9Abg/KZx9Yn8fu3RHQrckM17Q9FQJyxf/kzqDuHdqbY3VCrRwv/55M8poWyiJ9Z0woLzGzf8hv4dETWWzebDCGFZ7lY1LqJiudIxJKNBPIREgosnjlZgN4YN95PDfWhljYB8mfx5EjKtavt7BlS44BzxGDLzempe2LcSLNvG8A+JtNUXw0nsY7f2jBf053Ip7yI6tJ2NwRx+7HEgxNNF4BeXFB/x2h6PwlsODPTX1jiCQ9fH2YfO0AWBCoKUotEKZBJUGbvifIjKzNF26tW5jWezgiY98BA3v2G7h5r4q1XcDEDFhAtHsMF6wTJ3iXxoO+O3rIYmuNrD4U09LczK0eJFTUhYC1LRae2nSBWTsi8eI7i2eUe0fmy09za9ZNu/LYsyuKcMSDN95oxE9+UsewhD6Nmu/HRTSHWk5G9woLLRRgSXgmvqIgUooZUkpCYSKlrKvVxIbOBBIax/DxXTu4kKqJLKSkETx022XmVg822YyRnj9fXtigPUXnr0jHLSWRjVJuPKrlj5V47HJS9t1W9Su9v1oSBoXS9GNBylLWA/dAlrvWdsHAlztIReBNJRdGJap0Dx0YtAB+8IMuvP32KrS16QzZbmoqOA+gZinifrMC2tuzzjt5nP9tphmvWLHCk0qlqK47+33eACoy+9tiFQvF+BlGZRPVgolRuB8/o1U34SRIiDQweh7FvtDvbqjg0r6x1NlE0YS6GCMkTVSk7bn7wtwTSQILAxMGLOFSc82b6E+5BUjL6fIUv2bfvhwaQsCZMxJWNOcR1su/NMXeUDH1I4MXsa0/w7Rhcl/MJhwGVOYdRf/Ljb8A1aMDdmu3hvsPT+C7/9yDO26P4cEHVfY9CW2kaZc7iETtpHLt08+xWc5gO5t19B2ZxubpFE7+og11Sg737YizNmeEVaoMA6zYPhwG7OFxGSw9bglbp21XZtTu59IFtR5QLHtsFjhyNIU7j+fQthIYnwDOjy8egFdpfRJqsCC6pm8tdzPSe3JgMpsJwKoT81KOGbhhqkvbn5jm/WoI2bj//iSGhtJ44YV2pFUPVrTX9u7/H8hmOCoSbt1yGRt7VWYtNB2t3117zD3Wi80vLS0KJk45wnOQ4TrlGXhdIX8FnPEqESk7jQETa1qz8NXxmC3TWFy5o/emPUpnbjnUcGGxL017Xmp8iNznaDmi71kcmFOLptb9KoRH8amVauXvboFkXjE9AP8HSvI0mhIE6HEAAAAASUVORK5CYII="/>
</svg>
" + const imagebase64 = "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="547px" height="1410px" viewBox="0 0 547 1410" enable-background="new 0 0 547 1410" xml:space="preserve">  <image id="image0" width="547" height="1410" x="0" y="0"
    xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAiMAAAWCCAYAAADGzed0AAAAIGNIUk0AAHomAACAhAAA+gAAAIDo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=" />
</svg>
"; // 这里是最高值瓶子的图像 + + // 根据索引选择不同的图像 + const bottleImage = (i === 0) ? imagebase64_2 : imagebase64; + + group.append("image") + .attr("xlink:href", bottleImage) + .attr("width", bottleWidth) + .attr("height", bottleHeight) + .attr("preserveAspectRatio","xMidYMid meet"); + + // 添加瓶子蒙版（白色部分） + group.append("rect") + .attr("class", "bottle-mask") + .attr("width", bottleWidth) + .attr("height", bottleHeight * (1 - bottlePercentage)) + .attr("fill", "white") + .attr("opacity", 0.6); + + // 计算标签方块的大小和位置 + const squareSize = bottleWidth * 0.6; // 正方形边长为瓶子宽度的60% + const squareX = (bottleWidth - squareSize) / 2; // 水平居中 + const squareY = bottleHeight * (2/3) - (squareSize / 2); // 从底部往上1/3的位置 + + // 添加正方形背景 + group.append("rect") + .attr("class", "value-bg") + .attr("x", squareX) + .attr("y", squareY) + .attr("width", squareSize) + .attr("height", squareSize) + .attr("fill", "#f5f5f5") + .attr("rx", 5) + .attr("ry", 5); + + // 格式化值 + const formattedValue = `${formatValue(d[yField])}${valueUnit}`; + + // 我们将在下面计算实际字体大小，先使用基础大小创建文本元素 + const baseValueFontSize = 16; + + // 添加数值文本但先不设置字体大小 + const valueText = group.append("text") + .attr("class", "value-label") + .attr("x", bottleWidth / 2) + .attr("y", squareY + (squareSize * 0.6)) // 先设置一个位置，稍后会调整 + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold") + .style("fill", "#333") + .style("font-size", `${baseValueFontSize}px`) // 先设置基础字体大小 + .text(formattedValue); + + // 将值标签添加到数组中，以便后续统一调整 + valueLabels.push({ + element: valueText, + value: formattedValue, + squareSize: squareSize + }); + }); + + // ---------- 8. 添加国旗和国家名称 ---------- + const baseLabelFontSize = 14; // 基础字体大小 + const countryLabels = []; // 存储所有国家标签文本元素的引用 + + // 创建临时文本元素来测量文本宽度 + const tempText = svg.append("text") + .attr("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-size", `${baseLabelFontSize}px`); + + // 计算所有维度标签的最大宽度 + const dimensionWidths = sortedData.map(d => { + tempText.text(d[xField]); + return tempText.node().getComputedTextLength(); + }); + + // 最大可用宽度为bandWidth的90% + const maxAvailableWidth = xScale.bandwidth() * 1.2; + + // 计算需要的缩放比例 (如果有标签超出可用宽度) + const labelScaleFactor = Math.min(1, maxAvailableWidth / Math.max(...dimensionWidths)); + + // 确定最终的统一字体大小 + const finalLabelFontSize = baseLabelFontSize * labelScaleFactor; + + // 移除临时元素 + tempText.remove(); + + chart.selectAll(".flag-label-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "flag-label-group") + .attr("transform", d => `translate(${xScale(d[xField]) + xScale.bandwidth() / 2}, ${innerHeight + 10})`) + .each(function(d, i) { + const group = d3.select(this); + + // 添加国旗（如果有） + if (images.field && images.field[d[xField]]) { + group.append("image") + .attr("xlink:href", images.field[d[xField]]) + .attr("x", -12) + .attr("y", 0) + .attr("width", xScale.bandwidth()*0.3) + .attr("height", xScale.bandwidth()*0.25) + .attr("preserveAspectRatio","xMidYMid meet"); + + // 添加国家名称 - 使用统一的字体大小 + const label = group.append("text") + .attr("class", "country-label") + .attr("x", 0) + .attr("y", xScale.bandwidth()*0.45) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalLabelFontSize}px`) + .style("fill", colors.text_color) + .text(d[xField]); + + countryLabels.push(label); + } else { + // 如果没有国旗，添加没有国旗版本的标签 - 使用相同的字体大小 + const label = group.append("text") + .attr("class", "country-label") + .attr("x", 0) + .attr("y", 15) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalLabelFontSize}px`) + .style("fill", colors.text_color) + .text(d[xField]); + + countryLabels.push(label); + } + }); + + // ---------- 9. 统一调整所有值标签的字体大小 ---------- + // 创建临时文本元素来测量值标签文本宽度 + const tempValueText = svg.append("text") + .attr("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold") + .style("font-size", `${baseValueFontSize}px`); + + // 计算所有值标签在基础字体大小下的实际宽度 + const valueTextWidths = valueLabels.map(item => { + tempValueText.text(item.value); + return tempValueText.node().getComputedTextLength(); + }); + + // 计算每个标签所需的缩放比例（方形宽度 / 文本宽度） + const valueScaleFactors = valueLabels.map((item, i) => { + // 使用60%的方形宽度作为最大可用宽度 + const maxWidth = item.squareSize * 1; // 留一些边距 + return maxWidth / valueTextWidths[i]; + }); + + // 取最小的缩放比例，确保所有值标签使用相同的字体大小 + const minValueScaleFactor = Math.min(...valueScaleFactors, 1); // 不要放大，只缩小 + + // 计算最终的统一字体大小 + const finalValueFontSize = Math.min(baseValueFontSize * minValueScaleFactor, baseValueFontSize); + + // 移除临时元素 + tempValueText.remove(); + + // 应用统一的字体大小到所有值标签 + valueLabels.forEach(item => { + item.element + .style("font-size", `${finalValueFontSize}px`); + }); + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_range_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_range_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..3773b1e795daa8ff3caf26ac7a0e7ed9462a2225 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_range_chart_01.js @@ -0,0 +1,657 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Range Chart", + "chart_name": "vertical_range_chart_01", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 12], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "stroke"], + "min_height": 560, + "min_width": 560, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, dataJSON) { + const jsonData = dataJSON || {}; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const dataBlock = jsonData.data || {}; + const sourceRows = dataBlock.data || []; + const columns = dataBlock.columns || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const sourceColors = jsonData.colors || {}; + + d3.select(containerSelector).html(""); + + const roleColumn = (role, fallbackIndex) => Array.from(columns).find(c => c.role === role) || columns[fallbackIndex] || {}; + const xColumn = roleColumn("x", 0); + const yColumn = roleColumn("y", 1); + const groupColumn = roleColumn("group", 2); + const xField = xColumn.name; + const yField = yColumn.name; + const groupField = groupColumn.name; + const yUnit = yColumn.unit === "none" ? "" : (yColumn.unit || ""); + + const width = Math.max(560, Number(variables.width) || 720); + const height = Math.max(560, Number(variables.height) || 520); + const fontFamily = typography.label?.font_family || typography.title?.font_family || "Arial, sans-serif"; + const annotationFamily = typography.annotation?.font_family || fontFamily; + const textColor = sourceColors.text_color || "#101d3d"; + const mutedText = "#5f6e83"; + const canvasColor = "#f9fbff"; + const panelColor = "#ffffff"; + const cardStroke = "#e2e8f0"; + const gridColor = "#dfe6f2"; + const purple = "#6546c7"; + const rose = "#ff5267"; + const softPurple = "#f1edff"; + const softRose = "#fff0f2"; + const labelSize = Math.max(9, Math.min(12, parseFloat(typography.label?.font_size) || 11)); + const valueSize = Math.max(8, Math.min(11, parseFloat(typography.annotation?.font_size) || 10)); + const labelWeight = typography.label?.font_weight || "700"; + const valueWeight = typography.annotation?.font_weight || "650"; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("class", "vertical-range-chart"); + + function message(text) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", "16px") + .text(text); + return svg.node(); + } + + if (!xField || !yField || !groupField) { + return message("Missing range chart fields"); + } + + function readableLabel(value) { + return String(value ?? "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function parseTemporalRank(value) { + const text = String(value ?? "").trim(); + const lower = text.toLowerCase(); + const months = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, + sep: 9, sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + if (months[lower] != null) return months[lower]; + let match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^Q([1-4])\s+(-?\d{4})$/i) || text.match(/^(-?\d{4})\s+Q([1-4])$/i); + if (match && text.toUpperCase().startsWith("Q")) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + return NaN; + } + + function parseOrdinalRank(value) { + const text = String(value ?? "").trim().toLowerCase(); + const named = { + primary: 1, elementary: 1, secondary: 2, "high school": 2, college: 3, university: 3, + low: 1, lower: 1, medium: 2, moderate: 2, high: 3, higher: 3, + children: 1, adolescents: 2, teens: 2, adults: 3, seniors: 4 + }; + if (named[text] != null) return named[text]; + let match = text.match(/(?:less than|under)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) - 0.5; + match = text.match(/(?:more than|over)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) + 0.5; + match = text.match(/^[$]?\s*([\d,]+(?:\.\d+)?)\s*(?:-|to|–|—)/); + if (match) return Number(match[1].replace(/,/g, "")); + match = text.match(/^(-?\d+(?:\.\d+)?)/); + if (match) return Number(match[1]); + return NaN; + } + + function compactNumber(value) { + const numeric = Number(value); + const abs = Math.abs(numeric); + if (abs >= 1000000000) return `${d3.format(".3~g")(numeric / 1000000000)}B`; + if (abs >= 1000000) return `${d3.format(".3~g")(numeric / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".3~g")(numeric / 1000)}K`; + return d3.format(",.4~g")(numeric); + } + + function formatLocalValue(value, includeUnit = true) { + const formatted = compactNumber(value); + if (!includeUnit || !yUnit) return formatted; + if (yUnit === "%") return `${formatted}%`; + if (yUnit.length <= 3 && /^[^A-Za-z0-9]+$/.test(yUnit)) return `${yUnit}${formatted}`; + return `${formatted} ${yUnit}`; + } + + function wrapText(value, maxChars, maxLines = 2) { + const words = readableLabel(value).split(/\s+/).filter(Boolean); + if (!words.length) return [""]; + const lines = []; + let current = ""; + words.forEach(word => { + const next = current ? `${current} ${word}` : word; + if (next.length <= maxChars) { + current = next; + } else { + if (current) lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + if (lines.length <= maxLines) return lines; + const kept = lines.slice(0, maxLines - 1); + kept.push(lines.slice(maxLines - 1).join(" ")); + return kept; + } + + function addWrappedText(selection, lines, lineHeight) { + selection.selectAll("tspan") + .data(lines) + .enter() + .append("tspan") + .attr("x", 0) + .attr("dy", (d, index) => index === 0 ? 0 : lineHeight) + .text(d => d); + } + + const rows = sourceRows.map((row, index) => ({ + index, + category: readableLabel(row[xField]), + rawCategory: row[xField], + group: readableLabel(row[groupField]), + rawGroup: row[groupField], + value: Number(row[yField]) + })).filter(d => d.category && d.group && Number.isFinite(d.value)); + + if (!rows.length) return message("No valid range values"); + + const groupTotals = d3.rollup(rows, items => d3.mean(items, d => d.value), d => d.group); + const groups = Array.from(groupTotals.keys()).sort((a, b) => d3.descending(groupTotals.get(a), groupTotals.get(b)) || d3.ascending(a, b)); + const categories = Array.from(d3.group(rows, d => d.category), ([category, values]) => { + const valueByGroup = new Map(); + values.forEach(d => valueByGroup.set(d.group, d.value)); + const validValues = values.map(d => d.value); + return { + category, + rawCategory: values[0].rawCategory, + firstIndex: d3.min(values, d => d.index), + values, + valueByGroup, + min: d3.min(validValues), + max: d3.max(validValues), + spread: (d3.max(validValues) || 0) - (d3.min(validValues) || 0), + temporalRank: parseTemporalRank(values[0].rawCategory), + ordinalRank: parseOrdinalRank(values[0].rawCategory) + }; + }).filter(d => Number.isFinite(d.min) && Number.isFinite(d.max)); + + const allTemporal = xColumn.data_type === "temporal" || categories.every(d => Number.isFinite(d.temporalRank)); + const allOrdinal = !allTemporal && categories.every(d => Number.isFinite(d.ordinalRank)); + const sortMode = allTemporal ? "chronological" : (allOrdinal ? "ordered category" : "largest range"); + categories.sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + if (allOrdinal) return d3.ascending(a.ordinalRank, b.ordinalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.spread, b.spread) || d3.descending(a.max, b.max) || d3.ascending(a.category, b.category); + }); + categories.forEach((d, index) => d.rank = index + 1); + + const defs = svg.append("defs"); + const panelShadow = defs.append("filter") + .attr("id", "verticalRangePanelShadow") + .attr("x", "-8%") + .attr("y", "-12%") + .attr("width", "116%") + .attr("height", "128%"); + panelShadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 3) + .attr("stdDeviation", 5) + .attr("flood-color", "#334155") + .attr("flood-opacity", 0.12); + + const purpleGradient = defs.append("linearGradient") + .attr("id", "verticalRangePurpleGradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + purpleGradient.append("stop").attr("offset", "0%").attr("stop-color", chartUtils.color.variant(purple, { mode: "brighter", amount: 0.28 })); + purpleGradient.append("stop").attr("offset", "100%").attr("stop-color", chartUtils.color.variant(purple, { mode: "brighter", amount: 1.7 })); + + const roseGradient = defs.append("linearGradient") + .attr("id", "verticalRangeRoseGradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + roseGradient.append("stop").attr("offset", "0%").attr("stop-color", chartUtils.color.variant(rose, { mode: "brighter", amount: 0.12 })); + roseGradient.append("stop").attr("offset", "100%").attr("stop-color", chartUtils.color.variant(rose, { mode: "brighter", amount: 1.75 })); + + const measure = svg.append("g").attr("visibility", "hidden"); + function measureLabelText(text, fontSize, weight = "600") { + const node = measure.append("text") + .style("font-family", fontFamily) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight) + .text(String(text ?? "")) + .node(); + const estimate = node ? node.textContent.length * 7 : 0; + measure.selectAll("text").remove(); + return Math.max(estimate || 0, String(text ?? "").length * fontSize * 0.52); + } + function appendFittedText(parent, text, options) { + const { + x, y, maxWidth, fontSize, minFontSize = 6.5, + fill = textColor, anchor = "start", weight = "650", + className = "text", baseline = "middle" + } = options; + let size = fontSize; + while (size > minFontSize && measureLabelText(text, size, weight) > maxWidth) { + size -= 0.5; + } + const node = parent.append("text") + .attr("class", className) + .attr("x", x) + .attr("y", y) + .attr("text-anchor", anchor) + .attr("dominant-baseline", baseline) + .attr("fill", fill) + .style("font-family", fontFamily) + .style("font-size", `${size}px`) + .style("font-weight", weight) + .text(String(text ?? "")); + if (measureLabelText(text, size, weight) > maxWidth) { + node.attr("textLength", maxWidth).attr("lengthAdjust", "spacingAndGlyphs"); + } + return node; + } + function compactCategory(value) { + const text = readableLabel(value); + if (text.length <= 18) return text; + const parenthetical = text.match(/\(([^()]{2,})\)\s*$/); + if (parenthetical) return parenthetical[1].trim(); + const words = text.split(/\s+/).filter(Boolean); + if (words.length <= 2) return text; + return words.slice(0, 2).join(" "); + } + + svg.append("rect") + .attr("class", "chart-canvas") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", canvasColor); + + const outerPad = Math.max(14, Math.min(26, width * 0.035)); + const legendH = Math.max(54, Math.min(72, height * 0.12)); + const noteH = Math.max(58, Math.min(76, height * 0.13)); + const gap = Math.max(12, Math.min(18, height * 0.026)); + const plotCardX = outerPad; + const plotCardY = outerPad + legendH + gap; + const plotCardW = width - outerPad * 2; + const plotCardH = height - plotCardY - noteH - gap - outerPad; + const margin = { + top: 48, + right: 32, + bottom: categories.length > 8 ? 68 : 54, + left: 50 + }; + const plotW = plotCardW - margin.left - margin.right; + const plotH = plotCardH - margin.top - margin.bottom; + + const minValue = d3.min(rows, d => d.value); + const maxValue = d3.max(rows, d => d.value); + const span = Math.max(1, maxValue - minValue); + const yDomainMin = Math.max(0, minValue - span * 0.12); + const yDomainMax = maxValue + span * 0.14; + const yScale = d3.scaleLinear() + .domain([yDomainMin, yDomainMax]) + .nice(5) + .range([plotH, 0]); + const xScale = d3.scalePoint() + .domain(categories.map(d => d.category)) + .range([0, plotW]) + .padding(categories.length <= 2 ? 0.34 : 0.5); + + const palette = [purple, rose].concat(sourceColors.available_colors || d3.schemeTableau10 || d3.schemeCategory10); + const colorForGroup = (group, index) => palette[index % palette.length] || "#2563eb"; + const colorScale = d3.scaleOrdinal() + .domain(groups) + .range(groups.map(colorForGroup)); + + const legendCard = svg.append("g") + .attr("class", "group-legend-card") + .attr("transform", `translate(${outerPad + 4}, ${outerPad})`); + legendCard.append("rect") + .attr("class", "group-legend-bg") + .attr("x", 0) + .attr("y", 0) + .attr("width", Math.min(plotCardW - 8, Math.max(260, width * 0.68))) + .attr("height", legendH) + .attr("rx", 10) + .attr("fill", panelColor) + .attr("stroke", cardStroke) + .attr("filter", "url(#verticalRangePanelShadow)"); + const legend = legendCard.append("g") + .attr("class", "group-legend") + .attr("transform", `translate(${Math.max(18, legendH * 0.32)}, ${legendH / 2})`); + let legendX = 0; + groups.forEach((group, index) => { + const itemWidth = Math.min(210, Math.max(112, group.length * 7.2 + 52)); + const item = legend.append("g") + .attr("class", "group-legend-row") + .attr("data-group", group) + .attr("transform", `translate(${legendX}, 0)`); + item.append("circle") + .attr("class", "legend-swatch") + .attr("cx", 0) + .attr("cy", 0) + .attr("r", 7) + .attr("fill", colorScale(group)); + appendFittedText(item, wrapText(group, 24, 1)[0], { + x: 18, + y: -2, + maxWidth: itemWidth - 30, + fontSize: Math.max(10, labelSize * 0.96), + minFontSize: 7, + fill: textColor, + weight: "800", + className: "legend-label" + }); + const mean = groupTotals.get(group); + appendFittedText(item, `avg ${formatLocalValue(mean, false)}`, { + x: 18, + y: 14, + maxWidth: itemWidth - 30, + fontSize: Math.max(7.2, valueSize * 0.78), + minFontSize: 6, + fill: mutedText, + weight: "500", + className: "legend-mean" + }); + legendX += itemWidth; + }); + + svg.append("rect") + .attr("class", "plot-card") + .attr("x", plotCardX) + .attr("y", plotCardY) + .attr("width", plotCardW) + .attr("height", plotCardH) + .attr("rx", 12) + .attr("fill", panelColor) + .attr("stroke", cardStroke) + .attr("filter", "url(#verticalRangePanelShadow)"); + + svg.append("text") + .attr("class", "axis-title y-axis-title") + .attr("x", plotCardX + 24) + .attr("y", plotCardY + 31) + .attr("fill", textColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(10, valueSize * 1.02)}px`) + .style("font-weight", "800") + .text(yUnit ? `${readableLabel(yColumn.label || yField)} (${yUnit})` : readableLabel(yColumn.label || yField)); + + const plot = svg.append("g") + .attr("class", "range-plot") + .attr("data-sort-mode", sortMode) + .attr("data-count", categories.length) + .attr("transform", `translate(${plotCardX + margin.left}, ${plotCardY + margin.top})`); + + const ticks = yScale.ticks(5); + ticks.forEach(tick => { + plot.append("line") + .attr("class", "gridline axis-tick") + .attr("x1", 0) + .attr("x2", plotW) + .attr("y1", yScale(tick)) + .attr("y2", yScale(tick)) + .attr("stroke", gridColor) + .attr("stroke-width", tick === 0 ? 1.2 : 1); + plot.append("text") + .attr("class", "axis-tick-label axis-tick") + .attr("x", -10) + .attr("y", yScale(tick)) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${valueSize}px`) + .style("font-weight", valueWeight) + .text(formatLocalValue(tick, false)); + }); + + plot.append("line") + .attr("class", "x-axis-line") + .attr("x1", 0) + .attr("x2", plotW) + .attr("y1", plotH) + .attr("y2", plotH) + .attr("stroke", gridColor) + .attr("stroke-width", 1.1); + + const labelLane = (group, index) => index % 2 === 0 ? -1 : 1; + categories.forEach(category => { + const x = xScale(category.category); + const categoryGroup = plot.append("g") + .attr("class", "range-category") + .attr("data-category", category.category) + .attr("transform", `translate(${x}, 0)`); + const yMin = yScale(category.min); + const yMax = yScale(category.max); + + categoryGroup.append("line") + .attr("class", "range-line") + .attr("data-category", category.category) + .attr("data-rank", category.rank) + .attr("data-sort-mode", sortMode) + .attr("data-min", category.min) + .attr("data-max", category.max) + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", yMax) + .attr("y2", yMin) + .attr("stroke", "#c9d4e6") + .attr("stroke-width", 4.4) + .attr("stroke-linecap", "round"); + + const sortedValues = category.values.slice().sort((a, b) => d3.ascending(a.value, b.value)); + sortedValues.forEach((point, sortedIndex) => { + const groupIndex = groups.indexOf(point.group); + const lane = labelLane(point.group, groupIndex); + let y = yScale(point.value); + if (sortedValues.length === 2 && Math.abs(yScale(sortedValues[0].value) - yScale(sortedValues[1].value)) < 18) { + y += sortedIndex === 0 ? 7 : -7; + } + const formatted = formatLocalValue(point.value, false); + const badgeWidth = Math.min(54, Math.max(30, measureLabelText(formatted, valueSize, "800") + 12)); + const badgeX = lane < 0 ? -badgeWidth - 10 : 10; + const badgeY = y - 10; + categoryGroup.append("line") + .attr("class", "range-stem") + .attr("data-category", category.category) + .attr("data-group", point.group) + .attr("data-value", point.value) + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", yScale(point.value)) + .attr("y2", plotH) + .attr("stroke", colorScale(point.group)) + .attr("stroke-width", 3) + .attr("stroke-linecap", "round") + .attr("opacity", 0.28); + categoryGroup.append("circle") + .attr("class", "range-point data-point mark") + .attr("data-tag", "mark") + .attr("data-category", category.category) + .attr("data-group", point.group) + .attr("data-value", point.value) + .attr("data-index", point.index) + .attr("data-rank", category.rank) + .attr("data-sort-mode", sortMode) + .attr("cx", 0) + .attr("cy", yScale(point.value)) + .attr("r", 6.7) + .attr("fill", colorScale(point.group)) + .attr("stroke", "#ffffff") + .attr("stroke-width", 1.6); + categoryGroup.append("rect") + .attr("class", "value-label-bg") + .attr("data-category", category.category) + .attr("data-group", point.group) + .attr("data-value", point.value) + .attr("x", badgeX) + .attr("y", badgeY) + .attr("width", badgeWidth) + .attr("height", 20) + .attr("rx", 4) + .attr("fill", colorScale(point.group)); + categoryGroup.append("text") + .attr("class", "value-label") + .attr("data-category", category.category) + .attr("data-group", point.group) + .attr("data-value", point.value) + .attr("data-index", point.index) + .attr("data-rank", category.rank) + .attr("x", badgeX + badgeWidth / 2) + .attr("y", y) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .attr("fill", "#ffffff") + .style("font-family", annotationFamily) + .style("font-size", `${valueSize}px`) + .style("font-weight", "800") + .text(formatted); + }); + + const tick = categoryGroup.append("text") + .attr("class", "category-label") + .attr("data-category", category.category) + .attr("x", 0) + .attr("y", plotH + 20) + .attr("text-anchor", categories.length > 8 ? "end" : "middle") + .attr("transform", categories.length > 8 ? `rotate(-34, 0, ${plotH + 20})` : null) + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", `${categories.length > 8 ? Math.max(7, labelSize - 2) : labelSize}px`) + .style("font-weight", labelWeight); + addWrappedText(tick, wrapText(compactCategory(category.category), Math.max(7, Math.floor(plotW / Math.max(1, categories.length) / 6)), categories.length > 8 ? 1 : 2), labelSize + 1); + }); + + plot.append("text") + .attr("class", "axis-title") + .attr("x", plotW / 2) + .attr("y", plotH + margin.bottom - 12) + .attr("text-anchor", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${valueSize}px`) + .style("font-weight", valueWeight) + .text(readableLabel(xColumn.label || xField)); + + const largestRange = categories[0]; + const note = svg.append("g") + .attr("class", "insight-band") + .attr("transform", `translate(${outerPad + 4}, ${height - outerPad - noteH})`); + note.append("rect") + .attr("class", "insight-band-bg") + .attr("x", 0) + .attr("y", 0) + .attr("width", width - outerPad * 2 - 8) + .attr("height", noteH) + .attr("rx", 12) + .attr("fill", softPurple) + .attr("stroke", "#e7ddff"); + note.append("circle") + .attr("class", "insight-icon") + .attr("cx", 30) + .attr("cy", noteH / 2) + .attr("r", Math.min(24, noteH * 0.33)) + .attr("fill", purple); + note.append("path") + .attr("class", "insight-icon-mark") + .attr("d", `M20,${noteH / 2 + 10} L20,${noteH / 2 - 7} M30,${noteH / 2 + 10} L30,${noteH / 2 - 14} M40,${noteH / 2 + 10} L40,${noteH / 2 - 2} M17,${noteH / 2 - 11} L30,${noteH / 2 - 23} L43,${noteH / 2 - 11}`) + .attr("fill", "none") + .attr("stroke", "#ffffff") + .attr("stroke-width", 2.2) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + appendFittedText(note, `Largest range: ${largestRange ? compactCategory(largestRange.category) : ""}`, { + x: 66, + y: noteH / 2 - 9, + maxWidth: Math.max(180, width * 0.48), + fontSize: Math.max(11, labelSize * 1.04), + minFontSize: 7, + fill: textColor, + weight: "800", + className: "scale-note" + }); + appendFittedText(note, `${largestRange ? formatLocalValue(largestRange.spread, false) : ""} spread; endpoints compare ${groups.join(" vs ")}`, { + x: 66, + y: noteH / 2 + 12, + maxWidth: Math.max(220, width - 140), + fontSize: Math.max(8, valueSize * 0.86), + minFontSize: 6.5, + fill: mutedText, + weight: "550", + className: "category-note" + }); + + measure.remove(); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..00ef04cdc46add772e364eb4b9a0a332ab4f6a11 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_0.js @@ -0,0 +1,259 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Bar Chart", + "chart_name": "vertical_stacked_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 12], [0, 100], [3, 20]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("x", d => xScale(d.data.period)) + .attr("y", d => yScale(d[1])) + .attr("height", d => yScale(d[0]) - yScale(d[1])) + .attr("width", xScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("x", d => xScale(d.data.period) + xScale.bandwidth() / 2) + .attr("y", d => { + const height = yScale(d[0]) - yScale(d[1]); + return yScale(d[1]) + height / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + // 只在高度大于16且值大于0时显示文本 + return (height > 16 && value > 0) ? chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_1.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_1.js new file mode 100644 index 0000000000000000000000000000000000000000..1fa674d58978f6035ec6f953d34e330db656e082 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_1.js @@ -0,0 +1,273 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Bar Chart", + "chart_name": "vertical_stacked_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 12], [0, 100], [3, 20]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("x", d => xScale(d.data.period)) + .attr("y", d => yScale(d[1])) + .attr("height", d => yScale(d[0]) - yScale(d[1])) + .attr("width", xScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加总和数值标注 + chartGroup.selectAll(".total-label") + .data(processedData) + .enter() + .append("text") + .attr("class", "total-label") + .attr("x", d => xScale(d.period) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.total) - 5) // 在柱子顶端上方5个像素 + .attr("text-anchor", "middle") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => chartUtils.format.autoText(d.total) + (yUnit ? ` ${yUnit}` : '')); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("x", d => xScale(d.data.period) + xScale.bandwidth() / 2) + .attr("y", d => { + const height = yScale(d[0]) - yScale(d[1]); + return yScale(d[1]) + height / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + // 只在高度大于16且值大于0时显示文本 + return (height > 16 && value > 0) ? chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_2.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_2.js new file mode 100644 index 0000000000000000000000000000000000000000..9c37bb723b4dff2538b61706b82681bb2ed61a94 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_2.js @@ -0,0 +1,313 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Bar Chart", + "chart_name": "vertical_stacked_bar_chart_2", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 12], [0, 100], [3, 20]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +// vertical stacked bar chart plain chart#2 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加圆角矩形路径生成函数 + function roundedRect(x, y, width, height, radius) { + // 只对顶部添加圆角 + const topRadius = radius; + const bottomRadius = 0; + + // 如果高度小于半径，绘制圆弧 + if (height < radius) { + // 计算圆弧的角度 + const centerY = y + radius; + const angle = Math.acos((radius - height) / radius); + const startX = x + radius - radius * Math.sin(angle); + const endX = x + width - radius + radius * Math.sin(angle); + + return `M${x},${y + height} + L${startX},${y + height} + A${radius},${radius} 0 0,1 ${endX},${y + height} + L${x + width},${y + height} + Z`; + } else { + // 标准的圆角矩形（半圆顶部） + return `M${x},${y + height} + L${x},${y + topRadius} + Q${x},${y} ${x + topRadius},${y} + L${x + width - topRadius},${y} + Q${x + width},${y} ${x + width},${y + topRadius} + L${x + width},${y + height} + Z`; + } + } + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + // 计算圆角半径（条形宽度的50%，形成半圆顶部） + const cornerRadius = xScale.bandwidth() * 0.5; + + layers.selectAll("path") + .data(d => d) + .enter().append("path") + .attr("d", (d, i, nodes) => { + const x = xScale(d.data.period); + const y = yScale(d[1]); + const width = xScale.bandwidth(); + const height = yScale(d[0]) - yScale(d[1]); + + // 检查是否是最顶部的条形（在该x位置的最后一个非零高度的条形） + const layerIndex = d3.select(nodes[i].parentNode).datum().key; + const isTopLayer = layerIndex === groups[groups.length - 1] || + (height > 0 && !stackedData.slice(stackedData.findIndex(layer => layer.key === layerIndex) + 1) + .some(nextLayer => { + const nextData = nextLayer.find(item => item.data.period === d.data.period); + return nextData && (nextData[1] - nextData[0]) > 0; + })); + + // 如果是顶层且有一定高度，则添加圆角或圆弧顶部 + if (isTopLayer && height > 0) { + return roundedRect(x, y, width, height, cornerRadius); + } else { + // 普通矩形 + return `M${x},${y} L${x + width},${y} L${x + width},${y + height} L${x},${y + height} Z`; + } + }) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("x", d => xScale(d.data.period) + xScale.bandwidth() / 2) + .attr("y", d => { + const height = yScale(d[0]) - yScale(d[1]); + return yScale(d[1]) + height / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + // 只在高度大于16且值大于0时显示文本 + return (height > 16 && value > 0) ? chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_3.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_3.js new file mode 100644 index 0000000000000000000000000000000000000000..5d03a30ecdacc0286a0d71e4bb9312e3b7917d5e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_bar_chart_3.js @@ -0,0 +1,323 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Bar Chart", + "chart_name": "vertical_stacked_bar_chart_3", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 12], [0, 100], [3, 20]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// vertical stacked bar chart 3d +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距（为3D效果留出空间） + const margin = { + top: 60, // 增加顶部空间用于3D顶面 + right: 50, // 增加右侧空间用于3D侧面 + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, xLabelText).width + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 定义3D透视偏移量 + const dx = 10; // 横向透视偏移 + const dy = 6; // 纵向透视偏移 + + // 绘制堆叠的条形 - 3D效果 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer"); + + // 为每个堆叠段绘制3D效果 + layers.each(function(layerData, layerIndex) { + const layer = d3.select(this); + const baseColor = colorScale(layerData.key); + + // 计算颜色变化 + const frontColor = baseColor; + const topColor = chartUtils.color.variant(baseColor, { mode: "brighter", amount: 0.8 }); + const sideColor = chartUtils.color.variant(baseColor, { mode: "darker", amount: 0.6 }); + + layerData.forEach((d, i) => { + const bw = xScale.bandwidth(); + const x0 = xScale(d.data.period); + const y0 = yScale(d[0]); // 底部位置 + const y1 = yScale(d[1]); // 顶部位置 + const height = y0 - y1; + + // 跳过高度为0的段 + if (height <= 0) return; + + // ===== 正面 rect ===== + layer.append("rect") + .attr("x", x0) + .attr("y", y1) + .attr("width", bw) + .attr("height", height) + .attr("fill", frontColor) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // ===== 侧面 polygon（右侧面）===== + layer.append("polygon") + .attr("points", [ + [x0 + bw, y1], // 右上 + [x0 + bw + dx, y1 - dy], // 右上+偏移 + [x0 + bw + dx, y0 - dy], // 右下+偏移 + [x0 + bw, y0] // 右下 + ].join(" ")) + .attr("fill", sideColor) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 0.5 : 0); + + // ===== 顶面 polygon（只有最顶层才有顶面）===== + // 检查是否是最顶层（在该x位置的最后一个非零高度的层） + const isTopLayer = layerIndex === stackedData.length - 1 || + !stackedData.slice(layerIndex + 1).some(nextLayer => { + const nextData = nextLayer.find(item => item.data.period === d.data.period); + return nextData && (nextData[1] - nextData[0]) > 0; + }); + + if (isTopLayer) { + layer.append("polygon") + .attr("points", [ + [x0, y1], // 左上 + [x0 + bw, y1], // 右上 + [x0 + bw + dx, y1 - dy], // 右上+偏移 + [x0 + dx, y1 - dy] // 左上+偏移 + ].join(" ")) + .attr("fill", topColor) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 0.5 : 0); + } + }); + }); + + // 添加数值标注 - 调整位置以适应3D效果 + layers.each(function(layerData) { + const layer = d3.select(this); + + layerData.forEach(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + const x0 = xScale(d.data.period); + const y1 = yScale(d[1]); + const bw = xScale.bandwidth(); + + // 只在高度大于16且值大于0时显示文本 + if (height > 16 && value > 0) { + layer.append("text") + .attr("x", x0 + bw/2 + dx/3) // 稍微向右偏移以适应3D效果 + .attr("y", y1 + height/2 - dy/3) // 稍微向上偏移 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : '')); + } + }); + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_0.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_0.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..cd6bed3ff26fddbb28a1490385d6f46d66538319 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_0.js.bug @@ -0,0 +1,286 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Pictorial Bar Chart", + "chart_name": "vertical_stacked_pictorial_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 100], [3, 20]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + obj.icon = jsonData.images.field[key]; + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + // 根据colors.field的值，获取对应的color + let group_colors = [] + for (let i = 0; i < groups.length; i++) { + group_colors.push(colors.field[groups[i]]) + } + // 颜色比例尺 + const colorScale = d3.scaleOrdinal() + .domain(groups) + .range(group_colors) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = getTextWidth(xLabelText) + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("image") + .attr("x", d => xScale(d.data.period)) + .attr("y", d => yScale(d[1])) + .attr("height", d => yScale(d[0]) - yScale(d[1])) + .attr("width", xScale.bandwidth()) + .attr("xlink:href", d => { + let gap = d[1]-d[0] + // 从d.data中找到gap对应的key + for (let key in d.data) { + if (Math.abs(d.data[key] - gap) < 0.0001) { + return jsonData.images.field[key] + } + } + }) + .attr("preserveAspectRatio", "none"); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("x", d => xScale(d.data.period) + xScale.bandwidth() / 2) + .attr("y", d => { + const height = yScale(d[0]) - yScale(d[1]); + return yScale(d[1]) + height / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + // 只在高度大于16且值大于0时显示文本 + return (height > 16 && value > 0) ? formatValue(value) + (yUnit ? ` ${yUnit}` : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_1.js.bug b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_1.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..b09e944da21b32fc9687b22ee969403e3c128148 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_stacked_pictorial_bar_chart_1.js.bug @@ -0,0 +1,278 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Stacked Pictorial Bar Chart", + "chart_name": "vertical_stacked_pictorial_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 100], [3, 20]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + obj.icon = jsonData.images.field[key]; + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用时间段作为分类 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([0, chartWidth]) + .padding(0.3); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([chartHeight, 0]) + .nice(); + + // 根据colors.field的值，获取对应的color + let group_colors = [] + for (let i = 0; i < groups.length; i++) { + group_colors.push(colors.field[groups[i]]) + } + // 颜色比例尺 + const colorScale = d3.scaleOrdinal() + .domain(groups) + .range(group_colors) + + // 确定标签的最大长度： + + let minXLabelRatio = 1.0 + const maxXLabelWidth = xScale.bandwidth() * 1.03 + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]) + let currentWidth = getTextWidth(xLabelText) + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth) + } + }) + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("image") + .attr("x", d => xScale(d.data.period)) + .attr("y", d => yScale(d[1])) + .attr("height", d => yScale(d[0]) - yScale(d[1])) + .attr("width", xScale.bandwidth()) + .attr("xlink:href", d => d.icon) + .attr("preserveAspectRatio", "none"); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("x", d => xScale(d.data.period) + xScale.bandwidth() / 2) + .attr("y", d => { + const height = yScale(d[0]) - yScale(d[1]); + return yScale(d[1]) + height / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const height = yScale(d[0]) - yScale(d[1]); + // 只在高度大于20且值大于0时显示文本 + return (height > 16 && value > 0) ? formatValue(value) + (yUnit ? ` ${yUnit}` : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) // 移除刻度线 + .tickPadding(10)) // 增加文字和轴的间距 + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") // 根据minXLabelRatio调整文字旋转 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..1a4630ad15a5a316bee5a0690ceac71a301cfdaf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_01.js @@ -0,0 +1,291 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Waffle Chart", + "chart_name": "vertical_waffle_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 单位方块图实现 - 使用小方块表示数据值 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const fontSize = chartUtils.text.fontSize; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + + // 添加数值格式化函数 + + // 提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit || ""; + + // ---------- 2. 配置图表参数 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + // 初始设置图表边距，后续会在绘制方块图后调整 + const margin = { + top: 100, // 临时值，后续会根据图例高度调整 + right: 30, + bottom: 40, + left: 30 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 计算单位方块数和大小 ---------- + // 计算数据总和 + const totalValue = chartData.reduce((sum, d) => sum + (+d[yField] || 0), 0); + + // 确定单位方块的总数（目标是500-1000个） + let totalSquares = totalValue; + let valuePerSquare = 1; + + // 调整每个方块代表的值，确保方块总数在500-1000之间 + if (totalValue > 1000) { + // 如果总数太大，增加每个方块的值 + valuePerSquare = Math.ceil(totalValue / 800); // 目标800个方块 + totalSquares = Math.ceil(totalValue / valuePerSquare); + } else if (totalValue < 300) { + // 如果总数太小，减少每个方块的值（允许代表小于1的数值） + valuePerSquare = totalValue / 300; // 目标300个方块 + totalSquares = 300; // 固定方块数量 + } + + // 根据画布比例确定最适合的行列数，使方块更好地填充空间 + // 计算画布的宽高比 + const canvasRatio = innerWidth / innerHeight; + + // 计算最接近画布比例的行列组合 + // 这里采用开平方，然后根据画布比例调整的方式 + const sqrtSquares = Math.sqrt(totalSquares); + let numCols = Math.round(sqrtSquares * Math.sqrt(canvasRatio)); + let numRows = Math.round(sqrtSquares / Math.sqrt(canvasRatio)); + + // 确保行列乘积不少于总方块数 + while (numRows * numCols < totalSquares) { + if (numRows / numCols < canvasRatio) { + numRows++; + } else { + numCols++; + } + } + + // 确保至少有一行一列 + numRows = Math.max(1, numRows); + numCols = Math.max(1, numCols); + + // 计算方块大小，确保完全填充可用空间 + // 首先计算可用于每个方块的空间 + const maxSquareWidth = innerWidth / numCols; + const maxSquareHeight = innerHeight / numRows; + + // 使用较小的尺寸确保方块是正方形 + const maxSquareSize = Math.min(maxSquareWidth, maxSquareHeight); + + // 为了留出一些间距，使方块略小于可用空间 + const squareSize = maxSquareSize * 0.85; // 稍微减小方块以增加间距 + const squareSpacing = maxSquareSize * 0.15; // 增加间距使布局更美观 + + // 重新计算基于优化后的方块大小实际使用的空间 + const actualChartWidth = numCols * maxSquareSize; + const actualChartHeight = numRows * maxSquareSize; + + // 计算方块图的偏移量以居中显示 + const offsetX = (innerWidth - actualChartWidth) / 2; + const offsetY = (innerHeight - actualChartHeight) / 2; + + // ---------- 4. 创建SVG容器 ---------- + // 清除容器 + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 5. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 1); + + filter.append("feOffset") + .attr("dx", 1) + .attr("dy", 1) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 6. 创建图表区域 ---------- + // 创建一个容器，后续再添加实际内容 + const containerGroup = svg.append("g"); + + // ---------- 7. 计算各类别的数据 ---------- + // 计算每个类别所需的方块数和起始位置 + const categorySquares = []; + let squareCount = 0; + + // 用于颜色分配 + const categoryColors = {}; + + // 如果没有为每个类别指定颜色，使用默认颜色方案 + const defaultColors = colorResolver.availablePalette(6, { + fallbackColors: ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#ff8ab7", "#97bbf5"], + }); + + chartData.forEach((d, i) => { + const category = d[xField]; + const value = +d[yField]; + const numSquares = Math.round(value / valuePerSquare); + + // 确保每个类别有颜色 + categoryColors[category] = colorResolver.field(category, i, { colors: defaultColors }).value; + + categorySquares.push({ + category: category, + value: value, + squares: numSquares, + startSquare: squareCount, + color: categoryColors[category] + }); + + squareCount += numSquares; + }); + const availableLegendWidth = innerWidth; + const legendSquareSize = 14; + const legendRowHeight = Math.max(36, fontSize(typography.label.font_size) * 2.4); + const legendSpacing = 12; + + const legendItemsForDraw = chartData.map((d, i) => ({ + label: d[xField], + valueLabel: `${chartUtils.format.autoText(+d[yField])} ${yUnit}`, + color: categoryColors[d[xField]], + raw: d, + })); + const legendDrawResult = chartUtils.legend.categoryValueRows(svg, legendItemsForDraw, { + maxWidth: availableLegendWidth, + markerSize: legendSquareSize, + rowHeight: legendRowHeight, + itemGap: legendSpacing, + fontSize: fontSize(typography.label.font_size), + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + valueFontWeight: "bold", + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? Math.max(1, legendSquareSize * 0.15) : 0, + }); + const actualLegendHeight = legendDrawResult.height; + // 根据实际图例高度，调整图表布局 + // 图例在上方，方块图在下方，两者之间留出10px的间距 + const legendVerticalSpace = 10; // 图例和方块图之间的间距 + + // 计算方块图的顶部位置，考虑图例高度和间距 + const chartTopPosition = actualLegendHeight + legendVerticalSpace; + + // 计算方块图需要的总高度 + const chartTotalHeight = actualChartHeight + 2 * offsetY; + + // 使方块图居中显示（垂直方向） + const verticalCenterOffset = (height - chartTopPosition - chartTotalHeight) / 2; + const finalChartTopPosition = chartTopPosition + Math.max(0, verticalCenterOffset); + + // 移动图例到适当位置 + legendDrawResult.group.attr("transform", `translate(${margin.left}, 20)`); + + // ---------- 9. 绘制所有单位方块 ---------- + // 创建方块图区域，位于图例下方 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left + offsetX}, ${finalChartTopPosition})`); + + // 为每个类别创建方块组 + // 创建一个二维数组表示方块的位置占用情况 + const occupiedPositions = Array(numRows).fill().map(() => Array(numCols).fill(false)); + let squareIndex = 0; + + // 为每个类别创建方块 + categorySquares.forEach(cat => { + // 创建该类别的所有方块 + for (let i = 0; i < cat.squares; i++) { + if (squareIndex >= numRows * numCols) break; // 防止越界 + + // 先从上到下，再从左到右计数 + const col = Math.floor(squareIndex / numRows); + const row = squareIndex % numRows; + + occupiedPositions[row][col] = true; + + chart.append("rect") + .attr("data-category", cat.category) // 添加数据属性，方便交互 + .attr("x", col * maxSquareSize + squareSpacing / 2) + .attr("y", row * maxSquareSize + squareSpacing / 2) + .attr("width", squareSize) + .attr("height", squareSize) + .attr("fill", cat.color) + .attr("rx", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) // 圆角大小与方块大小成比例 + .attr("ry", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? Math.max(0.5, squareSize * 0.05) : 0) // 描边宽度与方块大小成比例 + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + squareIndex++; + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..178246ab102b1c407757749d347e16776381a6fc --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_02.js @@ -0,0 +1,246 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Waffle Chart", + "chart_name": "vertical_waffle_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 多网格单位方块图实现 - 每个类别各自有一个网格 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const fontSize = chartUtils.text.fontSize; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + + // 添加数值格式化函数 + + // 提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit || ""; + + // ---------- 2. 配置图表参数 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 计算标题所需高度 + const titleHeight = 70; // 每个图表类别标题高度 + + // 初始设置图表边距 + const margin = { + top: 30, + right: 30, + bottom: 40, + left: 30 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 为每个类别创建网格参数 ---------- + // 网格配置 + const gridSize = 10; // 每个网格10x10的格子 + const totalCells = gridSize * gridSize; // 总格子数 + + // 用于颜色分配 + const categoryColors = {}; + + // 如果没有为每个类别指定颜色，使用默认颜色方案 + const defaultColors = colorResolver.availablePalette(6, { + fallbackColors: ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#ff8ab7", "#97bbf5"], + }); + + // 计算数据总和 + const totalValue = chartData.reduce((sum, d) => sum + (+d[yField] || 0), 0); + + // 计算每个类别的比例 + const categoryInfo = chartData.map((d, i) => { + const category = d[xField]; + const value = +d[yField]; + const percentage = totalValue > 0 ? (value / totalValue) * 100 : 0; + const filledCells = Math.round((percentage / 100) * totalCells); + + // 确保每个类别有颜色 + categoryColors[category] = colorResolver.field(category, i, { colors: defaultColors }).value; + + return { + category: category, + value: value, + percentage: percentage, + filledCells: filledCells, + color: categoryColors[category] + }; + }); + + // 计算每个网格的尺寸 + const numCategories = categoryInfo.length; + const gridMargin = 40; // 网格之间的间距 + + // 根据类别数量确定网格布局（每行最多3个） + const gridsPerRow = Math.min(3, numCategories); + const numRows = Math.ceil(numCategories / gridsPerRow); + + const gridWidth = (innerWidth - (gridsPerRow - 1) * gridMargin) / gridsPerRow; + const gridHeight = gridWidth; // 保持正方形 + + // 计算单元格大小 + const cellSize = (gridWidth / gridSize) * 0.9; // 留一些间距 + const cellMargin = (gridWidth / gridSize) * 0.1; + + // ---------- 4. 创建SVG容器 ---------- + // 清除容器 + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 5. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 1); + + filter.append("feOffset") + .attr("dx", 1) + .attr("dy", 1) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 6. 创建主图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 为每个类别创建网格 ---------- + categoryInfo.forEach((info, index) => { + // 计算网格位置 + const rowIndex = Math.floor(index / gridsPerRow); + const colIndex = index % gridsPerRow; + + const gridX = colIndex * (gridWidth + gridMargin); + const gridY = rowIndex * (gridHeight + titleHeight + gridMargin); + + // 创建网格容器 + const grid = chart.append("g") + .attr("class", "category-grid") + .attr("transform", `translate(${gridX}, ${gridY})`); + + // 添加标题 + grid.append("text") + .attr("x", gridWidth / 2) + .attr("y", -titleHeight / 2) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize(typography.label.font_size)}px`) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`${info.category} ${chartUtils.format.percent(info.percentage, { digits: 0 }).text}`); + + // 添加值 + grid.append("text") + .attr("x", gridWidth / 2) + .attr("y", -titleHeight / 4) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize(typography.annotation.font_size)}px`) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`${chartUtils.format.autoText(info.value)} ${yUnit}`); + + // 创建背景单元格 + for (let row = 0; row < gridSize; row++) { + for (let col = 0; col < gridSize; col++) { + const cellIndex = row * gridSize + col; + + grid.append("rect") + .attr("x", col * (cellSize + cellMargin)) + .attr("y", row * (cellSize + cellMargin)) + .attr("width", cellSize) + .attr("height", cellSize) + .attr("fill", "#cccccc") // 改为灰色背景 + .attr("opacity", 0.5) + .attr("rx", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0); + } + } + + // 创建填充单元格 + for (let cellIndex = 0; cellIndex < info.filledCells; cellIndex++) { + // 从底部开始填充 + const row = Math.floor(cellIndex / gridSize); + const col = cellIndex % gridSize; + + grid.append("rect") + .attr("x", col * (cellSize + cellMargin)) + .attr("y", row * (cellSize + cellMargin)) + .attr("width", cellSize) + .attr("height", cellSize) + .attr("fill", info.color) + .attr("rx", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("stroke", "none") // 移除描边 + .attr("stroke-width", 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_03.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_03.js new file mode 100644 index 0000000000000000000000000000000000000000..c255875f5e78da878e8672e0a798747f02c5adcc --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_03.js @@ -0,0 +1,504 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Waffle Chart", + "chart_name": "vertical_waffle_chart_03", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical", "temporal"], ["numerical"]], + "required_fields_range": [[2, 10], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["radius_corner", "stroke"], + "min_height": 420, + "min_width": 420, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const sourceData = (jsonData.data && jsonData.data.data) || []; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const colorConfig = jsonData.colors_dark || jsonData.colors || {}; + const fieldColors = colorConfig.field || {}; + const otherColors = colorConfig.other || {}; + + d3.select(containerSelector).html(""); + + const categoryColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const valueColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const categoryField = categoryColumn.name; + const valueField = valueColumn.name; + const categoryType = categoryColumn.data_type || "categorical"; + const categoryUnit = (categoryColumn.unit || "").trim(); + const valueUnit = (valueColumn.unit || "").trim(); + + const width = Math.max(520, Number(variables.width) || 600); + const height = Math.max(520, Number(variables.height) || 600); + const backgroundColor = colorConfig.background_color || "#243447"; + const primaryColor = otherColors.primary || "#7dd3fc"; + const mutedCellColor = "rgba(226, 232, 240, 0.16)"; + const gridColor = "rgba(226, 232, 240, 0.22)"; + const fontFamily = (typography.label && typography.label.font_family) || + (typography.title && typography.title.font_family) || + "Arial, sans-serif"; + const annotationFamily = (typography.annotation && typography.annotation.font_family) || fontFamily; + const labelWeight = (typography.label && typography.label.font_weight) || "700"; + const valueWeight = (typography.annotation && typography.annotation.font_weight) || "600"; + const baseLabelSize = parseFloat(typography.label && typography.label.font_size) || 11; + const baseValueSize = parseFloat(typography.annotation && typography.annotation.font_size) || 10; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("class", "vertical-waffle-root"); + + function luminance(color) { + const c = d3.rgb(color); + return [c.r, c.g, c.b].map(v => { + const channel = v / 255; + return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4); + }).reduce((sum, v, index) => sum + v * [0.2126, 0.7152, 0.0722][index], 0); + } + + function contrastRatio(a, b) { + const l1 = luminance(a); + const l2 = luminance(b); + return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05); + } + + function readableTextColor(candidate, fallback) { + if (!candidate) return fallback; + return contrastRatio(candidate, backgroundColor) >= 4.2 ? candidate : fallback; + } + + const textColor = readableTextColor(colorConfig.text_color, "#f8fafc"); + const mutedText = readableTextColor("#cbd5e1", "#f1f5f9"); + + function showMessage(message) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", "16px") + .text(message); + return svg.node(); + } + + if (!categoryField || !valueField) { + return showMessage("Missing vertical waffle fields"); + } + + function cleanLabel(value) { + return String(value ?? "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function readableName(value) { + return cleanLabel(value).replace(/\b\w/g, letter => letter.toUpperCase()); + } + + function compactNumber(value) { + const numeric = Number(value); + if (!Number.isFinite(numeric)) return String(value ?? ""); + const abs = Math.abs(numeric); + if (abs >= 1000000000) return `${d3.format(".3~g")(numeric / 1000000000)}B`; + if (abs >= 1000000) return `${d3.format(".3~g")(numeric / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".3~g")(numeric / 1000)}K`; + return d3.format(",.4~g")(numeric); + } + + function formatLocalValue(value, includeUnit = true) { + const formatted = compactNumber(value); + if (!includeUnit || !valueUnit || valueUnit === "none") return formatted; + const currencyWithSuffix = valueUnit.match(/^([£$€¥])\s*([A-Za-z]+)$/); + if (valueUnit === "%") return `${formatted}%`; + if (currencyWithSuffix) return `${currencyWithSuffix[1]}${formatted}${currencyWithSuffix[2]}`; + if (/^[£$€¥]$/.test(valueUnit)) return `${valueUnit}${formatted}`; + return `${formatted} ${valueUnit}`; + } + + function parseTemporalRank(value) { + const text = String(value ?? "").trim(); + let match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^q([1-4])\s*(-?\d{4})$/i) || text.match(/^(-?\d{4})\s*q([1-4])$/i); + if (match && match[1].length === 1) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + return NaN; + } + + function parseOrdinalRank(value) { + const text = String(value ?? "").trim().toLowerCase(); + const normalized = text.replace(/[$,]/g, ""); + let match = normalized.match(/less\s+than\s+(-?\d+(?:\.\d+)?)/); + if (match) return Number(match[1]) - 0.1; + match = normalized.match(/more\s+than\s+(-?\d+(?:\.\d+)?)/); + if (match) return Number(match[1]) + 0.1; + match = normalized.match(/^(-?\d+(?:\.\d+)?)\s*(?:-|to)\s*-?\d+(?:\.\d+)?/); + if (match) return Number(match[1]); + match = normalized.match(/^(-?\d+(?:\.\d+)?)(?:st|nd|rd|th)?\b/); + if (match) return Number(match[1]); + + const exactRanks = new Map([ + ["none", 0], + ["minimal", 1], + ["light", 2], + ["low", 2], + ["moderate", 3], + ["medium", 3], + ["high", 4], + ["very high", 5], + ["enthusiastic", 6], + ["overuse", 7], + ["lowest", 1], + ["very low", 1], + ["lower middle", 3], + ["lower-middle", 3], + ["middle", 4], + ["upper middle", 5], + ["upper-middle", 5], + ["highest", 7] + ]); + if (exactRanks.has(text)) return exactRanks.get(text); + + const rankedPatterns = [ + [/^none$/, 0], + [/minimal/, 1], + [/\blight\b|\blow\b/, 2], + [/moderate|medium/, 3], + [/\bhigh\b/, 4], + [/very\s+high/, 5], + [/enthusiastic/, 6], + [/overuse/, 7], + [/very\s+low|lowest/, 1], + [/lower[-\s]?middle/, 3], + [/middle/, 4], + [/upper[-\s]?middle/, 5], + [/highest/, 7] + ]; + for (const [pattern, rank] of rankedPatterns) { + if (pattern.test(text)) return rank; + } + return NaN; + } + + const aggregated = new Map(); + sourceData.forEach((row, index) => { + const category = cleanLabel(row[categoryField]); + const value = Number(row[valueField]); + if (!category || !Number.isFinite(value) || value < 0) return; + if (!aggregated.has(category)) { + aggregated.set(category, { + category, + rawCategory: row[categoryField], + value: 0, + firstIndex: index + }); + } + aggregated.get(category).value += value; + }); + + const rows = Array.from(aggregated.values()); + if (rows.length < 2) { + return showMessage("Not enough data for vertical waffle chart"); + } + + const categoryStats = rows.map(d => ({ + ...d, + temporalRank: parseTemporalRank(d.rawCategory), + ordinalRank: parseOrdinalRank(d.rawCategory) + })); + const allTemporal = categoryType === "temporal" || categoryStats.every(d => Number.isFinite(d.temporalRank)); + const allOrdinal = !allTemporal && categoryStats.every(d => Number.isFinite(d.ordinalRank)); + const sortMode = allTemporal ? "chronological" : (allOrdinal ? "ordered category" : "ranked by value"); + const chartRows = categoryStats.slice().sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + if (allOrdinal) return d3.ascending(a.ordinalRank, b.ordinalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.value, b.value) || d3.ascending(a.category, b.category); + }).map((d, index) => ({ ...d, rank: index + 1 })); + + const measure = svg.append("g").attr("visibility", "hidden"); + function measureLabelText(text, fontSize, family = fontFamily, weight = labelWeight) { + const node = measure.append("text") + .style("font-family", family) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight) + .text(String(text ?? "")) + .node(); + const measured = node ? node.textContent.length * 7 : 0; + measure.selectAll("text").remove(); + return Math.max(measured || 0, String(text ?? "").length * fontSize * 0.52); + } + + function truncateText(text, maxWidth, fontSize, family = fontFamily, weight = labelWeight) { + const full = String(text ?? ""); + if (measureLabelText(full, fontSize, family, weight) <= maxWidth) return full; + let lo = 1; + let hi = full.length; + let best = full.slice(0, 1); + while (lo <= hi) { + const mid = Math.floor((lo + hi) / 2); + const candidate = `${full.slice(0, mid).trim()}...`; + if (measureLabelText(candidate, fontSize, family, weight) <= maxWidth) { + best = candidate; + lo = mid + 1; + } else { + hi = mid - 1; + } + } + return best; + } + + function wrapLabel(text, maxWidth, fontSize, maxLines = 2) { + const words = cleanLabel(text).split(" ").filter(Boolean); + if (!words.length) return [""]; + const lines = []; + let current = ""; + words.forEach(word => { + const candidate = current ? `${current} ${word}` : word; + if (measureLabelText(candidate, fontSize) <= maxWidth || !current) { + current = measureLabelText(candidate, fontSize) <= maxWidth + ? candidate + : truncateText(candidate, maxWidth, fontSize); + } else { + lines.push(current); + current = measureLabelText(word, fontSize) <= maxWidth + ? word + : truncateText(word, maxWidth, fontSize); + } + }); + if (current) lines.push(current); + if (lines.length <= maxLines) return lines; + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = truncateText(kept.slice(maxLines - 1).concat(lines.slice(maxLines)).join(" "), maxWidth, fontSize); + return kept; + } + + const margin = { + top: 34, + right: 26, + bottom: 112, + left: 62 + }; + const plotWidth = width - margin.left - margin.right; + const plotHeight = height - margin.top - margin.bottom; + const plotBottom = margin.top + plotHeight; + const n = chartRows.length; + const lanes = n > 8 ? 2 : 3; + const cellRows = 20; + const totalCells = lanes * cellRows; + const columnSlot = plotWidth / n; + const columnWidth = Math.min(columnSlot * 0.72, n > 8 ? 40 : 52); + const cellGap = Math.max(1.1, Math.min(2.5, columnWidth * 0.055)); + const cellSize = Math.max( + 5.5, + Math.min((columnWidth - (lanes - 1) * cellGap) / lanes, (plotHeight - (cellRows - 1) * cellGap) / cellRows) + ); + const actualColumnWidth = lanes * cellSize + (lanes - 1) * cellGap; + const actualColumnHeight = cellRows * cellSize + (cellRows - 1) * cellGap; + const columnTop = plotBottom - actualColumnHeight; + const labelFontSize = Math.max(8, Math.min(baseLabelSize, n > 8 ? 9 : 10.5)); + const valueFontSize = Math.max(8, Math.min(baseValueSize, 10)); + + const maxValue = Math.max(1, d3.max(chartRows, d => d.value) || 1); + const percentScale = valueUnit === "%" && maxValue <= 100; + const yScale = d3.scaleLinear() + .domain([0, percentScale ? 100 : maxValue]) + .nice(4) + .range([plotBottom, columnTop]); + const domainMax = yScale.domain()[1]; + const ticks = yScale.ticks(4); + + const palette = d3.schemeTableau10 || d3.schemeCategory10; + function colorForCategory(d, index) { + return fieldColors[d.category] || fieldColors[d.rawCategory] || primaryColor || palette[index % palette.length]; + } + + const chart = svg.append("g") + .attr("class", "vertical-waffle-chart") + .attr("data-tag", "chart"); + + ticks.forEach(tick => { + const y = yScale(tick); + chart.append("line") + .attr("class", "gridline y-gridline") + .attr("x1", margin.left) + .attr("x2", width - margin.right) + .attr("y1", y) + .attr("y2", y) + .attr("stroke", gridColor) + .attr("stroke-width", tick === 0 ? 1.3 : 1) + .attr("stroke-dasharray", tick === 0 ? null : "3,4"); + chart.append("text") + .attr("class", "axis-tick") + .attr("x", margin.left - 10) + .attr("y", y) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8, valueFontSize * 0.86)}px`) + .style("font-weight", valueWeight) + .text(formatLocalValue(tick, false)); + }); + + chart.append("line") + .attr("class", "baseline") + .attr("x1", margin.left) + .attr("x2", width - margin.right) + .attr("y1", plotBottom) + .attr("y2", plotBottom) + .attr("stroke", "rgba(248, 250, 252, 0.46)") + .attr("stroke-width", 1.4); + + chartRows.forEach((d, index) => { + const centerX = margin.left + columnSlot * index + columnSlot / 2; + const x0 = centerX - actualColumnWidth / 2; + const fillCells = Math.max(0, Math.min(totalCells, Math.round((d.value / domainMax) * totalCells))); + const group = chart.append("g") + .attr("class", "waffle-column data-point") + .attr("data-tag", "mark") + .attr("data-category", d.category) + .attr("data-value", d.value) + .attr("transform", `translate(${x0}, ${columnTop})`); + + for (let cellIndex = 0; cellIndex < totalCells; cellIndex += 1) { + const rowFromBottom = Math.floor(cellIndex / lanes); + const lane = cellIndex % lanes; + const x = lane * (cellSize + cellGap); + const y = (cellRows - 1 - rowFromBottom) * (cellSize + cellGap); + const filled = cellIndex < fillCells; + group.append("rect") + .attr("class", filled ? "waffle-cell filled-waffle-cell" : "waffle-cell background-waffle-cell") + .attr("x", x) + .attr("y", y) + .attr("width", cellSize) + .attr("height", cellSize) + .attr("rx", variables.has_rounded_corners ? Math.max(1, cellSize * 0.22) : Math.max(0.7, cellSize * 0.1)) + .attr("ry", variables.has_rounded_corners ? Math.max(1, cellSize * 0.22) : Math.max(0.7, cellSize * 0.1)) + .attr("fill", filled ? colorForCategory(d, index) : mutedCellColor) + .attr("stroke", "rgba(248, 250, 252, 0.18)") + .attr("stroke-width", 0.5); + } + + chart.append("text") + .attr("class", "value-label") + .attr("x", centerX) + .attr("y", yScale(d.value) - 8) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "ideographic") + .attr("fill", textColor) + .style("font-family", annotationFamily) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", "700") + .text(formatLocalValue(d.value, true)); + + const labelLines = wrapLabel(d.category, Math.max(34, columnSlot * 0.92), labelFontSize, 2); + const label = chart.append("text") + .attr("class", "category-label") + .attr("x", centerX) + .attr("y", plotBottom + 18) + .attr("text-anchor", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", `${labelFontSize}px`) + .style("font-weight", labelWeight); + labelLines.forEach((line, lineIndex) => { + label.append("tspan") + .attr("x", centerX) + .attr("dy", lineIndex === 0 ? 0 : labelFontSize + 2) + .text(line); + }); + }); + + chart.append("text") + .attr("class", "axis-title") + .attr("x", margin.left) + .attr("y", margin.top - 14) + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.8, valueFontSize * 0.92)}px`) + .style("font-weight", valueWeight) + .text(valueUnit && valueUnit !== "none" + ? `${readableName(valueColumn.label || valueColumn.name || valueField)} (${valueUnit})` + : readableName(valueColumn.label || valueColumn.name || valueField)); + + const sortLabel = sortMode === "chronological" + ? "chronological order" + : (sortMode === "ordered category" ? "ordered category scale" : "ranked by value"); + svg.append("text") + .attr("class", "category-note") + .attr("x", 24) + .attr("y", height - 24) + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.4, valueFontSize * 0.86)}px`) + .text(`${readableName(categoryColumn.label || categoryColumn.name || categoryField)}${categoryUnit ? ` (${categoryUnit})` : ""}: ${sortLabel}`); + + svg.append("text") + .attr("class", "scale-note") + .attr("x", width - 24) + .attr("y", height - 24) + .attr("text-anchor", "end") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.4, valueFontSize * 0.86)}px`) + .text(`Each column has ${totalCells} cells; scale 0-${formatLocalValue(domainMax, true)}`); + + svg.append("text") + .attr("class", "vertical-waffle-key") + .attr("x", width - 24) + .attr("y", margin.top - 14) + .attr("text-anchor", "end") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.4, valueFontSize * 0.86)}px`) + .text("Filled cells encode the value on a shared vertical scale"); + + measure.remove(); + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_04.js b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_04.js new file mode 100644 index 0000000000000000000000000000000000000000..3eaf617876f60005dc1a352901506b56d3c3da32 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_vertical/vertical_waffle_chart_04.js @@ -0,0 +1,283 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Waffle Chart", + "chart_name": "vertical_waffle_chart_04", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "yes", + "icon_label": "yes", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 多网格单位方块图实现 - 每个类别各自有一个网格 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const fontSize = chartUtils.text.fontSize; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + + // 添加数值格式化函数 + + // 提取图标信息 + const images = jsonData.images || { field: {} }; + + // 提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit || ""; + + // ---------- 2. 配置图表参数 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 计算标题所需高度 + const titleHeight = 100; // 增加高度以适应图标 + const iconSize = 40; // 图标大小 + + // 初始设置图表边距 + const margin = { + top: 30, + right: 30, + bottom: 40, + left: 30 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 为每个类别创建网格参数 ---------- + // 网格配置 + const gridSize = 10; // 每个网格10x10的格子 + const totalCells = gridSize * gridSize; // 总格子数 + + // 用于颜色分配 + const categoryColors = {}; + + // 如果没有为每个类别指定颜色，使用默认颜色方案 + const defaultColors = colorResolver.availablePalette(6, { + fallbackColors: ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#ff8ab7", "#97bbf5"], + }); + + // 计算数据总和 + const totalValue = chartData.reduce((sum, d) => sum + (+d[yField] || 0), 0); + + // 计算每个类别的比例 + const categoryInfo = chartData.map((d, i) => { + const category = d[xField]; + const value = +d[yField]; + const percentage = totalValue > 0 ? (value / totalValue) * 100 : 0; + const filledCells = Math.round((percentage / 100) * totalCells); + + // 确保每个类别有颜色 + categoryColors[category] = colorResolver.field(category, i, { colors: defaultColors }).value; + + return { + category: category, + value: value, + percentage: percentage, + filledCells: filledCells, + color: categoryColors[category], + icon: images.field && images.field[category] ? images.field[category] : null + }; + }); + + // 计算每个网格的尺寸 + const numCategories = categoryInfo.length; + const gridMargin = 40; // 网格之间的间距 + + // 根据类别数量确定网格布局（每行最多3个） + const gridsPerRow = Math.min(3, numCategories); + const numRows = Math.ceil(numCategories / gridsPerRow); + + const gridWidth = (innerWidth - (gridsPerRow - 1) * gridMargin) / gridsPerRow; + const gridHeight = gridWidth; // 保持正方形 + + // 计算单元格大小 + const cellSize = (gridWidth / gridSize) * 0.9; // 留一些间距 + const cellMargin = (gridWidth / gridSize) * 0.1; + + // ---------- 4. 创建SVG容器 ---------- + // 清除容器 + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 5. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 1); + + filter.append("feOffset") + .attr("dx", 1) + .attr("dy", 1) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 6. 创建主图表区域 ---------- + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 为每个类别创建网格 ---------- + categoryInfo.forEach((info, index) => { + // 计算网格位置 + const rowIndex = Math.floor(index / gridsPerRow); + const colIndex = index % gridsPerRow; + + const gridX = colIndex * (gridWidth + gridMargin); + const gridY = rowIndex * (gridHeight + titleHeight + gridMargin); + + // 创建网格容器 + const grid = chart.append("g") + .attr("class", "category-grid") + .attr("transform", `translate(${gridX}, ${gridY})`); + + // 添加图标 + if (info.icon) { + // 为图标创建圆形背景 + grid.append("circle") + .attr("cx", gridWidth / 2) + .attr("cy", -titleHeight / 2 - 20) + .attr("r", iconSize / 2 + 5) + .attr("fill", info.color) + .attr("opacity", 0.9); + + // 添加图标图像 + grid.append("image") + .attr("x", gridWidth / 2 - iconSize / 2) + .attr("y", -titleHeight / 2 - 20 - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", info.icon) + .attr("preserveAspectRatio", "xMidYMid meet"); + + // 添加百分比文本到图标旁边 + grid.append("text") + .attr("x", gridWidth / 2 + iconSize / 2 + 15) + .attr("y", -titleHeight / 2 - 20) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("font-family", typography.title.font_family) + .style("font-size", `${fontSize(20)}px`) + .style("font-weight", "bold") + .style("fill", info.color) + .text(chartUtils.format.percent(info.percentage, { digits: 0 }).text); + } + + // 添加标题 + grid.append("text") + .attr("x", gridWidth / 2) + .attr("y", -titleHeight / 2 + 20) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize(typography.label.font_size)}px`) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`${info.category}`); + + // 添加值 + grid.append("text") + .attr("x", gridWidth / 2) + .attr("y", -titleHeight / 2 + 40) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize(typography.annotation.font_size)}px`) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`${chartUtils.format.autoText(info.value)} ${yUnit}`); + + // 创建背景单元格 + for (let row = 0; row < gridSize; row++) { + for (let col = 0; col < gridSize; col++) { + const cellIndex = row * gridSize + col; + + grid.append("rect") + .attr("x", col * (cellSize + cellMargin)) + .attr("y", row * (cellSize + cellMargin)) + .attr("width", cellSize) + .attr("height", cellSize) + .attr("fill", "#cccccc") // 改为灰色背景 + .attr("opacity", 0.5) + .attr("rx", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0); + } + } + + // 创建填充单元格 + for (let cellIndex = 0; cellIndex < info.filledCells; cellIndex++) { + // 从底部开始填充 + const row = Math.floor(cellIndex / gridSize); + const col = cellIndex % gridSize; + + grid.append("rect") + .attr("x", col * (cellSize + cellMargin)) + .attr("y", row * (cellSize + cellMargin)) + .attr("width", cellSize) + .attr("height", cellSize) + .attr("fill", info.color) + .attr("rx", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, cellSize * 0.1) : 0) + .attr("stroke", "none") // 移除描边 + .attr("stroke-width", 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + } + }); + + // 返回SVG节点 + return svg.node(); +}