@toriistudio/shader-ui 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -2090,12 +2090,1370 @@ function Efecto({
     }
   );
 }
+
+// src/components/Snow.tsx
+import { useCallback as useCallback6, useEffect as useEffect7, useRef as useRef7 } from "react";
+import * as THREE7 from "three";
+
+// src/shaders/snow/fragment.glsl
+var fragment_default7 = "precision mediump float;\n\nuniform vec3 uColor;\n\nvarying float vAlpha;\n\nvoid main() {\n  vec2 uv = gl_PointCoord - 0.5;\n  float dist = length(uv);\n  float mask = smoothstep(0.5, 0.0, dist);\n  if (mask <= 0.01) {\n    discard;\n  }\n\n  float centerGlow = smoothstep(0.22, 0.0, dist);\n  vec3 color = mix(uColor * 1.2, uColor, centerGlow);\n\n  gl_FragColor = vec4(color, mask * vAlpha);\n}\n";
+
+// src/shaders/snow/vertex.glsl
+var vertex_default6 = "uniform float uTime;\nuniform float uFallSpeed;\nuniform float uWindStrength;\nuniform float uTurbulence;\nuniform float uSize;\nuniform float uTwinkleStrength;\nuniform vec3 uArea;\n\nattribute float aSpeed;\nattribute float aSize;\nattribute float aSeed;\n\nvarying float vAlpha;\n\nfloat wrap(float value, float size) {\n  return mod(value + size * 0.5, size) - size * 0.5;\n}\n\nvoid main() {\n  float height = uArea.y;\n  float width = uArea.x;\n  float depth = uArea.z;\n\n  float fall = uFallSpeed * (0.3 + aSpeed);\n  float droppedY = position.y - uTime * fall;\n  float wrappedY = wrap(droppedY, height);\n\n  float sway =\n      sin((wrappedY + aSeed) * 0.45 + uTime * 0.8) * uTurbulence +\n      cos(uTime * 0.35 + aSeed) * 0.15;\n  float wind = uWindStrength * (0.4 + aSpeed);\n  float displacedX = wrap(position.x + sway + wind, width);\n\n  float driftZ =\n      sin(uTime * 0.25 + aSeed * 1.7) * 0.5 +\n      cos((wrappedY + aSeed) * 0.2) * 0.4;\n  float displacedZ = wrap(position.z + driftZ, depth);\n\n  vec4 modelPosition =\n      modelMatrix * vec4(displacedX, wrappedY, displacedZ, 1.0);\n  vec4 viewPosition = viewMatrix * modelPosition;\n\n  float baseSize = mix(0.45, 1.0, aSize) * uSize;\n  float twinkle =\n      1.0 + sin(uTime * (0.6 + aSpeed) + aSeed) * uTwinkleStrength;\n  float perspective = clamp(15.0 / max(1.0, -viewPosition.z), 0.5, 3.0);\n  gl_PointSize = baseSize * twinkle * perspective;\n  gl_Position = projectionMatrix * viewPosition;\n\n  vAlpha = mix(0.35, 1.0, aSize);\n}\n";
+
+// src/components/Snow.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var AREA_BOUNDS = {
+  width: 36,
+  height: 44,
+  depth: 26
+};
+function createSnowGeometry(count) {
+  const geometry = new THREE7.BufferGeometry();
+  const positions = new Float32Array(count * 3);
+  const speeds = new Float32Array(count);
+  const sizes = new Float32Array(count);
+  const seeds = new Float32Array(count);
+  for (let i = 0; i < count; i += 1) {
+    const x = (Math.random() - 0.5) * AREA_BOUNDS.width;
+    const y = (Math.random() - 0.5) * AREA_BOUNDS.height;
+    const z = (Math.random() - 0.5) * AREA_BOUNDS.depth;
+    positions[i * 3] = x;
+    positions[i * 3 + 1] = y;
+    positions[i * 3 + 2] = z;
+    speeds[i] = Math.random();
+    sizes[i] = Math.random();
+    seeds[i] = Math.random() * 100;
+  }
+  geometry.setAttribute("position", new THREE7.BufferAttribute(positions, 3));
+  geometry.setAttribute("aSpeed", new THREE7.BufferAttribute(speeds, 1));
+  geometry.setAttribute("aSize", new THREE7.BufferAttribute(sizes, 1));
+  geometry.setAttribute("aSeed", new THREE7.BufferAttribute(seeds, 1));
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function buildUniforms2({
+  color,
+  fallSpeed,
+  windStrength,
+  turbulence,
+  flakeSize,
+  twinkleStrength
+}) {
+  return {
+    uTime: { value: 0 },
+    uFallSpeed: { value: fallSpeed },
+    uWindStrength: { value: windStrength },
+    uTurbulence: { value: turbulence },
+    uSize: { value: flakeSize },
+    uTwinkleStrength: { value: twinkleStrength },
+    uColor: { value: new THREE7.Color(color) },
+    uArea: {
+      value: new THREE7.Vector3(
+        AREA_BOUNDS.width,
+        AREA_BOUNDS.height,
+        AREA_BOUNDS.depth
+      )
+    }
+  };
+}
+function Snow({
+  className,
+  style,
+  width,
+  height,
+  color,
+  fallSpeed,
+  windStrength,
+  turbulence,
+  flakeSize,
+  twinkleStrength,
+  flakeCount,
+  mouseWindInteraction = false,
+  ...divProps
+}) {
+  const snowRef = useRef7(null);
+  const uniformsRef = useRef7({
+    color,
+    fallSpeed,
+    windStrength,
+    turbulence,
+    flakeSize,
+    twinkleStrength,
+    flakeCount
+  });
+  uniformsRef.current = {
+    color,
+    fallSpeed,
+    windStrength,
+    turbulence,
+    flakeSize,
+    twinkleStrength,
+    flakeCount
+  };
+  const pointerWindOffsetRef = useRef7(0);
+  const pointerWindTargetRef = useRef7(0);
+  const pointerStateRef = useRef7({
+    lastX: 0,
+    lastTime: 0,
+    timeoutId: null
+  });
+  const pointerActiveRef = useRef7(false);
+  const baseWindRef = useRef7(windStrength);
+  useEffect7(() => {
+    baseWindRef.current = windStrength;
+  }, [windStrength]);
+  const handleCreate = useCallback6(({ scene }) => {
+    const uniforms = buildUniforms2(uniformsRef.current);
+    const geometry = createSnowGeometry(
+      Math.max(1, Math.floor(uniformsRef.current.flakeCount))
+    );
+    const material = new THREE7.ShaderMaterial({
+      fragmentShader: fragment_default7,
+      vertexShader: vertex_default6,
+      uniforms,
+      transparent: true,
+      depthWrite: false,
+      blending: THREE7.AdditiveBlending
+    });
+    const points = new THREE7.Points(geometry, material);
+    points.frustumCulled = false;
+    scene.add(points);
+    snowRef.current = { points, geometry, material, uniforms };
+    return () => {
+      scene.remove(points);
+      geometry.dispose();
+      material.dispose();
+      snowRef.current = null;
+    };
+  }, []);
+  const handleRender = useCallback6(
+    (_context, delta, elapsedTime) => {
+      const assets = snowRef.current;
+      if (!assets) return;
+      assets.uniforms.uTime.value = elapsedTime;
+      const currentOffset = pointerWindOffsetRef.current;
+      const targetOffset = pointerWindTargetRef.current;
+      const nextOffset = THREE7.MathUtils.damp(
+        currentOffset,
+        targetOffset,
+        3.5,
+        delta
+      );
+      if (Math.abs(nextOffset - currentOffset) > 5e-5) {
+        pointerWindOffsetRef.current = nextOffset;
+        assets.uniforms.uWindStrength.value = baseWindRef.current + nextOffset;
+      }
+    },
+    []
+  );
+  const { containerRef } = useScene({
+    camera: {
+      position: [0, 0, 18]
+    },
+    onCreate: handleCreate,
+    onRender: handleRender
+  });
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uColor.value.set(color);
+  }, [color]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uFallSpeed.value = fallSpeed;
+  }, [fallSpeed]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uWindStrength.value = windStrength + pointerWindOffsetRef.current;
+  }, [windStrength]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uTurbulence.value = turbulence;
+  }, [turbulence]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uSize.value = flakeSize;
+  }, [flakeSize]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    assets.uniforms.uTwinkleStrength.value = twinkleStrength;
+  }, [twinkleStrength]);
+  useEffect7(() => {
+    const assets = snowRef.current;
+    if (!assets) return;
+    const geometry = createSnowGeometry(Math.max(1, Math.floor(flakeCount)));
+    assets.points.geometry.dispose();
+    assets.points.geometry = geometry;
+    assets.geometry = geometry;
+  }, [flakeCount]);
+  useEffect7(() => {
+    const pointerState = pointerStateRef.current;
+    const clearTimeoutIfNeeded = () => {
+      if (pointerState.timeoutId !== null) {
+        window.clearTimeout(pointerState.timeoutId);
+        pointerState.timeoutId = null;
+      }
+    };
+    if (!mouseWindInteraction) {
+      clearTimeoutIfNeeded();
+      pointerWindOffsetRef.current = 0;
+      pointerWindTargetRef.current = 0;
+      pointerState.lastTime = 0;
+      pointerActiveRef.current = false;
+      const assets = snowRef.current;
+      if (assets) {
+        assets.uniforms.uWindStrength.value = windStrength;
+      }
+      return;
+    }
+    const container = containerRef.current;
+    if (!container) return;
+    const scheduleReset = () => {
+      clearTimeoutIfNeeded();
+      pointerState.timeoutId = window.setTimeout(() => {
+        pointerWindTargetRef.current = 0;
+        pointerState.timeoutId = null;
+      }, 220);
+    };
+    const handlePointerMove = (event) => {
+      const isMouse = event.pointerType === "mouse";
+      if (!isMouse && !pointerActiveRef.current) return;
+      const now = performance.now();
+      if (pointerState.lastTime === 0) {
+        pointerState.lastX = event.clientX;
+        pointerState.lastTime = now;
+        return;
+      }
+      const dx = event.clientX - pointerState.lastX;
+      const dt = Math.max(1, now - pointerState.lastTime);
+      const velocity = dx / dt;
+      const offset = THREE7.MathUtils.clamp(velocity * 0.9, -1.6, 1.6);
+      pointerWindTargetRef.current = offset;
+      pointerState.lastX = event.clientX;
+      pointerState.lastTime = now;
+      scheduleReset();
+    };
+    const handlePointerDown = (event) => {
+      pointerActiveRef.current = true;
+      pointerState.lastX = event.clientX;
+      pointerState.lastTime = performance.now();
+      scheduleReset();
+    };
+    const handlePointerUp = () => {
+      pointerActiveRef.current = false;
+      pointerState.lastTime = 0;
+      pointerWindTargetRef.current = 0;
+      scheduleReset();
+    };
+    const handlePointerLeave = () => {
+      pointerActiveRef.current = false;
+      pointerState.lastTime = 0;
+      pointerWindTargetRef.current = 0;
+      clearTimeoutIfNeeded();
+    };
+    container.addEventListener("pointermove", handlePointerMove);
+    container.addEventListener("pointerdown", handlePointerDown);
+    container.addEventListener("pointerup", handlePointerUp);
+    container.addEventListener("pointercancel", handlePointerUp);
+    container.addEventListener("pointerout", handlePointerLeave);
+    container.addEventListener("pointerleave", handlePointerLeave);
+    return () => {
+      container.removeEventListener("pointermove", handlePointerMove);
+      container.removeEventListener("pointerdown", handlePointerDown);
+      container.removeEventListener("pointerup", handlePointerUp);
+      container.removeEventListener("pointercancel", handlePointerUp);
+      container.removeEventListener("pointerout", handlePointerLeave);
+      container.removeEventListener("pointerleave", handlePointerLeave);
+      pointerState.lastTime = 0;
+      pointerWindOffsetRef.current = 0;
+      pointerWindTargetRef.current = 0;
+      pointerActiveRef.current = false;
+      clearTimeoutIfNeeded();
+      const assets = snowRef.current;
+      if (assets) {
+        assets.uniforms.uWindStrength.value = windStrength;
+      }
+    };
+  }, [containerRef, mouseWindInteraction, windStrength]);
+  return /* @__PURE__ */ jsx8(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        width: width ?? "100%",
+        height: height ?? "100%",
+        ...style
+      },
+      ...divProps
+    }
+  );
+}
+
+// src/components/AnimatedDrawingSVG.tsx
+import clsx from "clsx";
+import { useEffect as useEffect8, useLayoutEffect, useRef as useRef8 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var PATH_SELECTOR = "path, line, polyline, polygon, circle, ellipse";
+function AnimatedDrawingSVG({
+  svgMarkup,
+  animated = true,
+  size,
+  onAnimated,
+  delay,
+  className,
+  style,
+  ...divProps
+}) {
+  const containerRef = useRef8(null);
+  const animationsRef = useRef8([]);
+  const parserRef = useRef8(null);
+  const onAnimatedRef = useRef8(onAnimated);
+  const animationRunIdRef = useRef8(0);
+  const onAnimationCompleteRef = useRef8(false);
+  const timeoutRef = useRef8([]);
+  const monitorRafRef = useRef8(null);
+  const sanitizedMarkup = (svgMarkup ?? "").toString().trim();
+  const normalizedDelay = typeof delay === "number" && delay > 0 ? delay : 0;
+  useEffect8(() => {
+    onAnimatedRef.current = onAnimated;
+  }, [onAnimated]);
+  useEffect8(() => {
+    return () => {
+      animationsRef.current.forEach((animation) => animation.cancel());
+      animationsRef.current = [];
+      timeoutRef.current.forEach((id) => window.clearTimeout(id));
+      timeoutRef.current = [];
+      if (monitorRafRef.current !== null) {
+        cancelAnimationFrame(monitorRafRef.current);
+        monitorRafRef.current = null;
+      }
+    };
+  }, []);
+  useLayoutEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    let rafId = null;
+    let delayId = null;
+    let started = false;
+    if (normalizedDelay > 0) {
+      container.style.visibility = "hidden";
+    } else {
+      container.style.removeProperty("visibility");
+    }
+    animationRunIdRef.current += 1;
+    const currentRunId = animationRunIdRef.current;
+    onAnimationCompleteRef.current = false;
+    timeoutRef.current.forEach((id) => window.clearTimeout(id));
+    timeoutRef.current = [];
+    const markComplete = () => {
+      if (animationRunIdRef.current === currentRunId && !onAnimationCompleteRef.current) {
+        onAnimationCompleteRef.current = true;
+        onAnimatedRef.current?.();
+      }
+    };
+    animationsRef.current.forEach((animation) => animation.cancel());
+    animationsRef.current = [];
+    if (monitorRafRef.current !== null) {
+      cancelAnimationFrame(monitorRafRef.current);
+      monitorRafRef.current = null;
+    }
+    if (!sanitizedMarkup) {
+      container.replaceChildren();
+      markComplete();
+      return;
+    }
+    const parser = parserRef.current ?? new DOMParser();
+    parserRef.current = parser;
+    let parsed;
+    try {
+      parsed = parser.parseFromString(sanitizedMarkup, "image/svg+xml");
+    } catch {
+      return;
+    }
+    if (parsed.querySelector("parsererror")) {
+      return;
+    }
+    const parsedSvg = parsed.querySelector("svg");
+    if (!parsedSvg) {
+      container.replaceChildren();
+      onAnimatedRef.current?.();
+      return;
+    }
+    const svgElement = document.importNode(parsedSvg, true);
+    svgElement.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    if (size !== void 0) {
+      svgElement.removeAttribute("width");
+      svgElement.removeAttribute("height");
+      const sizeValue = typeof size === "number" ? `${Math.max(0, size)}px` : `${size}`;
+      svgElement.style.width = sizeValue;
+      svgElement.style.height = "auto";
+    } else {
+      svgElement.style.width = "100%";
+      svgElement.style.height = "100%";
+      svgElement.style.maxWidth = "100%";
+      svgElement.style.maxHeight = "100%";
+    }
+    svgElement.style.display = "block";
+    container.replaceChildren(svgElement);
+    const runAnimations = () => {
+      const drawTargets = Array.from(
+        svgElement.querySelectorAll(PATH_SELECTOR)
+      );
+      const scheduleFallback = (delay2) => {
+        const fallbackId = window.setTimeout(markComplete, delay2);
+        timeoutRef.current.push(fallbackId);
+      };
+      if (!drawTargets.length) {
+        if (!animated) {
+          markComplete();
+        } else {
+          Promise.resolve().then(() => {
+            markComplete();
+          });
+        }
+        return;
+      }
+      let maxDuration = 0;
+      const resolveTimingValue = (value, fallback) => {
+        if (typeof value === "number") {
+          return value;
+        }
+        if (typeof value === "string") {
+          const parsed2 = Number.parseFloat(value);
+          return Number.isFinite(parsed2) ? parsed2 : fallback;
+        }
+        if (typeof value === "object" && value !== null) {
+          const parsed2 = Number.parseFloat(value.toString());
+          return Number.isFinite(parsed2) ? parsed2 : fallback;
+        }
+        return fallback;
+      };
+      drawTargets.forEach((element, index) => {
+        const length = typeof element.getTotalLength === "function" ? element.getTotalLength() : null;
+        if (!length || Number.isNaN(length)) {
+          element.style.removeProperty("stroke-dasharray");
+          element.style.removeProperty("stroke-dashoffset");
+          return;
+        }
+        const dashValue = `${length}`;
+        element.style.strokeDasharray = dashValue;
+        element.style.strokeDashoffset = animated ? dashValue : "0";
+        if (!element.style.strokeLinecap) {
+          element.style.strokeLinecap = "round";
+        }
+        if (!animated) {
+          return;
+        }
+        const animation = element.animate(
+          [{ strokeDashoffset: dashValue }, { strokeDashoffset: "0" }],
+          {
+            duration: Math.min(6500, Math.max(1200, length * 12)),
+            delay: index * 120,
+            easing: "ease-in-out",
+            fill: "forwards"
+          }
+        );
+        const timing = animation.effect?.getTiming();
+        const baseDuration = Math.min(6500, Math.max(1200, length * 12));
+        const total = resolveTimingValue(timing?.delay, index * 120) + resolveTimingValue(timing?.duration, baseDuration);
+        if (total > maxDuration) {
+          maxDuration = total;
+        }
+        animationsRef.current.push(animation);
+      });
+      if (!animated) {
+        markComplete();
+        return;
+      }
+      const startMonitor = () => {
+        const monitor = () => {
+          if (animationRunIdRef.current !== currentRunId) {
+            return;
+          }
+          const allFinished = animationsRef.current.every((animation) => {
+            const state = animation.playState;
+            return state === "finished" || state === "idle";
+          });
+          if (allFinished) {
+            if (monitorRafRef.current !== null) {
+              cancelAnimationFrame(monitorRafRef.current);
+              monitorRafRef.current = null;
+            }
+            markComplete();
+            return;
+          }
+          monitorRafRef.current = requestAnimationFrame(monitor);
+        };
+        if (monitorRafRef.current !== null) {
+          cancelAnimationFrame(monitorRafRef.current);
+        }
+        monitorRafRef.current = requestAnimationFrame(monitor);
+      };
+      startMonitor();
+      if (animated && maxDuration > 0) {
+        scheduleFallback(maxDuration + 50);
+      }
+    };
+    const triggerStart = () => {
+      if (started) return;
+      started = true;
+      container.style.removeProperty("visibility");
+      rafId = requestAnimationFrame(runAnimations);
+    };
+    if (normalizedDelay > 0) {
+      delayId = window.setTimeout(triggerStart, normalizedDelay);
+    } else {
+      triggerStart();
+    }
+    return () => {
+      if (delayId !== null) {
+        window.clearTimeout(delayId);
+      }
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+    };
+  }, [sanitizedMarkup, animated, size, normalizedDelay]);
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      ref: containerRef,
+      className: clsx(
+        "flex items-center justify-center [&_svg]:block",
+        className
+      ),
+      style: {
+        ...style
+      },
+      ...divProps
+    }
+  );
+}
+
+// src/components/WandyHand.tsx
+import { useEffect as useEffect9, useMemo as useMemo4, useRef as useRef9, useState } from "react";
+import opentype from "opentype.js";
+
+// src/assets/fonts/waltographUI.ttf
+var waltographUI_default = "data:font/ttf;base64,AAEAAAANAIAAAwBQT1MvMkwL+v4AAAFYAAAAVlZETVhijWoZAAD9CAAABeBjbWFwDqUX7AAABJQAAAZkZ2FzcP//AAQAAP0AAAAACGdseWYFY5/UAAAK+AAAbFRoZWFk543gmwAAANwAAAA2aGhlYRGiEJAAAAEUAAAAJGhtdHivWRW+AAABsAAAAuRrZXJuAdACuQAAeMAAAACEbG9jYU6zbRQAAHdMAAABdG1heHAA0wSFAAABOAAAACBuYW1l3eT7nwAAeUQAAIH8cG9zdKUewBwAAPtAAAABvwABAAAAAQAA/XxbyF8PPPUACwPoAAAAALyYn1gAAAAAvVT9yP/A/ukOwAOyAAEAAwACAAAAAAAAAAEAAAMgASMAAA7k/8D/zw7AAAEAAAAAAAAAAAAAAAAAAAC5AAEAAAC5A7oAEgDJAAQAAQAAAAAAAAAAAAAAAAADAAEAAQJpArwABQAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAMIBgIAAAAAAACAAAAvAAAASgAAAAAAAAAATUdCRgAgACAixQJC/0EAAAMgASMAAAABAAAAAAAAA18ADwH0AAACEwAeAt0AMgLOACkA9gAiAS0AEQEyAA0BQf/1AeAAJAEgABYBUAAPAQIAHgGP/88CvAAfArwAeAK8ABkCvABWArwAQQK8ADYCvAA9ArwAQAK8AEsCvABcAUQAMgE2ACwB+gASApUAHAD1//gBj//PAPUAAgFMAAkBTwAAAmkAFAL+ADICYgAeApYANAKiABICZAACAT8AVAJkACIB9AAqA6oAJAKYACIC4AAUAt0AFgJuAAACvAAyA10AFAKcACgCogATAoYAFgIEABMClgAWAV8AEwFQADECbwAxAm8AMQDnABQCEQAFAxMAEQGdAAsDHQAIAggAAAEpAEoCnABZAi0AFQHqACgCEgAgAdoAHQKgABMCoAATAVAAHwEsABMAtQALAKv/5QH6ABEBKQBKAZQAGgLaADICewAaAUMAMQK6ABUEOwAUAhcACwEDAAgBCwAbAZsADwGhABQCLQAtDuQALAD/ACICQgAYAfYADwE2AA4EKAApAUAAHQEwAA0BNwASA2QAEQNkAB4CrQAUAjcAFQKiABMCov/sBa4AFgQ7ABQDyAAUAVIAXwJeABQCXgAUAl4AFAJeABQCXgAUAl4AFAJeABQCXgAUAl4AFAJeABQCXgAUAl4AFAPIABQCkgAUApIAFAJiAB4CYgAeAmIAHgJiAB4CYgAeAmIAHgJiAB4CYgAeAVIAVAFSAFQBUgBUAVIAVAFSAFQBUgBUAVIAVAFSAFQC4AAUAuAAFALgABQC4AAUAuAAFALgABQC4AAUAuAAFALgABQC4AAUAuAAFALgABQCvAAyArwAMgK8ADICvAAyArwAMgK8ADICvAAyArwAMgKiABMCmAAiApgAIgKCACcCj//iAAAAAAIIAAACXgAUArIADACZABQBOwBBAaUACQGfADICYP/AAoYAFgKGABYDKABBA1kAQQNUAEECogATAqIAEwLdABYC3QAWAv4AMgKtABQAAAADAAAAAwAABCIAAQAAAAAAHAADAAEAAAHgAAYBxAAAACAA3QABAE0ATgACAAMABABSAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAF4AVABgABoAGwCjAE8AIQAiACMAJAAlACYAJwBmACgAKQAqACsALABlAGQAUAAtAC4ALwCkADAAMQAyADMAHAAdAB4AHwAgAAAAowBPACEAIgAjACQAJQAmACcAZgAoACkAKgArACwAZQBkAFAALQAuAC8ApAAwADEAMgAzAGEAbABiADQAAABxAHIAegB9AKEAkACbAHQAcwB1AHcAdgB4AHsAgQCAAIIAgwCJAIgAigCLAKIAkwCSAJQAlgCVAJ0AnACeAJ8AAAAAAEEAQgBEADoAWQBpAEcARgA+AEkARQAAAGsAkQAAAAAAAAAAAGgAAAAAAAAAAAAAAAAAYwAAAAAAeQCXAEwAQABaAAAAXQAAAAAAVwBYADUAPwBtAHAAjwBqAFMAOwA8ADgAOQA3AFEAAAAAAKAAZwAAAEMAVQBWAAAAAAAAAEoAWwBcAF8AbwB+AG4AfwB8AIUAhgCHAIQAjQCOAAAAjACZAJoAmAAAADYAPQBIAAAAAAAAAEsABAJCAAAAQABAAAUAAAAmADsAWgBfAH4ApACvALQAuQDRANYA8QD2AP8BUwFhAXgBfgGSAsYC3CAUIBogHiAiICYgMCA6IKwhIiLF//8AAAAgACcAPABbAGEAoAClALIAtgC7ANIA2ADyAPgBUgFgAXgBfQGSAsYC3CATIBggHCAiICYgMCA5IKwhIiLF//8AAP/eAAD/wQAA/58AAAAAAAAAAP+6AAD/oAAAAAD/Vf7vAAD+y/1w/WHgKAAAAADgGOAP4C/gHOAB3xzdhQABAEAAAABKAAAAhAAAALwA0ADUANoAAAEEAAABNAFCAAAAAAFAAAAAAAAAAAABOgE+AAAAAAAAAAAAAAAAAAAAAAABAE0ATgACAAMABABSAF4AVABgABoAGwCjAE8AIQAiACMAJAAlACYAJwBmACgAKQAqACsALABlAGQAUAAtAC4ALwCkADAAMQAyADMAowBPACEAIgAjACQAJQAmACcAZgAoACkAKgArACwAZQBkAFAALQAuAC8ApAAwADEAMgAzAGEAbABiADQAaACpAEQARQBGAGMAVwBaAAsARwBIAKsArABJAFkASgBLAKoAWACwALEAsgBMAG0AbgBvAHAAcQByAGsAegB8AH0AfgB/AIQAhQCGAIcAtwChAJEAmACZAJoAmwCzALgAaQBzAHQAdQB2AHcAeAB5AHsAgACBAIIAgwCIAIkAigCLALcAogCXAJwAnQCeAJ8AtAC4AKAAagBTAK8ArgA3AFEAWwA4ADkAXAAEAkIAAABAAEAABQAAACYAOwBaAF8AfgCkAK8AtAC5ANEA1gDxAPYA/wFTAWEBeAF+AZICxgLcIBQgGiAeICIgJiAwIDogrCEiIsX//wAAACAAJwA8AFsAYQCgAKUAsgC2ALsA0gDYAPIA+AFSAWABeAF9AZICxgLcIBMgGCAcICIgJiAwIDkgrCEiIsX//wAA/94AAP/BAAD/nwAAAAAAAAAA/7oAAP+gAAAAAP9V/u8AAP7L/XD9YeAoAAAAAOAY4A/gL+Ac4AHfHN2FAAEAQAAAAEoAAACEAAAAvADQANQA2gAAAQQAAAE0AUIAAAAAAUAAAAAAAAAAAAE6AT4AAAAAAAAAAAAAAAAAAAAAAAEATQBOAAIAAwAEAFIAXgBUAGAAGgAbAKMATwAhACIAIwAkACUAJgAnAGYAKAApACoAKwAsAGUAZABQAC0ALgAvAKQAMAAxADIAMwCjAE8AIQAiACMAJAAlACYAJwBmACgAKQAqACsALABlAGQAUAAtAC4ALwCkADAAMQAyADMAYQBsAGIANABoAKkARABFAEYAYwBXAFoACwBHAEgAqwCsAEkAWQBKAEsAqgBYALAAsQCyAEwAbQBuAG8AcABxAHIAawB6AHwAfQB+AH8AhACFAIYAhwC3AKEAkQCYAJkAmgCbALMAuABpAHMAdAB1AHYAdwB4AHkAewCAAIEAggCDAIgAiQCKAIsAtwCiAJcAnACdAJ4AnwC0ALgAoABqAFMArwCuADcAUQBbADgAOQBcAAEADwAWA1ICwAA9AAABJjU0Nz4BMzIWFx4BFRQGBw4BIyInHgEVFA4CIyIuAjU0NjcGIyImJyY1NDY3PgEzMhYXHgEVFAc2MzICLw4mFDEaID4aGhoSExQyGh4eERIpR141Nl9HKRMRHh4aMRQmGhoaPyAaMRQTEg04RkYB+yEfOCgTEhoaGj0gGjEUFBIMHUIkNV9GKSlGXzUkQh0MEhQoNyA9GhoaEhMUMRoiHiAAAgAeAGQCGQJrAIAAhwAANy4BNTQ2Nz4BMxc1JicuATU0NjceATMWFzQ1NCc+AzM3MhYVHgEdATIzMj8BNT4BMzIWFxU2MzI3NjMyFxYVFAYHLgEjBxU+ATcjNjMyMzIWFw4BDwEOASsBDgEjFhczDgEjIiYnLgEnNSMWFx4BFRQGIyImJyYnLgEnIiYnIzc1Bw4BFTNIEA8NCwcSCDkjJh0XJR0BAwIcHAIBDhASBhAPEwEBCwsMCwMFJRMRGwUODg8OBQ0TDAoQERYjEAwMFw4BBQUGBhIaAgICAgEEDBUZDhUJAQUYDhUZGiwDAwMCNQMJAQEXEQwaCBEFBAMCBgwHMOU0AgI38QwfEA4ZBwQDAzoFCgghEhQhBgwFCAQSExMUBwsIBAELEQ4cDhoCAVAMDw4PRgIBAQkRFBMoCAQCAUUBAgIBDRMFEAYFFB4BASIoIB8gFgkVCikiJQYHBhYTCQUIGBUqFgEBbz4DEB8QAAAABAAy/7oCqgMZAFAAaAB0AH8AAAEeARceARceARUOAQcOAQcOAQceARUeAxUUDgIHFRQOAiMiJicuAycuAzU0PgIzMh8BNDU0NyYjIiMuAzU0PgI3PgE3NhMUBw4BBxU+AzU0LgInFhUUFRYXFgUWFzUuASMiBhUUFgMUHgIXNw4DAU8qKgVDdC0KCgEYDwsnCw5PMgEBOV1CJDJLViMFDBUQChwLBgoHBgIvUTwiIDE7GxcdBgEFBAQDUF4zDzZRXikCAgIBoQMHGhEaLiMUFiQvGQEZGwP+9B8zFCgRFRsXFxglLxgEHDIlFQMZAjs2ARYLAgoREhUGAgcCAgUEGDEZBxUqRzg4TDMbBhgOHhgPCAUDFBsfDgknMjYaJC8bCwMBCQkJCQECDBkpHy5CKxoGGjQdEv30CQMHEAYyBhIXHREOGBQQBg0NDA0KDgNYDgNLBQkRFgcSASsGCgcFAksDCQsOAAAABAApACwCqgK6AEAAVQBiAHIAABMyFhc+ATc2MzIeAhUUBgcOAwcOAQcOASMiLgI1NDc+ATcHPgE3PgE3DgEHFRQOAiMiJjU0PgI3PgE3EzQ+Ajc+ATMyHgIVFA4CIyImNxQWMzI+AjU0JiMHAQ4BFRQWMzI2NTQnLgEnN98aOxUzaScMDgoYFQ8CBR06QEcpJlAoBhMKCxcUDQxUi0QBAgYCAgMDDhwOGio1HE5WBQ0WEQ0yHLMJHDQqDBwKHTEjFBwtOBxPTl4fHAsYFA0ZDwf+gwoPJx0VIgEOGw4DAqgrIwYtIwoNFBcKCAgFJExUXjczajEHCQwSFgoRDFG8YwEEBwQDBwMDBQIKITYnFlNBEh8eIBQPDgT+KxMxLiQHBQQfMDscITcoFlVHGiIKEhcNGyUBASYLHRcbHCEZBwQCCgURAAAAAAEAIgISAOIDNgAdAAATMh4CFRQOBCMiJjU0PgI1NC4CNTQ+AlokMyEQFyMqJRwDCQsQEhARFBEDDBYDNh4qLxEaLCMaEQgNCRAWEg8JExATIiYGFRUQAAABABH/ewEXA3MAGQAABQcnLgM1ND4CPwEWFw4BFRQeAh8CAQ85LSw6Iw8QJD0tICUFNjQOHi0fCgZWLxYxio2BKUJtbXxTBRIjXtBzLXV1Zh0LCgABAA3/fwEkA1sAHQAAFyc3PgU1NC4CLwE3HgUVFA4CDwFGKAgbKh8VDQUJGSwkMho2UDkjFAcGHDo0F347LxZGVV9cVCAuW1FEFyA6CTNGU1JLG0WenpI6AgAAAAH/9QE2AUcCmwBJAAATHwEHDgEjIiYvAS4DJwcGIyImLwEOAQcOASMuATU0Nz4BNy4BJy4BNTQ2Nz4BMzIWFzQ2PwEXHgEVFBUUDwEOAQc+AT8BHwHZXgMTCAgEAwkGBgUJDRQQBAUWGRECAwsRCgYVCxwPCAohHAshGwgCDhUJCgYHFh0FCEEOCQ0CAgIEAgkWESEgBQHnTxodBAEBAwYECQwRDVAXCg9FChEMCQgRGQ4TDAobFAUWEQgIBAgXFwcEDhcHGB0XBAUOEQIEBAYJBg0IBAkHDxUkAAABACQAqQGsAicAQgAAAT4BNzYzMhYXFhUUBgcmIyIGBxQWFxYVFBUUBiMiJicmJy4BNSInLgE1NDY3FR4BFzU0Jic1PgE7ATIWFxYVFBUUBgEkFCsXBQgHEQgFDg4jFgcVHgYKAhkSDRoIFAYGBTEyFhMiHA0xFAEBBSkODg8ZAQEBAawDAgMBBggNFxQtCAcCAhcxGwQEAwIUEAcDBhUaMxoUCCQSFCYIFgYJAS4GDAcjDQ0JEQkKCQoPHgAAAAABABb/cAEKAMgAIwAAFzI+AjU0JiciBwYjIi4CNTQ+AjMyHgIVFA4CIyImJygWLCMVDQkLBRAWCxcSDAcYLSYnMh4LFig5IxssC1wPGycXDxADCBAKDxQLFSskFis5Og4iPjAcFx0AAAEADwEaATsBsgAhAAATPgEzMhYXFhUUBgcmIyIOAiMiJicuATU0NjcVHgEzMjbKEikVCA8FBQwNGREJICQlDhIlExEOHhoSIBEPIAGSBAUHCA0WEysLBwQFBAwKCCQRFCYLGAoGBQAAAQAe/+kA5ACtABEAADcyHgIVFA4CIyIuAjU0NoMTJBoQEBoiEhQmHRE4rRAbJBQTIxsQDRghFC48AAAAAf/P/68BwAMFACcAAAEOBQcOASMiLgInJjU0Nz4BNz4DNz4BMzIeAhcWFRQHAXgUMzk7NiwOAxEODBwZFAQDASM/GyZAODIZBQ8LDSAdFgUGAwI7IV9ud3VtLAgRDhYaCwkFBQNGezVJeHJ0RQ0IChASCQsIBgYAAgAfAAACnAL3ABMANQAAEzQ+AjMyHgIVFA4CIyIuAjcUHgIzMj4CNTQmJx4BFS4DIyIGBw4BByInDgMfN117RD5tUS4xVnRDPnNZNXgeNUkrK0kzHR0jBQcVMDAvEw4aDAIEAxYGCxgWDgFyUY5pPT5nhUhNjWtAO2WGVixUQScqSF0zOE8iFTorHDUqGQsGAQIBDRAuOD4AAAAAAQB4//YCdwL6AEMAAAUuASMiBgcGIyImJy4BNTQ3HgM7AS4BJwciLgInLgE1NDY3PgM3PgEzMh4CFx4BFx4BFT4BMzIWFx4BFRQGAloXIxAaNBo1NyE5IR0YHgoTGicfFgIGBFcSGxUSCAQCAwkPMjAkAwkeEQohIRsDAQYDAQEdQSYIDggGBQ4EBAIEAgYHCworFyIWBwgEAWLBYh8PFRYIBQoHBQwKBxkjKhgUEAYMEAp6+HsWLxgCBQMFCxwOGDIAAAEAGf/pAqMC+QBPAAABPgM1NC4CIyIOAgcUBgcGFQ4DIy4DNTQ3FT4DMzIXHgMVFA4CBx4BMzI2Nx4DFQ4DIyIuAiMiDgIjIiY1AWgMJSQZDxYaCikzIxYLAgEBAwcNFRARFgwFAgUvRlMpGA8jRjcjO1VeJBI6MzdjFw4SCgQSMzo+HSE7OjsgEh8fIxUXIAGGDSszNRUNGBMLDBUdEAIKBgIDChQPCgERGBsNFwgBL0AnEQMFIDRJLzNmY18tCxAfIgMSGBwNGCkeEAgKCA8RDyQYAAAAAAEAVgAAAmYC/wBgAAATBgceAxcmIyIjIg4CIyImNTQ2Nz4BMzIeAhcUDgIHHgMVFA4CIyIuAjU0NjMyFhceATMyPgI1NC4CJw4BIyIuAjU0PgIzMhc+AzU0LgIjIgbgCgQEEhYYCQsJCAcQEQwMCigiIyAgNiU4alMzAgkPFg8VHRIINFFkLz1dPiALGQofDhtRNxEuKR0EDBURHUIfIDYpFy46NQczNgwSDAYdLzkcEikCbwQBBhEUEwcBAgICMCMmRQsLCxQxVUEQJykoDw0dJzYmRVcyEic4PxkmJA4WKjEKGCYcDxUSEAkKCA0XHxIfJRMGDgMXHB4KGyETBwYAAAAAAgBB/9cCUwMEAEoAWgAABSIuAicuAz0BLgMnLgE1ND4CNz4BMzIWFRQGBw4BFRQXHgMXNDY1ND4EMzIeAhUUDgIHFB4CFx4BFRQGBxM0JicOAxUUFhc+AwHfDiAcFgMCBQQDIVJQRxcHBRAbJBULDxAUFw8FERUHDC0yLwwBAQUNFiIZJzMcCwUSJB8CBQkIAgMTFxUDCwMGBAIBAQcLBgMpBgwRCwonMzseHgEKFyYcFysXJlNSTyERDBsVFC0NLGMtJRsJDgoFAQQSIh5PVFE/JzRTZzMwSTkrEA8xOTsZBQgFECcJAfA0aisTNz4/GhIdCAQVGBgAAAAAAQA2AAIChQL9AHEAAAEyFhcjHgEXDgEHDgMjIg4CBw4BHQE+ATMyHgIVFA4EIyIuBDU0NjMyHgIXFA4CIyImJy4BIyIGFRQeAjMyPgI1NC4CIyIGByIGBw4BIwciJic1LgE1NDY3LgEnPwE+AzcCLAgQCAEUFQIIFgsJIysvFg8fKz0uBwUVOSM0blg5HTA8PjwWGUFFQzQgQjEWOT8+GwgPFQwLFQgNMxcUHCg1NQ07RycNJDxMKBUlFAMIAQwXCRAKFRMEBAcJExoHHCcqdHduJQL9AggOOB4IDgIBAQIBAQIBARE4Gg4DBBQ3ZVEvSzkoGQwLFyMuOSI6OwILFhUPHRcOBQoPDwsLFx8UCSIwNRIiKxYIAgECAQkIAggOFhs0Gh0/IQ4vFxYIAQIDBAQAAAACAD3/zQJ+AwoAQQBNAAABFA4CBx4BHwEUDgIjIiYnDgEjIi4CNTQ+Ajc+ATMyFhUUDgIHDgEVFB4CMzI3LgM1ND4CMzIeAgcUFhc+ATU0JicOAQJ+GS9DKgIEAQENFh0PECAKDyIRNkwxFiNDYD0OJQ4UGB0mJwkzPggQGRILEAMFBAMaNVI4JDUjEdQCAh8sEQYZHwGDJ1JRTiIFCgYKESEbEBUYBQIoRFoxSpSIdSwLDhIXFCsrJw5MvGESLCYZCAwrLSkLLmpbPB8wPIoMGQwhUSkkHgIjWAAAAQBAAAQCewL7ADcAAAEuAScOASMiLgI1ND4COwEeARceARcWNhc+AzMyFhUUBgcOAQcGAgcOAyMiJjU0PgIBn0KGQgYQEAoRDQcPGB0OCCZJJSRIJgsOCQYOEx0VGiYJEg0XCUlQDAIPFhwPHSscMD4CSAgPCw4WISglAwwYFAwCEQoJDgMBAQIKEw0IKBoTJg8ICgRs/v+BDyIdFCAjPYOEgQADAEsACgJwAwEAJQA5AFgAADc0PgI3LgE1ND4CMzIeAhUUDgIHHgMVFA4CIyIuAiU0LgInDgMVFB4CMzI+AgMiJw4BFRQeAhc+AzU0JicWHQEuAyMiBgcGSxkrOSA8RylFWjI2Y0osFiU0Hh40JxYnRmE7QGhLKQGaHCoxFh0xJhUTJz4qDSglGtcOBg4HFCEtGBwzJhcXFAQQJycjDQMNAgjiHTIrJREfTzEvTTYeHjZIKh0wKCAODB8rPCoxTjYdHzlQJBgpIhoLDRseIxQPHhcPCBIbAa8DESwJCRgaHA0PHRwbDg8mDgkPPQ4gGxINAQUAAgBc//kCUAMNACUAOwAABS4BNTQ+Ajc+ATcOASMiLgI1ND4CMzIeAhUUDgIHDgEjEzQuAiMiBhUUHgIzMj4CNz4BNwECDQQHCw0HK0cXHUcuLUMsFjZSYi02UzcdI0JgPA4lELgQGR8PSE8IEBgPISkbEgoCEhoFBhALBxYZFwgydUMbJSc+Tyc/Z0koKERZMEqTh3YsCw4CMBsqHQ9QWBAjHhMMGSUZBhMIAAIAMgAsARICWgARACIAADcGIyIuAjU0PgIzMhcWFRQDBiMiLgI1ND4CMzIWFRT0IC4XKiATER4qGSwgIh4cMhcqIBMRHioZLz9SJg8bJxcZKyASICIsLAEwIg4bJhcZKyASPjIsAAAAAgAs/xwBIAJqACMANQAAFzI+AjU0JiciBwYjIi4CNTQ+AjMyHgIVFA4CIyImJxMyHgIVFA4CIyIuAjU0Nj4WLCMVDQkLBRAWCxcSDAcYLSYnMh4LFig5IxssC3AWJx4RER4mFRcqIBM/sA8bJxcPEAMIEAoPFAsVKyQWKzk6DiI+MBwXHQMaEh4oFhUoHhMQGyUWM0MAAAACABL/rgHlAxAAOgBMAAATBiMiLgI1ND4CMzIeAhUUDgQHFDsBFw8BDgEjIi4CNTQ+BDU0LgIjIg4CFRQWFxMyHgIVFA4CIyIuAjU0NrAfGBcmGw8tRVMnK1RAKBsqMSsfAh0cCBUPCxEFFzEpGx0qMyodCBMeFQUpLCMSFVUQHhcNDhYdEBAfGA4uAi0OEx4iDyI1JRMdNUcqITs3NTY4Hxk1GwUEAg8eKxwkRUE7NC0TCRYSDQEFCAYJEAv9+Q0XHhAPHRcNCxUbESQyAAAAAwAcAB8CfwLoAFEAXQBtAAATND4CNzYzMh4CFRQHFjMyNjU0LgIjIg4CFRQeAjMyPgI3PgEzMhYVFAYHNQ4DIyIuAjU0PgIzMh4CFRQOAiMiJw4BIyImNy4BJw4DFRQzMjcGHgIXPgE1NCYnLgPDEi1KOAoIGSMXCw4DBxsRHTNDJS9QOiIdN08yETEzLw4QGAkUFwECFkZNTBxFdFQvN1x2PkxrRSALHTMnIh4RLhxPULoUFAEIExALQxEWAwQKDQYCAgEBAQoLCgGLFDQxJQYFGi08IysoAiwnQFw8HSNCXjszW0QnBw8aEgkHFQ8CBwUCLzceCThhhU5CfWI8OWKBSBI0MCIOERJiAiNVJwUOExkQWrMUKSUgCgkXDA4YCQwRDAcAAAAB//j/ngEPA0EAUAAABzQ2NxEuATU0Njc2MzI3PgE3Iz4BMzIWFxYXFBYdARceARUUDgIHBiMiIx4BFRQeAh0BMhYzHgMVFAYHBg8BDgEjIiYnLgEnLgEnLgEIGRQQGBsYAgQFBQQJBQERNSEGExcHBAECCBEPFxkJCwsKBgEBAQEBBQ4JChkWEBIJAgIJFBUGIzIQAgcCCA0FGRkhFRsJAq0JGxcdEgIBAgECAQQFBAUHBgEBAQECCxoQChMPCgEBETYkPJSTgisVAQEKEBMJExsLAgMKBwMFBAEBAQICAQIQAAAB/8//rwHAAwYANgAAAy4BNTQ3PgE3PgM7ARcjHgEdAR4DFx4BFxYVFAcGBw4DIyIvAS4BNRcuBSczLgIBAQECAgQYHiANBwQDCA0ZMzg/Jhs/IwEDAgQGExYYCwUCBwgOARMyNTk1MBMCArEDBwIGAwIFAwkTEAoCAgYLBD5ydHxJNXtGAwUFCQcFCRYSDAEBAwwNBTFwdXVrWyIAAAAAAQAC/50BGQNAAEQAAAEUBgcRHgEVFAYHDgEHNwcOASMiJi8CLgE1ND4CNzYzMjM1NC4CPQEiIyInLgM1NDY3PgE3PgEzMhYXHgEXHgEBGRkUEBkaGAUNCAIXECgiCBUUDgEIEA8XGQoLCQoGAQEBBwcGCQoZFg8PCQIIAhgUByArEQscBRkaAv8UGwn9UgkZGR4QAgECAgEEBAUDBxABCxoSChMPCgEBajyVk4IrFQEBChATCREaDAIMAgcDBQQCBAECEgAAAAABAAkBoAFDAnsAMQAAAS4BJw4BBw4BIyIuAjU0NjceATMyNjc+ATc+ATMyFhceARceARc1FBYzMhYVFA4CAQkaMhQFCgUOHxYRGhQKDRIWCQIFCwgCAwMEKRYUJQcCAQECBAUKBR0cBw8VAacBDw4FCAQIDA8YGwwLGhYLAw0JAwYJGR8VGgUHBAUMBQEBAiUWChcUDQAAAAEAAP+mAU//+wADAAAVNSEVAU9aVVUAAAEAFP/2AkwCwAA0AAAlHgEVFA4EIyIuAjU0PgIzMh4CFx4DFRQGBw4BIyInBw4DFRQeAjMyNjcCLg0RHDA8QkAbNWRMLjhpl18PJyUgCAYJBQIEBREfDzomXR06Lx0XKz8oI1U3rgseFxglGxIKBD5heDtPimU6AgkREA0PDQ4LDhwSCAo+GgghOE82GkI6KBgSAAABADL/yALgAuAARAAAEyY1NDU0Njc2MzIzMh4CFRQOAisBBgcjIiY9ASY1NDceARcuATU0NTQ1ND4COwEeAR0BHgEzMj4CNTQuAisBBzQCMzMSCgsRbsGPUkVuiUQMCysQJiKGGBEvIAEBDh0qHQ4IAhUwDx5EOiZMfqNXGCwCcgYFBgUjKAsCQnakYj9sUC0aGCcpCFZUKScXIg8ILxoaFhcIO1MzFzNcM+wJAx4tNRhJe1oyKgAAAQAe/+4CRAK6AGoAACUWFRQHDgMjIi4CNTQ2Ny4BNTQ2Nz4BPwEuAzU0Njc+AzMyFhceAxUUDgIHDgIjIgciIyIHDgEVFBceATsBFx4BFxYVFAYHDgMjIgYHDgEVFBceATMyPgIzMh4CAiUBCBI6SloxK0UwGhMIBhIDAgsZDiASLSYaGRcfRFFiPg4lIQgaGhIVICMOICoiEA8UCAcHBwQLAwEJC5QcCQkCAQYKDS47RiUDBgIIFgEBCgsSPEZKIAkTEQuUBAcOBRAuKx8gNUQkIE0oDxgVCA4KBQkCbggTFhwSDgkCAQ0PCwUJCBcbHA0IDgwIAQICAQECBRoXDhAGDgQLIQ4FCwsUAQECAgECBhtFIAoFCAwUGRQLEhUAAQA0//oCogK8AFIAADcOASMiJicuATU0PgI3LgEvAS4BNTc+AzcyHgIXFhceARUUDgIjIiYjIg4CBw4BBzI+AjceARUUBgcOASsBIg4CBw4BFRQWFRQVFOgYLxESGggLBwgRGhMnIwgCAwUCNGJiZjg7QSIPCQIEDgwSHiYUGjAODh4nMyIPEwZaZDQUCgsHCA4dMhc0EiAhIxYIBQEIBggLDw8zJiJabHtBBh8RBggUCg4EDA0MAwEECAYBBAsfDg4SCgQEAwYKBx1DJAECAQILGQ4PJhEDAQEECAceSCYcNhgIBwcAAAEAEv/6ApYCwgBGAAABDgEjPgE1NCYjIgYHDgMVFBYzMj4CNTQuAiMiBgcuATU0PgQzMh4CFRQOAiMiLgI1ND4EMzIVFAYHAioSLBgJCQoOCRsSNFpDJ0tREkJAMBQdIA0qOxchDRwtOjw5FiI1JRQxXYhWTGpDHylCV1xaJpYMDAIADAoRGwgGCgUFDDBIXztCRggdODEKCwYBKykKHBggLB4QCAIWJC8ZRGlIJSJFZURBdGJNNx1kFC4YAAAAAAEAAv/+AkoCzgBlAAABNjczMhYXFBUUFxQWFRMUFh8BHgEVFA4CBw4BIyIuAi8BIw4BIyImJx4CFRQVFA4CByImLwEuAzUuAScuAzU0Nj0BHgEXEzc2MzIeAhcUBgcOAR0BHgMzMjY3AYwJJRwMLRECAg4HBQEFBgEECQgOFAwLGxgSAggGFCEPFTIjAQIBBA0ZFBQjFxADBQMBEiwIAgQDAwIbLxIOIBIWBxUXFAUCAgMHEBkbIhoOEQ8CliMVBggJEA8SCxkO/wAdMxoFGzYeCx8fHAkFBQcOFA2cAgIDAxIwLxMTBw8RCQUCBxE6CC0zLgoIKRcFGB0eDAMDAhIRFAUBChAGAwUIBAwMDBpiPlwDBAIBAQMAAAAAAQBU//4A8gLQACIAABMeARceAxUUDgIjIiYnLgMnND4CNzY1ND4BNz4BfjYxAgIEAwIFDhgTDCAMCg4KBQEBAgMCAQMJCQIEAtACPTk9iIuIPAwZFA0HBQMcIyAIGCswPSwPISJieUUIBgAAAQAi//wCWgLCADwAABM+ATMyFhUUFRQHPgM3NjMyHgIdAQ4DBx4DFx4BFRQHDgEHLgMnFw4BIyImJy4BNTQmPQFICRMGIy0CMUtCQScHCwggHxccPkZMKgUrRFk1EBAGBhcXPGFUTikKEikVDx0OBgQMArQIBnNrDgoJERIqO1A5ChQbGgcEN1JCOR4JJjI6HQkoFBINDxsCFDlBRiLeDgwDBRUrGFuuV9gAAAEAKv/eAeoC2AApAAATMhUOAwcVFBYzMj4CNz4BMzIeAhUUDgIjIi4CNTQ+Ajc+AfIsARQcIA0NCQolLTEXFzQPBwkFATtVXyUyQycQHCcsEQkkAtgsNlpqjGgIDhQIDhAJCBcLDxAEIEtAKyxEUiY4j4t1HxESAAEAJP/iA4kCzABuAAATNjc+AzMyHgIXHgEXPgUzMh4CFx4DFRQOAisBIi4CJzUuAzU0NjcOBQcOASsBIi4ENQ4DBw4DHQEUDgIHIyImJy4DNTQ2Nz4BNz4DMzIeAtwBAgchM0MnFBkPBgECBAMHGigzPUYnFiUcEQEBBAMCAwkPDAYlLBcHAQEBAQEDAxguKSQfGgoFIA8BGiceFA0FEiAcGQoLEAsFAw4cGQYUHAoFCQYECwsCAgEGCxIeGBUZDgYCKAEEDDU1KRssOB0wUhQRNTs7Lx0UHyUQDkBWZDM2Z08xMUA9DQMNMT9GIS1ICwo5UF1bUxwODkJmeW5UDQskKy0VFiw3SDMOHjUoGAEYIBBDS0gWPn01BQsFGiwfEhwmJwABACIABAJyAxQARwAAATQ2MzIeBBUUDgIjIi4EIyIGBw4FDwEOAyMiLgI1ND4EMzIeBBceATMyNjU0LgQvAQGGBg4OKzAwJxgVJzklHTo3MCgdBwMIAwICAwMDBQIBAggNFQ8YHhIGCBEYHiUWDycuMzY2GwYGAgkDBgsQFBcMBgLqDB4gO1VqfUUuX04xN1NgUzcKDAYoN0E+NQ8HDB4bEiQyNhIaWmlsWDcmP1FVUiEGChoaLkk/O0BKLxgAAAADABT/xgLMAsIAIwAzAEcAADcuATU0PgIzMhcWFRQGBzMyFhceAxUUDgIHDgEHLgE1ASIOAgczMj4ENTQmJz4BNw4BBw4DFRQWFz4DN2ApI0Bqi0tCKDIeDgQhRyANFhAJWpC0WgYgEh4eAawoRDw4HBoaQkRBMh8sgRIiEx5DGz9bPBwDBSA/QkkqTkSAPFCJYzgRFBMMDAIRFQglLjEUXJhtPwQSHREnRRgBrC5VeUoTIzE6QiMgIGsFCAIDEAkPQFRfLg8eD1KAXToNAAAAAQAW//wCxALEAF8AAAEUBw4BIyIuAiMiBhUUFhceATMyPgI1NC4EJy4DNTQ+BDMyFhceARUOAQcOAQcOBRUUHgIXHgMVFA4EIyIuAjU0PgIzMh4CFxYB8gQMQCYFJDI2FxceGhUXPiMrWkkuIDNBQj0VVmc2EThWZVg+BUuDMgsLAhkRDCoMDkpfZ1Y4NEhNGEh3VS8pP05KPhBAdFg0IjZAHhxBQ0MfBAECCQQNHg0RDRMYCBQJCQoPHSocEx4YEgsGAQIOGy0iMkgwHA8EFw4CDBIUFwYDCAICBQcJDxUOCwwJBQMJFS1RRDRNNiIUByc8SCEnNB4MCBEZEQQAAAIAAP9iAmQDBAA5AEkAAAUOASMiLgInLgM1ND4CNy4BNTQ+AjcyHgIXHgEXPgMzMh4CFRQOAisBDgMVFBYTHgEzMj4CNTQmIyIOAgFMDhMXDhwYEwYMDQgCCQ8VDWdpBAkQCwoGAQIFM2k+DSQvOyUUMCocNUpPGgwNEwwGDFAIDwkMHRgRCAwPIRsSigwIDRQXChQzNjYXQGlaTygpYDsKGxoVBBAVFQQqIwkNKCccCiFANys0HQowWVlbMTtvAroCAggOEgoLCwcQGgAAAAABADL/+AKUAvAAOgAANy4BNTQ2Nz4BMzIXDgEHDgEVFBYzMj4CNzYzMhYXHgMfARUUBiMiJicuATU0Ji8BDgMrAS4BTA4MYV8GEQUWBh0yEAQFGSciNC0rGiQaCBEJGSEWDAQKHiAOFg4MDAUFCBQ4RVItAjlMWi1ZKnrudAUFKF+7YhguFDA4Qm+OTVgWGkNtW04jYhQpKwUDESUSGjsdUEZkQR8CLgACABT/8AM/AxMAUgBiAAAFIi4CJw4BIyImNTQ+BDMyFhceARUHDgMVFB4COwEuATU0PgIzMh4CFRQGBx4BMzI+AjU0Jic1NDY3MzIeAhceAxUUDgIDNCYnDgEVFB4CFz4DAdoaNjMuEBMlEVdlJTpHRz4TCRIICAUCJ08/JwYQHhcPCQ4eOVIzHi0eEEtFDBgKNE82HD5IBgcSCRQeKyAfLBoMKFeHgwgHFyMBAwUDDRYQChADDh0ZBQNrXT52aVg/IwICBA8LISdZZHE9ESYfFCNKIyxXRiwYKTYeUH82BglKa3YsT4xEDgsUBQMNHBkZR1JcLlOXdEQBhQ4UCA0wKgYWGhkJCSUsKwAAAQAo/8ICegLSAEsAABMuAycuATU0Njc2Mx4BHwE+AzMyHgIXLgEjIgYHDgEHHgMzMj4CNx4BFRQOAiMiLgInDgEHDgMjIiY1NDY3PgHOHCgjIRQGBAQGMUMMFwtQETk/QBkNHRoUBAYlCRcyGxgrFxM1NjIQDRMNCgUIBgsXIhYQJzhPOR0lCwgjKioPCwcFBRRLAWwmOzk8KAgTCwsRBiAMIReQGEE8KQ0gNyoKCCcXFz4pHU1HMQMLFRMYNhgfNikYHj9gQ0RhIRkgEwgaEhEjDk6jAAAAAgAT/v8ClgL3ADgASQAABQ4BIyIuAjU0PgI3LgM1ND4CMzIWFRQOAhUUFz4FMzIeAhUUDgIHDgMdARM+ATc2NTQuAiMiDgQBFwkUESYwGwsECQ4LFi4lFyU0NhIPHBUZFSULISo0PEIkL0AoEjZefkgIDQkFOy9OIysDCRANCyAjIh0T+gIFJDlJJB03PEYrCSYyNxk4dmI+HBYWOUFHIywgJFteWUYqJzpEHkKCa0wNMFZYYTsfAjMVQy03PQoXFA4pQExGNwABABYACAJyAswAQgAAJQ4BIyInLgE1NDc+AzcOASMiLgI1NDY3HgMzMjY3PgEzMhYfAQ4DBz4BMzIzMhceARUUBisBJiMiIyIGAYQ1ZTIsMB4iFiheX1kkGDMVJWJZPgMDKEpFQyInUC0IEQkaJwMECUBaazQ+dj4ODA0PJCIlJwQLCwsLHTcaBQ0GBigYGxk0YmNmOQgIDSA2KQgVCwINDQoPFwMFIR0mSXtuZTEFEQICKxsbLwIHAAAAAAEAEwD3AfIBwwAoAAABDgEHBiMiJzMuASMiBgcuATU+ATMyFyMWMzI+AjUnLgEnHgMVBwHsEx0IGTA5RgEgKQoVHhEfJBs+MyhNAUMQCBQSDQMCCQgTJhwSAQFhGyQIGSUQESgoFSkXNkEtJgcKDgYGBRIRBhIUFwwFAAADABb/1AJ7AIIAEQAjADUAADcyHgIVFA4CIyIuAjU0NiEyHgIVFA4CIyIuAjU0NiEyHgIVFA4CIyIuAjU0NnARHxgODhcfEBIhGg8xAQMRHxgODhcfEBIhGg8xAQQRHxgODhcfEBIhGg8xgg4YIBIRHxgODBUeESk1DhggEhEfGA4MFR4RKTUOGCASER8YDgwVHhEpNQAAAAEAEwLBAU0DmwA1AAATLgEnBgcOASMiLgI1NDY3HgEzMjY3PgE3PgEzMhYXHgEXJx4BFx4BMzIWFRQOAiMiJicmvgMGAw4TERsWDhYPCQgLEAsFDREKBwYGBCEREBwGAgMBAQIHCAIXChYVBQsQCxg3EAMC6wIFAhENCwoNFRkLCBMQCAMQDggQERQZERIFCQYCChQLBAceEwkUEQsTDAMAAAAAAQAxAYkBJQLhACMAAAEiDgIVFBYXMjc2MzIeAhUUDgIjIi4CNTQ+AjMyFhcBExcrIxUNCQsFEBYLFxIMBxgtJicyHgsWKDkjGywLAq0PGycXDxADCBAKDxUKFSskFis5Og4iPjAcFx0AAAAAAgAxAYkCRwLhACMARwAAASIOAhUUFhcyNzYzMh4CFRQOAiMiLgI1ND4CMzIWFyEiDgIVFBYXMjc2MzIeAhUUDgIjIi4CNTQ+AjMyFhcCNRcrIxUNCQsFEBYLFxIMBxgtJicyHgsWKDkjGywL/tQXKyMVDQkLBRAWCxcSDAcYLSYnMh4LFig5IxssCwKtDxsnFw8QAwgQCg8VChUrJBYrOToOIj4wHBcdDxsnFw8QAwgQCg8VChUrJBYrOToOIj4wHBcdAAIAMQGJAkcC4QAjAEcAABMyPgI1NCYnIgcGIyIuAjU0PgIzMh4CFRQOAiMiJichMj4CNTQmJyIHBiMiLgI1ND4CMzIeAhUUDgIjIiYnQxYsIxUNCQsFEBYLFxIMBxgtJicyHgsWKDkjGywLASwWLCMVDQkLBRAWCxcSDAcYLSYnMh4LFig5IxssCwG9DxsnFw8QAwgQCg8UCxUrJBYrOToOIj4wHBcdDxsnFw8QAwgQCg8UCxUrJBYrOToOIj4wHBcdAAABABQBEADTAc4AEQAAEzIeAhUUDgIjIi4CNTQ2dBMjGg8PGSISFCQbEDYBzg8ZIxQSIxoQDhghEio7AAABAAUAyQINAVQAJQAAExQWMx4BMzI+Ajc+ATcyFhceARUUBgcuASMOASMiJicuATU0NlIBASJCIA0gMUk3ChQLCRIIBQYQFBMqDjRuNCJFIx8aKgFUBAcIBwEDBAQBAQEDBwgWCxQsCAMDAwgHCgkkExYiAAEAEQDJAvwBWQAqAAATBhUUHgIzMj4CNz4BMzIWFx4BFRQGBy4BIyIGBw4BIyImJzMuATU0NmwDHCkvEyVAPT8jLWQ+CxMLCAgWFyE1FydNJyhPKjNjMwEqIzEBWQUECAoEAQECAwIDBQIFCBgMFSsIBAIEAgIDBgoIJRQVJQAAAQALAsIBkwOEACMAABMuATU+AzMyHgIzMjY1NCYnHgEVFA4CIyIuAiMiBgczERcHGyMnEhMpJyUQDhgIBygzEyArGREoKSYQERIKAskOHBQoMRsJFxsXCg4KHAsGKh0ZKx8SFhoWGxoAAAAAAwAIASYC+AMCAGAAlQCdAAABPgE3PgEzMh4CFxQVFBc+AzMyHgIXFB4CFRQOAiMiLgInNC4BNTQ1NCY1NDcOAw8BDgEjIi4CJw4BBw4BHQEUBgciJicuAzU0Njc+AzMyHgIXAw4BIyImJy4BNTQ2Ny4BNTQ+AjcyFhUUHgIXNjc+ATMyHgIVFA4CIw4BFRQWFx4BFRMiBgczMjY1AagGExQGHgcNEAkEAQEKHCQpFwwWEAoBAgIBAwcMChQZDQUBAQEBAQsUEhAHDQMVChMbEQkBDBMICgoOIQ4SBgMEAwIFBQQGChMRDBAJBALrCQwOER4HCwYOCzEyAwcLCA0EGCEhCQQDDi0gCxsXEBsnKg4LCwICAQJKChUEBAoVAowUKQ4EDA8ZHxAKCgoJECUfFAsSFQkHHysxGR02KhkZISMJBxogEBEPDg8FBQIMJy8wFSQICDhMTxcMIg8VLzAHIi8BDhQIISYkCyA9Fw8dFw0MERQI/p0IBBoLFDsZOVohFjEfBhAPDQMRCQgODQkDBgMPIwUSJB4YHhAGLVAtDyEPDBYLAYcHCQkGAAACAEoABwD+AukAMwBDAAA3PgE3PgE1NDU0NTQmJz4BNz4BNx4BFx4BHwEVFBUUFxQWHQEUBhUUFRQXFAYHDgEHLgEnEyImNTQ+AjMyHgIVFAZcCw4DAgMBAQYcDwITAgcFAggPBQQBAgICCAwIFhodNQxiIC4NFRwPEB4XDi19J08oHks3CgcIBgcRDhMPBQEFAQUDAQUMDiFREhAPDgwYCyYNHREQEhEWDiMiDhAEBhkXAg0vIQ8cFw0LFBwQJDAAAAAAAgBZAAQCEQLNAFEAZAAAJR4BFRQOAgcUFhcOAQcOAQcuAScuAS8BNS4BNTQ+Ajc0JjU+ATc+ATceARceAR8BMjYzMh4CFx4DFRQGBw4BIyInBxUUFhUOARU+ATcnPgE3DgMVFBYXNTQ1NCc0JgH6Cg0YKDMbAQEGGA4CEAIGBAIIDAUDZGAaM0kvAQUYDgIQAgYEAggMBQQEBwULHh0ZBgUHBAIEBA0YDCsfBAICAhEkFbMBAgESIRkPJjQBAvMIFhASGxIKAwsZFBoUBgEHAQcDAgUQFCsSBGFbLFhOPhILGRQZFQYBBwEHAwIGEBMrAQEGDQsJDAkKCAkUDgUHLAFlEB8PH0cwBQ0Hbh1FLQwoMTofJjUIARcUFRMQHwAAAgAV/8cCFQLnAGoAdQAABSImJy4BJy4BJw4BIyIuAjU0PgIzMhYXPgE3IyImJy4BNTQ2Nx4BNzU2Jic0Njc+AzMyHgIXHgMVFAcuAyMiDgIHDgEHPgE/ATIWFxYVFAYHLgEjIgYHDgEHHgEXFhUUBiUyNjcuASMiBhUUAdIJKBAVLRYRGA8WRy0SJBsRFyMqFBYaDQYIBQYOHhoeGxwZFTYPBQMCBQgLFxocDwgeIB0GChYRCyAHGBkYBw0PCAQBAgQDFC4gDQgTCAwSERckCxQaEggMCzt4LAkp/o8LGwoGCwUJEzkJCgwkEw4SCy0wDxsmFhoxJRcDBBQtFwQHCiMUFSMBBhACAypaLB4zDxQXDAMHCgsDBhgcHQsVGAcSEQsIGCsiFy8XAwMBAgUHERoUKwcCAwMCIUAjHk06DQ0XD4QRGQMBEhAMAAACACgAiwG/AhIASABhAAA3JjU0NjcuATU0NjMyFhceARc+ATc+ATMyFz4DMzIWFRQHDgEHHgEVFAceARcWFRQOAiMiJicOASMiJicOASMiJjU0Njc2PwEOARUUFjMyNjc2NzY1NCYnJicmIyIGB08RCAwPFx4SCgwGBQ8IDiYUDiALJiIKCggKDBMdBQgSCwsNFAUKBQ8KEBIJDxYLFy8aIDIUDBoQGxgJBQhxBQ4SMiwOHw8EDBwLCAkHEREHBwHvJTATMRkKHRcXGQoIBwwDCAwCBwMZBAwMCBoVCQwRDQgXNBkrJQYLBRERCRENCBsJDw0KCwkWFQ4HGwgNhi4LIR8rNwwLCQQcJRIiDQYNDwMBAAACACD/yAHqAsUAXABuAAA3HgEVFAYHIh4CMz4BNTQuAicuAzU0PgI3JjU0PgIzMh4CFRQOAiMiJicuAyMiDgIVFBceARceARcjHgEVFAYHFhUUDgIjIi4CNTQ2Nz4BPwE0Ji8BDgMVFB4CFzc+AawDBhAJARAYHg4sPxgnMhkgPjMfEBskFD8oP08nNUcqEgsRFAkLFAoGHCMkDAgYFxEGBxgdIDwcAUI1Kyc7JD5TLhBDRDMVFhUcF90aH0gOIRsSFSY3IgkXKWQCBgUIFwUDAgIBExUTFxELBwgYIS4eFSwsJg8rPyIzIxISHioYDhQOBxIQCQ4LBgUJDQgIBQYQCwwYDBk/KiRLKiM6Jz0rFgkTHhUTIAsLBgTtDhoLGwgZHR8NChYUEQUJFzIAAAAAAgAdAqgBpgNNABEAIwAAATIeAhUUDgIjIi4CNTQ2IzIeAhUUDgIjIi4CNTQ2AVQQHhcNDRYdDxEgGA8vvBAeFw0NFh0QER8YDy8DTQ0XHhEQHRcOCxUbESYzDRceERAdFw4LFRsRJjMAAAAAAwATAEYCjAK/ABMAPABtAAATND4CMzIeAhUUDgIjIi4CNxQeAjMyPgI1NCYnLgMrAR4DFS4BIyIGByI1NDY3IyIOAgUeARUUDgIjIi4CNTQ+AjMyHgIXHgEVFAYHDgEjIicHDgMVFB4CMzI2NxM3XXxEPWtPLjFVdEI9clk1QSlFWzM0WUAlKioHGBgSAgkMFxILIGMxFR4TAwUBBx8yJBMBawcJITA2FhUzLR4eOFEzCBUUEQQHBQMCCREIHhUyDx8ZEBEbHw8TLh0BeUR3WDM0VW87QXZaNTFUb1szW0UoKkdcMzhRIwUQDwsIDhAXEiMZDgUCAggFLUBGggUQCxIWDAMbLjsgKEQzHQEECQgNCQsHDgkEBR8NBBAcKBsSJBwSEQkAAAAEABMARgKMAr8AEwA+AH4AlAAAEzQ+AjMyHgIVFA4CIyIuAjcUHgIzMj4CNTQmJy4DKwEeAxUuAyMiBgciNTQ2NyMiDgIXLgE1BiMGIw4DIyI1ND8BPgMzMh4CFRQGBw4BBx4BFx4BFx4BFRQGIyImLwEuAScjIgYdARQOAiMiNz4DNTQmIyIGBw4DIwcVFBYXEzddfEQ9a08uMVV0Qj1yWTVBKUVbMzRZQCUqKgcYGBICCQoVEQsPKC4yGBUeEwMFAQcfMiQTlAMBAQEBAQsFAwcLHwMfFh4eIhkPLSoeBAwPJxMZIxACDAMDCAkFCxwISAkfCwEDAgIIEA0MOA4iHRMVDgYMBwQNDAkBAgEBAXlEd1gzNFVvO0F2WjUxVG9bM1tFKCpHXDM4USMFEA8LBQwSGRISFw0FDgUCAggFLUBG2UeNSAEBBQUDARkGAxQLEAoFCBIcFAgkDxQdERcmFQISBQcUCAYDDQpPCQgBBgJHChYTDMQEEhkfEhALAQIBAwMDAVYCEwIAAAABAB8C4AEnAy8AHwAAATYzMhcWFRQGByYjIiMiBiMiJicuATU0NjcWFxYzMjYBEwIFBwMDBAUIBwYHIkAlECESDgsJBwEOHxsnSAMuAQQIEA4bBAEHAgMCFQ0MFQMGAQMIAAAAAQATAr0BFAN0ABgAABMyNjc+AzMyFhUUBiMiDgIHIi4CJy8JEQ4gLyASAx0cFhQPJioqFBEVDAYCAw0MDR0fDwMpFRQdExkYBA8XHA4AAAABAAsBIACqAb4ACwAAEzIWFRQGIyImNTQ2WyAvLh8hMS0Bvi4hHzArHyMxAAH/5f8uAKwAOQAqAAA3NjMyFhcOAQceARUUBgc3DgEjIiYnLgE1NDY3HgE7AS4BLwEmNTQ3PgE3QAgQFCcDBAsGERoBAgEILx0XOREJByIXAxgLAwIVCwsPDwoMBzUEExQOEggVMx0GCggBIh4KEQkUChIkCxsJCxgKCw8TFQ4KDQsAAAIAEf+uAeQDEAA6AEwAACU2MzIeAhUUDgIjIi4CNTQ+BDc0KwEnPwE+ATMyHgIVFA4EFRQeAjMyPgI1NCYnAyIuAjU0PgIzMh4CFRQGAUYfGBcmGw8tRVMnLFNAKBsqMSseAx0cCBUPCxEFFjIpGx0qMyodCBMeFQUpLCMSFVURHRcNDRcdEBAfGA4ukQ4THiIPIjUlEx01RyohOTUyNDcfGTUbBQQCDx4rHCREPjgzLBIJFhINAQUIBgkQCwIHDRcdEQ8dFw0LFRwQJDIAAAACAEoABwD+AukAKwA7AAATBgcOARUUFRQVFBYXDgEHIiYnLgEvATU0Jic1NDY1NDU0JzQ2Nz4BNx4BFwMyFhUUDgIjIi4CNTQ27BYFAgQBAQYcDxgLAggPBQQBAgICCAwIFhodNQxiIC4NFRwPEB4XDi0Cc05QHks3CwcHBwYSDRMPBQEBBQwOIVESHw5VDR0REBESFg4jIg4QBAYZF/3zLyEPHBcNCxQcECQwAAAAAAIAGgGxAXADGwAUACkAABMOAwcGIyImJwM+AzMyHgIXDgMHBiMiJicDPgMzMh4CsgYKDRMQCQkJEgUmBhMVFwsHFxYSwAYKDRMQCQkJEgUmBhMVFwsHFxYSAu0sQEFPOgYMDgEiEBMJAgQLEg0sQEFPOgYMDgEiEBMJAgQLEgAAAwAy//gCqAK+ADQATwBiAAA3LgE1NDU0NzQ+AjcOASMiJz4BNz4DMzIeAhUUBgceARUUDgIjLgMnDgEjIiYnASIGDwE+AzMXFRQGBw4BBzI+AjU0LgIDIgcOAQcOAQc+AzU0LgIngAkHAgkPEgoXKg8QFAMPCB9XXVwjKko4IBkhNUMpSWQ6FiwtKxQMIQ8RFwYBBilHDgoMJCwxGR4cEhEgBSNGOCMbLTgeKDACBQMGDQMfST8rBA8cFxQ1YTYRERIUFz9DQhsJCRwPFAslKhUEHTJDJhcyGwxQPEdnQyECAQEFBwUFCAwBKAcFng0ZFAwCCgsTDAkRCAocMykRFw0FAQwMCxILGDQeBA4WHxcPFxAJAQAAAAIAGv/sAkwCyAA4AEsAAAUuAycuAScOAwcOASMiLgI1NDY3DgEjLgE1ND4CMzIeAhUUDgIHHgMVFA4CIyIDDgMHHgEzMj4CNTQuAicB3gItPkIYHCsUAgQDBAECHhQRIhsSKicMFAcVEzlMTRRafk4kHC89IBk7MyEVHR4KDPIIDAoJBBIvGhM0MCEkOkcjDAMvQkoeAQYLFDIyLhIYGA4ZIxaA7XsCBAsWCxIiGxEeQWZJJEA1KQ4ONzoxCA8aEgsCaCE6Oz8mAwEIFyoiNjsdBgIAAQAxAYkBJQLhACMAABMyPgI1NCYnIgcGIyIuAjU0PgIzMh4CFRQOAiMiJidDFiwjFQ0JCwUQFgsXEgwHGC0mJzIeCxYoOSMbLAsBvQ8bJxcPEAMIEAoPFAsVKyQWKzk6DiI+MBwXHQACABX/pgKhArkAXAByAAAFDgEjIi4CJy4BJwYjIi4CNTQ2NyY1ND4CMzIeAhUUBgcOAwc3DgIjIiMiDgIVFBYXPgEzMhYXPgE3Mh4CFR4BFz4BMzIeAhUUDgIHDgEVFBYVASInBhUUHgIzMj4CNTM3LgEnDgECFwwREgsWExAECAkCO0M9XT8hHhkfL0tbLC09JA8LDgYTHCodLwMNDgYFARowJBYBARAgES42DAUKCA8SCQIMGA8PLyQOIR0TGCMpEggDAf7QJR8PFCAqFhcwJxkGAx8iCBA1SQoHCQ4PBgwdDxYfOVAxLlAgMD4vUjwjFyQrEwsZCgQICQsGXAMEAhAbJxYIDQgFByMUBQgDCAwQCAoJAxEkBhYqJBohFQoBJk8lGzEXAUoJJDATIhkPDBsrHwgPJBQOCgAAAwAU/8YELALCAG4AfgCSAAA3LgE1ND4CMzIXFhcyNjM+AzMyFhceAxUUDgIHDgIjIgciIyIHDgEVFBceATsBFx4BFxYVFAYHDgMjIgYHDgEVFBceATMyPgIzMh4CFxYVFAcOAyMiLgInDgEHDgEHLgE1ASIOAgczMj4ENTQmJz4BNw4BBw4DFRQWFz4DN2ApI0Bqi0tCKCcJAgQCH0RRYj4OJSEIGhoSFSAjDiAqIhAPFAgHBwcECwMBCQuUHAkJAgEGCg0uO0YlAwYCCBYBAQoLEjxGSiAJExELAgEIEjpKWjElPi4fBkm2XAYgEh4eAawoRDw4HBoaQkRBMh8sgQoTChgwFD9bPBwDBSA/QkkqTkSAPFCJYzgREQ8BAQ0PCwUJCBcbHA0IDgwIAQICAQECBRoXDhAGDgQLIQ4FCwsUAQECAgECBhtFIAoFCAwUGRQLEhUKBAcOBRAuKx8YKTYeOUAEEh0RJ0UYAawuVXlKEyMxOkIjICBrAwUCBAwHD0BUXy4PHg9SgF06DQAAAAIACwDFAfcB+QAjAEgAAAE2NzIWFx4BFRQGBy4BIyIGBw4BIyImJy4BNTQ2NxUeATMyNjc+ATMyFhceARUUBgcuASMiBgcOASMiJicuATU0NjcVHgEzMjYBQT9GCBAIBQQPERQiERcxGBkzHCBAIhsYJx4lPR0cOSccOiAMFgsFBA8RFCIQFzAYGTMbIEAiGxclHyE/Hxs5ATwHAgQGCBULFCwIBAIFAQEFCAsIJRIUJQcRCwcFpQMFAwYIFQsULAgEAgQCAgQICwgkExQkCBEKCAUAAQAI//MA8AGPACkAABMeAQcOAQceARcUDgIjIi4CLwEuAycuASc+ATc+ATc+ATcVPgE3rxUYAgQdFyArAwoPEwkMEQ0IAwIKGhsaCQMUAxEYCw0cEAUBAgMKDQGPDCcXJz4fIkIvERcOBQwRFAgEGCUcEwcDEAIjGgkKHyAHCQUBDhsJAAAAAAEAG//zAQIBjwAsAAATHgEXNR4BFR4BFx4BFw4BBw4DBxUUBhUOAyMiLgI1PgE3LgEnJjY3cw0KBAIEEBwOCxgRAxQECRobGgoBAwgMEgwJEg8KAyogFx0EAhgVAY0JGw4BBwwCIB4LCRojAhADBxMcJRgBAQEBCBQRDAUOFxEvQiIfPicXJwwAAAAAAgAP//MBkAGRACUARAAAEx4BBw4BBx4DFRQOAiMiLgIvAS4DJz4DPwEVPgE/AR4BBw4BBw4BBx4BFw4BIyIuAicuAyc+AzelFRgCBCoXECAbEAoPEwkMEQ0IAwIPIx4XBA4WFRYOBwMKDbwcFwIFHBACBQIhJgkDGRcJERAMAwscHRsJECIfGQcBjwwnFydFHxEiIyQSERcOBQwRFAgEIC0gFQgQHR8nGhUBDhsJBAUxFy0zFAQFBCNCMRUlDhQVBxwmHRwTDCo0OxwAAgAU//MBiwGRACgASQAAAR4BFzUeARceAxcOAwcVFAYVDgMjIi4CNT4BNy4BJyY2NwceAxcOAwcOAyMiJic+ATcuAScuAScmPgI3ARcNCgMCAwIHDRIZFBAYFRYPAQMIDBIMCRIPCgMqIBcdBAIYFYgHFRoeEA4VEA4IBg8SFg4XGQMKJiACBQIQHAUBBQwUDgGNCRsOAQcIBhMkIiISDBUeKiEBAQEBCBQRDAUOFxEvQiIfPicXJwwPHDw2KwwNFxUWDQokJBolFTBDIwQFBBQ0LAwZFRADAAAAAAIALf/IAf8C3QBSAF4AACUOASMiLgI9AT4BNz4DNyMiLgI1ND4CNx4DMz4BMzIWFRQGBx4BFRQOAgcOASMiLgI1PgM1NCYnNCYnLgEnFSInHgEVFAYHBgMUHgI7AS4BJw4BAS4BCxoJFxUOAgYCAQMCAQEIIDstGhQnOycbKSgvIgguFRMaJScNCgEBAwICEhYJFRMNAgMCAQkKAgELDwgCBhANBQQGnAcPGBEEAg4QDhUHGRoHDhQOAiZFIxMhICMXJjtIIidNPy4IAwUFBAIIDxMULAtdsGElPjw9JRcbCA8VDB80MzUgXq5fCA0GAQQCAQI+dEM5ZTNLAbgUKyUYOl42DiwAABIALP7pDsADEgATAHgAjADTAP4BCgE+AU0B5AH2AggCJwJNAr0DAANVA2oDuQAAJT4BNzY1NC4CIyIOBB0BFhMyFhceAxUUDgQjIiYnLgEnLgE1DgEjIi4CNTQ2Nz4BNz4BMzIVFAYHDgMVFB4CMzI2Ny4DNzQ2NzY3PgE3NjMyHgIVFAYHHgEzMjc+ATc+ATc2NTQuAicBFjMyOwIyMzI3NC4CJw4DNzY7AjIWFx4BFx4DFx4DHQEGFRQHBiMiJi8BIyImIyIGKwEGBw4BDwEOASMiIyInLgE1NDY3NCYnNzsBPgM/ARcyFhUUBgcOAQcOAQcVFDMyNjc+ATMyFRYVFA4CIyIuAjU0PgI3PgEFHgEzMjY1NCMiBwYDDgEjIicmJy4BJyY1NDU0NjcmNTQ3NjcyFhUUMx4BFz4DMzIeAhUUDgIrAQ4BFRQBDgMVFB4CFx4BFzcBIgYjIicmNTQ+AjMyFx4BFx4DFx4DFRQGBwYHDgEHDgEjIiYnDgEHDgEjJy4BJy4BJy4BJyY1NDc+ATc+AT8BNDY3PgE3HgEXFhczMh4EFRQOAiMiJic+ATc+ATcuAyMiBgcXHgEXHgEzMj4CNz4DNTQuAicuAScuASMiBgcGFRQeAhcWFRQFFjMyNz4DNzU0JjUOAQcGFxQWOwEyPgI1NCcmIyIOAgcWFxYVHgEVFAcGIyImJy4DPQE0NTQ+ATc+ATc0EzMyHgIVFAcOAQcOAQcGIyImJw4BBy4BJzQ3LgE1ND4CNzIWAwYUMx4BFzIWFx4BFx4BFxYXHgEVFAcGBwYHBiMiLgI1ND4CMzIWFxYVFAcGBw4BIyIuAiMiBgcGFRQeAjMyNz4BNz4BNzY1NC4CJyIuAjU0PgQzMhYXHgEVDgEHDgEjDgMHDgElNDYzMhYXHgEVFA4CIyIuBCMiBw4DBxQOAiMiLgI1Jj4CMzIWFx4BFx4BFx4BFxYjMj0BNC4CLwEBFAcOAyMiJyY1NDY3LgE1NDY3PgE/AS4DNTQ3PgEzMhYXHgEXFhUUDgIjDgErASIHDgEVFBY7ARceARUUBgciBiMiBw4BBzI2Nz4BMzIXFhc2Nz4BNTQ1NCc0IyIOAgcOAwMuAScmNTQ+AjcuATU0Njc+ATc+ATc2Mx4BFRQGBw4BBwYHDgEVFBczNzY3PgE3PgE3PgE3NjMyHgIVFAcGBw4BBw4BIyIGBw4DBwFVFx4KEgEFCQgMEg8KBgMBzw0eCiQ9LRghNkZMSx8hMxMJDwUEBhQrFSo6JBEfHR1UNAsaCg8MAytGMhwHEyEZDx4JAQYGBQEJCxYZEB4OHhIYHxQITkwLKiQkKRQmERIcDBYRITEfAUUEAwQDDg4EBAQDAQMFBQUMDAshAgUDBwUKBAQGAQIHCQcCBAgFAwEBBQYPFwgEIhkXBgIBAQIKCQQIBQsDDQgFBQQGCwoQDg4RARAiBRIVFQkw0woGAwICBwMIDwYKCyEYCxkICQMZJisSGB4QBQ4UFggFDAEPBAcGDCEODxAQKAgKCw8ODgcGCAECEw5oBQMMBgMEGjMfBxIYHhMKGBUOGiYpDQUOBwGbIEc6JxAWGgsZQiMJ/tQFDAkQDxA0Sk4aRVEoTiUcRUpNIyQ9LhoRER45Gj0iIkQjI0wiAwUFCQ8LFwsKBkZXFAgSCBEiEisXGD0lAgUEBA0JHA4CAQUNETc/QTMhDBMYDQocCAcMBwcKAQgsO0IdCwoGAQwaDQ4UChU0ODkaGy8jFEx0iz8tVy0sXDMUKRQYCw4MAgUDkgEDBAEFExcXCQEVHQwWOQYCFhQ1LyECAxQWKyklEx4ECgEJBgYUBREGBQcEAwEBAQEFCrYEBhMSDRULGhEPIBIjGBAiDggKCwkOAwQMDiI3RiQhLxwCAg4aCwsaDw0dDg8bDRcRCQkTFBkXGxoLIDstGhEbIQ8dRh4CAgYPBxIKCxocHQ8GCQULDxgcDgYbDhoODhcLFyIwMxAsMxoIHCsyLR8DJEAZBgYCDQgFFAcNMDMuDBoYAdUEBgsmEhEZChQcEw4dGxkUDwMDBQEBAgMDBAYLCAwQCAMBCRIaEAYPCAgSCgkTCwoUCwcBBwcMEAkFAXYGCiEoLxkoFRMRCAIGAwIGDgYXCRMRCxogUD4IERADCwUMCxESBxEVCCMMAgMLBQVLDwQCBAgOPicDAwMNCAU3MAgSCQgICLA1LRcUAgoHExQSBgQREhGBDhkIFQcRHBUICwkICBIKCxMLFQUMBgYFBRAMDQsHCAQCAQEBCRUODhkODxsOGRQTGg8GGhYiEiMTEiAMBQsGDxMPDgqsHDYaNzwKFxUOHy86Ny0LGg8CYwoKHlRgZTBNfmNKMBgaEAkQCAgMAwgKIjdHJECCOzxmIwgPDAgKAyxrdn0+FzAoGgkLATA8NAUgNRctHA4TBw4bJy4SR4lBHRwdDCkbG0QnT2oqV1FIG/3AAQEHFhgYCAITGxzGBgYEBgsFBhcbGwshNDExHiUFBQQFAxsUOwEBBBoNGQ4cBQMCCxYRESwZDBUCFA0lJyYOOgILCg4XCwoXCxhANQUQDwgFCwkJBhElIRUWIykUHERANg8HCEUBAQ8JEAkK/mIFBAsKCwoYDg8NDQxBaScqOA0NDgURCAUWEAUGExQNBRAgGxUaDgUyaTM6ASsDBwwRDQkWFRUIFCEJwwFkAgMECiImEwQSChUOCSArNB0cQUZKJiQ7GzEiERkICAgJBggREQMCAg4pGChCGAgWCxcXFxYOFAkIDgcpAygXFSoIFjMhHyEDChEaJhkJGBUPBgYGDQYFDAUIEg8JAgLYCAoCAgECCAwLCh0pNCJCdGBKGREaCQkHAwUFCAIEAwMBAwUFeAEBBxUXFggBAgIBBQ8NF0MCBg0ZJBcICAgTICmRAg0RHD1+PAwMCwQCAQ4SEQMeCgcHEBUPC1JMCAEWBw0VDRwgDxsLCxMIEAQFCg4CAhoRBgoPGxEZNi8eARb+gQIDBQgEAgIBAQIBBwUJFAsZEygZFQwLAwMTHCMPEhgNBg0RAQQEAQcHBAIHCQgCAgYPCgsFAQMCBQMECAULDQ0UDQYBBQ0WEBciFg0HAgsFAgYICAsEAgMCBAQEAgUFcwcOIiAgVzUXMCgZHCoxKhwLBSgwLgsFEA8LEhkbCBVPTzsJDAkaDg4gEREcDQgRCSIwLjIkC/7SCwQIGBYPGxciES4YCAkJBggFAwUBNgQJCw0JDQICEgIFBQoGDg4DCAcFAQEBBBMSBAcCBREIBhABAgYRIRELBQEBCgkFCCcUMCAEBAQFCw8VFgcGHyMg/osCDQsYHwcuRVkyEScSFCcUFSMQERsLFQIMDQgOCAgaERIdDhsNCgMBAQINGhARHQ4OGQoVHCgqDy0kJxkPFAgIBwEBK0E8Pyn//wAi/1EA4gB1AAcABQAA/T8AAP//ABj/GwIuAHMABwA5/+f9kgAAAAEAD/+7AeMCkgBcAAATLgE1ND4CMzIWFxYXPgE3PgE3PgM3PgEzMhYXFhUUFRQGIyInLgEnDgEHPgEzMh4CFRQOAgcOAwcOASMiLgI1NDYzMhYXHgEfATI3Bz4DNy4BJ48PFAoQFgwFCgsGDwMKBgIFAwYNFiEYBw8JHTgYARoOExMGDQQTGAgOGw4GDQoGFCAnEgcRHjAmDiYUEh8XDQ4PBQsFAgQCBAIIAhwnGhAFCxkNASQFDhQKFxUOAQUEAxgwGQIRChQoJB8LAwUaJQUEAwIcFQcCAwEjTioDBAwTFgoOFg8JAipXU0weCwwNGCASFAwFAwIBAQIFARQ0PEQjAwcFAAAAAAEADgB2ASMCEQAsAAATHgEHDgEHDgEHHgEXHgEXFA4CIyIuAi8BLgEnLgEnPgE3PgE3PgE3PgE34xUYAgMuGgsJCAgSCiA0BAoPEgkLExANBAEXOxgQGQ4RFw4RLiIEBQIFCgsCEQwnFyEzFwkGCwgNCBo1JBIXDQYKDxEGAiEyEgwWERoXCQsmKgMKBQsVCAAAAAAHACkALAP1AroAOQBOAGMAcAB9AI0AkQAAEzIWFz4BNzYzMh4CFRQGBw4DBw4BBw4BIyIuAjU0Nz4BNw4BBxUUDgIjIiY1ND4CNz4BNwE0PgI3PgEzMh4CFRQOAiMiJiU0PgI3PgEzMh4CFRQOAiMiJjcUFjMyPgI1NCYrARcUFjMyPgI1NCYrAQEOARUUFjMyNjU0Jy4BJzcnFzcn3xo7FTNpJwwOChgVDwIFHTpARykmUCgGEwoLFxQNDFqURg4cDhoqNRxOVgUMFhEOMhwB/wkbNCoNGwsdMSMTHC04G09O/rQJHDQqDBwKHTEjFBwtOBxPTl4fHAsYFA0ZDwb6IBwLGBQNGg4G/TYKDycdFSIBDhsOAyUFBAYCqCsjBi0jCg0UFwoICAUkTFReNzNqMQcJDBIWChEMV8tpAwUCCiE2JxZTQRIgHiAUDg4E/iQTMS4kBwYEHzA8HCE3JxZTSRMxLiQHBQQfMDscITcoFlVHGiIKEhcNGyVLGiIKEhcNGyUBLAsdFxscIRkHBAIKBRFtDAkDAAABAB0AdgEyAhEALQAAEx4BFx4BFx4BFx4BFw4BBw4BDwEOAyMiLgI1PgE3NT4BNy4BJy4BJyY2N3YLCgUCBQQiLREOGRAOGRAYOxcBBQwQEwsJEg8KBDQgDgsLBw0IGi4DAhgVAg8IFQsFCgMqJgsKFhoRFgwSMiECBhEPCgYNFxIkNRoBCwYMBgwHFzIiFycMAAAAAQAN/90BKgMWAE0AABM+ATcyNz4DNTQuAicVJj4CMzIWFRQGBw4BFRQWFx4BFRQGBx4DFxQWFR4BMzIeAhUUBisBIiYnLgM9ATQmJy4BJy4BJw0HFgoBBwwOBgIBAgEBBQ8iMx8oGw4cGRECAQIBChEOEQgDAQECBwgGFRMOIBwJCxgNGBsPBAgUBQwICxQKAW0REQUFCA4RFQ8IFhcVBwElUEIrHxQWJggILh0OHhIRJw4gJxQTLjIzGAUIBSczCxIVChIYBAgSJykrFiodOBoGBgUFEAsAAQAS/90BLwMWAE4AAAEOAQcOAQcOAR0BFA4CBw4BKwEiJjU0PgIzMjY3NDY1ND4CNy4BNTQ2Nz4BNTQmJy4BNTQ2MzIeAgc1DgMVFB4CFx4BMx4BFwErChQLCAwEFAkEDhwXDhgLCRwgDhMVBggIAgEDCRAODg0BAgECEBocDhsoHzMiDgQBAQEBAQcNDAIFAQsVBwFWCxAFBQYGGjgdKhYrKScSCAQYEgoVEgs0JwQIBRgzMi4TEiofDyUSESANHS4ICCYWFB8rQlAlAQcVFxYIDxURDggBBAUSEAAAAAABABEAAANUAqoAPQAAASY1NDc+ATMyFhceARUUBgcOASMiJx4BFRQOAiMiLgI1NDY3BiMiJicmNTQ2Nz4BMzIWFx4BFRQHNjMyAjEOJhQxGiA+GhoaEhMUMhoeHhESKUdeNTZfRykTER4eGjEUJhoaGj8gGjEUExINOEZGAeUhHzgoExIaGho9IBoxFBQSDB1CJDVfRikpRl81JEIdDBIUKDcgPRoaGhITFDEaIh4gAAMAHv/dA0EC8gATAD0ARgAAEzQ+Ajc+ATMyFxYVFA4CIyImAQ4DFRQeAjMyPgI1NCcOARUUHgQXDgMHLgU1NDYBLgEnNx4BFRQeToKpWgYLBTYb6USAu3aRnQEYJTMfDh0wPiBIfFszsiYtIDRCREAYEBIRFBIcSUxKOiMFAdMZRCNZGSYBVVKDZEkZAQE5QcNOk3RGmAFeEjM5PBshPC0bL01gMockCEAtKFJPSj4xDgwVEhAHDTNEUVlbLBwr/eEEEg1KEB8MGQAAAAIAFP/1ApkC4wARAD0AAAEOAx0BPgM1NC4CDgEDFCMiJicuATU0PgI3BiMiJjU0NxU+ATc+ATcjPgE3PgIeAhUUDgIHARUEBgUCOFxCJBYlMDM1C1ILHxQODQIFBwUaDh8tDwIKCA0eDgIMHA8rbG9pUzJDb5FPAl4XLC40Hz0HFSExJSszGAQECP3wWQoLPnREH0xRUSMIHiEXFAIFCwkCCgUECgMIDwETMlZDSmhJLQ8AAAEAFf/tAjEC6QA4AAABFhUUDgIHHgEVFAYHDgEjIiYnLgM1NDceAxceATMyNjc0LgInDgMjIjU0NTQ/AT4BAgEwGiYpEB0hCBASSygmcDoPKCQZGgccJS4ZH0AgEREFAwoSECMzKSIRaQEaiuMC6TMqDQ0IBgVq6XEgPhgcHBojCR4nKxYqMgwfIB4MDhMFBhhGaZNlBgcEAWAFBAUFGRQPAAD//wAT/v8ClgOyAiYAMgAAAAYARWplAAD////s/v8ClgL3AiYAMgAAACYAO/eQAAcAO//n/vEAAP//ABb//AV+AsQAJwAtAroAAAAGAC0AAAADABT/xgQsAsIAbgB+AJIAADcuATU0PgIzMhcWFzI2Mz4DMzIWFx4DFRQOAgcOAiMiByIjIgcOARUUFx4BOwEXHgEXFhUUBgcOAyMiBgcOARUUFx4BMzI+AjMyHgIXFhUUBw4DIyIuAicOAQcOAQcuATUBIg4CBzMyPgQ1NCYnPgE3DgEHDgMVFBYXPgM3YCkjQGqLS0IoJwkCBAIfRFFiPg4lIQgaGhIVICMOICoiEA8UCAcHBwQLAwEJC5QcCQkCAQYKDS47RiUDBgIIFgEBCgsSPEZKIAkTEQsCAQgSOkpaMSU+Lh8GSbZcBiASHh4BrChEPDgcGhpCREEyHyyBChMKGDAUP1s8HAMFID9CSSpORIA8UIljOBERDwEBDQ8LBQkIFxscDQgODAgBAgIBAQIFGhcOEAYOBAshDgULCxQBAQICAQIGG0UgCgUIDBQZFAsSFQoEBw4FEC4rHxgpNh45QAQSHREnRRgBrC5VeUoTIzE6QiMgIGsDBQIEDAcPQFRfLg8eD1KAXToNAAD//wAU/8wDsgL+ACYApwAAAAcAIwFuAAAAAQBf/7oA6AMZABsAABMeARceAxUUDgIjIiYnLgMnPgM3NoMvKgICAwMCBQwVEAocCwgMCQQBAgMGCQcBAxkCSkRJo6aiSA4eGA8IBQQiKScJW5uftXcS//8AFP/MAiwC/gIGAKcAAP//ABT/zAIsAv4CBgCnAAD//wAU/8wCLAL+AgYApwAA//8AFP/MAiwC/gIGAKcAAP//ABT/zAIsAv4CBgCnAAD//wAU/8wCLAL+AgYApwAA//8AFP/MAiwC/gIGAKcAAP//ABT/zAIsAv4CBgCnAAD//wAU/8wCLAL+AgYApwAA//8AFP/MAiwC/gIGAKcAAP//ABT/zAIsAv4CBgCnAAD//wAU/8wCLAL+AgYApwAA//8AFP/MA7IC/gAmAKcAAAAHACMBbgAA//8AFP8uAkwCwAAmACEAAAAHAEsA8gAA//8AFP8uAkwCwAAmACEAAAAHAEsA8gAA//8AHv/uAkQCugIGACMAAP//AB7/7gJEAroCBgAjAAD//wAe/+4CRAK6AgYAIwAA//8AHv/uAkQCugIGACMAAP//AB7/7gJEAroCBgAjAAD//wAe/+4CRAK6AgYAIwAA//8AHv/uAkQCugIGACMAAP//AB7/7gJEAroCBgAjAAD//wBU//4A8gLQAAYAJwAA//8AVP/+APIC0AAGACcAAP//AFT//gDyAtAABgAnAAD//wBU//4A8gLQAAYAJwAA//8AVP/+APIC0AAGACcAAP//AFT//gDyAtAABgAnAAD//wBU//4A8gLQAAYAJwAA//8AVP/+APIC0AAGACcAAP//ABT/xgLMAsICBgAsAAD//wAU/8YCzALCAgYALAAA//8AFP/GAswCwgIGACwAAP//ABT/xgLMAsICBgAsAAD//wAU/8YCzALCAgYALAAA//8AFP/GAswCwgIGACwAAP//ABT/xgLMAsICBgAsAAD//wAU/8YCzALCAgYALAAA//8AFP/GAswCwgIGACwAAP//ABT/xgLMAsICBgAsAAD//wAU/8YCzALCAgYALAAA//8AFP/GAswCwgIGACwAAP//ADL/+AKUAvACBgAvAAD//wAy//gClALwAgYALwAA//8AMv/4ApQC8AIGAC8AAP//ADL/+AKUAvACBgAvAAD//wAy//gClALwAgYALwAA//8AMv/4ApQC8AIGAC8AAP//ADL/+AKUAvACBgAvAAD//wAy//gClALwAgYALwAA//8AE/7/ApYC9wIGADIAAP//ACIABAJyAxQCBgArAAD//wAiAAQCcgMUAgYAKwAAAAIAJ//3An0C0wA1AEQAADcOAwcuAzU0PgQzMh4CHwE+AzcWFRQGDwIeARUUDgIjIiY1NDY1NCYvATcuAScuAyMiBgcOAQfQAQUNGhcfJxcIFicyOTsbME88KAkhEBUPDggBDA0IBwcEEyAqFwsLAgcN/eoBBwsVGxUPCQwYCBUpCDELEQ4LBQcqRGA/MGhmW0YpM0tWI3YBBQUGAgQICzI0DAdIOQESJyEVFxQOKxcdMwsiZBgzGjI8IQoTFDBlNQAAAAAB/+L/1QKXAtIAMgAAAR4BFxQGBw4DBw4DBwYmJy4DJy4BJzQ2NzY3MhceAxc+Azc+ATMyMzICiAgGAQECI0lEOxYGFSEsHhcUAwMhOVExCxIBDQ4dEwQCMlBANRcfOzMqDyM2FwUEBALFDRkLBxAIRHl5f0kUNjIkAQEVGE+lnpE8CRkRCRELGAEBIVZsgkxUd1IzDyMlAAIAFP/MAiwC/gBLAF0AAAE+ATsBMh4CFx4DFx4BFx4DFRQVFA4BBwYjIiYvASMiJiMiJiMiBw4DDwEGIyImJy4BNTQ2NzQmJzcWMzI7AT4DPwEDFjMyMzIzMjc0LgInDgMBcgUJCAwKExALAgQPEQ8DAgMCBw0IBQEDAgkNHSwRCEAaJQ0MEAYKAgsSEBEKFhAgCRMMFREdGxwgBAYHBwhCDCQqKhJgQg4ODg4ODw8OAQYLCgsZGBUC9AgCDBIWCg0uNTYUDRgMNl1YWjQaEhEYEgkGNyd0AQECBB8tNhw6EAQCFysgJFgwGCsFJgIZS09MG3b+egICDi0wMBEDKTY4AAAAAQAM//QClgLKAC4AABMeARcTHgEXPgU3NjMyHgIVFA4EBw4BBw4BIyIuBgc1NDeIDxgUZQIJCTVKMh4UDAcCCAoeHRUEDhswSDMJFg8aKRojOC8lIBsZFw0uAsYaSS/+sAgUDHOlckYoEAQCCxIVCgoVKkV0qngVKRIOGDVYb3NuVDIDDjkrAAIAFP/lAJACyQAaADUAABM+AT8BMjc+ATceARceARcRDgEjIiY9ATQ2NwM0NTQ+ATc+ATMyFhceAhUUFRQGByIvAS4BJQULBgQBAgIDAg0cDAIEBBElDRQaAwULAQIBDyUODhgLAgIBDxcsHwMEBAK5BQQCAQEBAQEFFA4NHRP+/woIDRDgHDQR/XYZISFKSyICAwsQWWQyBgYBFx0NHAoICwAAAQBBAR0A2QL6ACQAABMiJicmNTQ2Nz4BNz4BMzIeAhceARcOASMiLgInLgE1LgEnchEUCAQCBREbAwUQCgUSEg8CAgUCBwsOAw0PDgQHAgEEAwJaDQoHBwMIBgktHQ0KBAcLBmrUag8KAQIDAgsTCUWGRAABAAkBGQGXAvkARQAAEz4DNTQuAiMiDgIHFAcVDgEjLgE1NDU0Nz4DMzIWFx4DFRQOAgceATMyNjceARUOASMiJiMiDgIjIiY11gcXFRAJDhAGGSAVDQcCBA0UFQ0BAx0rMxkHDAUVKyIVJDQ6FgsjICI8DhILF0skKEQoCxIUFQ0OEwIWCBsfIA0HDwwHCA0RCgEKAw0VAiAQBwUFAhwnGAsBAQMTIC0dID48OxsGChMUBCAQHiYQCQsJFg8AAAABADIBJQF4Av8AVwAAEx4BFyYjIiMiDgIjIiY1NDY3PgEzMh4CFw4BBx4DFRQOAiMiLgI1NDYzMhYXHgEzMj4CNTQmJw4BIyImNTQ+AjMyFz4DNTQuAiMiBgd+BSALBwUFBQoKCAcGGRUWFBQhFyJCMyABARMSDRILBSAyPh0mOScTBw8GEwkRMiIKHRkSDBYRKRMnNhwkIQQhIAcLCAQSHSMSCxkKAqMHGwkBAQIBHhUXLAYHBwwfNCgUNhQIEhghGCo2HwsYIigPGBYJDRofBg8YERIUCwYFHhYTFwwECQIOEhIGEBUMBAMEAAH/wP/yAkUCiwB7AAADIgYjIjU0PgI3Njc+AzMyHgIVFA4CIyImJy4DKwEOAQczMjczMhYVFA4CBwYjIisBIiMiJwYVFBUUFzMyFhUUDgIjDgEjHgEzMjY3Fx4BFRQGBw4DIyIuAicjIiY1ND4COwEmNTQ1NDU0Nw4BDwENAgIDJAkPEggmIg4zUnVRFjcxIgoOEgcOCAgFDxQaEAJNah5nNDYDFhMNEhUIDg4NC2cUEhIRAQPKERwPFhcHH0okHUwgMmItFhELBQIZOz5AHixTSTkQVBcSCQ8SCTgBAQwYDAUBYgEjBRMUEAEFASRHNyIOHSwfBhAPCwoIBg4MCQIuKgMeDgcRDwsBAgEIBwcIGBISEQYTEg4CAigpHA8FDRkNBhQLDxsVDRs0TjIRFAYTEw0ICQkJCAkJCwEBAgEAAgAWAAgCcgOlADUAeAAAAR4BFzY3PgEzMh4CFRQGBy4BIyIGBw4BBw4BIyImJy4BJxcuAScuASMiJjU0PgIzMhYXFhMOASMiJy4BNTQ3PgM3DgEjIi4CNTQ2Nx4DMzI2Nz4BMzIWHwEOAwc+ATMyMzIXHgEVFAYrASYjIiMiBgEtAwYDDRQRGxYNFw8JCAsQCwUNEQoHBgYEIREQHAYCAwEBAgcIAhcKFhUFCxALGDcQA1k1ZTIsMB4iFiheX1kkGDMVJWJZPgMDKEpFQyInUC0IEQkaJwMECUBaazQ+dj4ODA0PJCIlJwQLCwsLHTcDewIFAhAOCwoNFRkLCBMQCAMQDggQERQZERIFCQYCChQLBAceEwkUEQsTDAP8ngUNBgYoGBsZNGJjZjkICA0gNikIFQsCDQ0KDxcDBSEdJkl7bmUxBRECAisbGy8CBwAAAgAWAAgCcgOlADUAeAAAAR4BFzY3PgEzMh4CFRQGBy4BIyIGBw4BBw4BIyImJy4BJxcuAScuASMiJjU0PgIzMhYXFhMOASMiJy4BNTQ3PgM3DgEjIi4CNTQ2Nx4DMzI2Nz4BMzIWHwEOAwc+ATMyMzIXHgEVFAYrASYjIiMiBgEtAwYDDRQRGxYNFw8JCAsQCwUNEQoHBgYEIREQHAYCAwEBAgcIAhcKFhUFCxALGDcQA1k1ZTIsMB4iFiheX1kkGDMVJWJZPgMDKEpFQyInUC0IEQkaJwMECUBaazQ+dj4ODA0PJCIlJwQLCwsLHTcDewIFAhAOCwoNFRkLCBMQCAMQDggQERQZERIFCQYCChQLBAceEwkUEQsTDAP8ngUNBgYoGBsZNGJjZjkICA0gNikIFQsCDQ0KDxcDBSEdJkl7bmUxBRECAisbGy8CBwAABABB/7kC7gMFACQASACFAJUAABMiJicmNTQ2Nz4BNz4BMzIeAhceARcOASMiLgInLgE1LgEnBQ4FBw4BIyImJyY1NDc+ATc+Azc+ATMyFhcWFRQHEyImJy4BPQEuAScmNTQ+Ajc+ATMyFRQGBw4BFRQXHgEXNTQ+AjMyHgIVFA4CBxQeAhceARUUBgcTNCYnDgMVFBYXPgNyERQIBAIFERsDBRAKBRISDwICBQIHCw4DDQ8OBAcCAQQDAZ4UMzk7NiwOAxEOGSMJAwEjPxsmQDgyGQUPCxstCQYDUBAlBQIGJ1AbBwkRFQwHCAoZCQMKDAQOLQ8CCxgWFx0RBgMKFRIBAwUFAQILDgwCBgIDAwEBAQQGAwICWg0KBwcDCAYJLR0NCgQHCwZq1GoPCgECAwILEwlFhkQWIV9ud3VtLAgRKBcJBQUDRns1SXhydEUNCBoRCwgGBv0eDQ4MQCMRARkhGBwWMTAtFAsGHAsbCBo6GhYPCwsBIRtLRTEfMDweHCshGQoJHSEiDwMFAwkXBQEiHz4ZCyAlJQ8LEAUDDA4NAAAAAwBB/7kDOAMFACQASACOAAATIiYnJjU0Njc+ATc+ATMyHgIXHgEXDgEjIi4CJy4BNS4BJwUOBQcOASMiJicmNTQ3PgE3PgM3PgEzMhYXFhUUBxM+AzU0LgIjIg4CBxQHFQ4BIy4BNTQ1NDc+AzMyFhceAxUUDgIHHgEzMjY3HgEVDgEjIiYjIg4CIyImNXIRFAgEAgURGwMFEAoFEhIPAgIFAgcLDgMNDw4EBwIBBAMBnhQzOTs2LA4DEQ4ZIwkDASM/GyZAODIZBQ8LGy0JBgMdBxcVEAkOEAYZIBUNBwIEDRQVDQEDHSszGQcMBRUrIhUkNDoWCyMgIjwOEgsXSyQoRCgLEhQVDQ4TAloNCgcHAwgGCS0dDQoEBwsGatRqDwoBAgMCCxMJRYZEFiFfbnd1bSwIESgXCQUFA0Z7NUl4cnRFDQgaEQsIBgb+JggbHyANBw8MBwgNEQoBCgMNFQIgEAcFBQIcJxgLAQEDEyAtHSA+PDsbBgoTFAQgEB4mEAkLCRYPAAADAEH/uQMjAwUAJABIAKAAABMiJicmNTQ2Nz4BNz4BMzIeAhceARcOASMiLgInLgE1LgEnBQ4FBw4BIyImJyY1NDc+ATc+Azc+ATMyFhcWFRQHAx4BFyYjIiMiDgIjIiY1NDY3PgEzMh4CFw4BBx4DFRQOAiMiLgI1NDYzMhYXHgEzMj4CNTQmJw4BIyImNTQ+AjMyFz4DNTQuAiMiBgdyERQIBAIFERsDBRAKBRISDwICBQIHCw4DDQ8OBAcCAQQDAZ4UMzk7NiwOAxEOGSMJAwEjPxsmQDgyGQUPCxstCQYDMQUgCwcFBQUKCggHBhkVFhQUIRciQjMgAQETEg0SCwUgMj4dJjknEwcPBhMJETIiCh0ZEgwWESkTJzYcJCEEISAHCwgEEh0jEgsZCgJaDQoHBwMIBgktHQ0KBAcLBmrUag8KAQIDAgsTCUWGRBYhX253dW0sCBEoFwkFBQNGezVJeHJ0RQ0IGhELCAYG/pIHGwkBAQIBHhUXLAYHBwwfNCgUNhQIEhghGCo2HwsYIigPGBYJDRofBg8YERIUCwYFHhYTFwwECQIOEhIGEBUMBAMEAAAA//8AE/7/ApYC9wIGADIAAP//ABP+/wKWAvcCBgAyAAD//wAW//wCxALEAgYALQAA//8AFv/8AsQCxAIGAC0AAAABADL/yALgAuAAYAAAEyY1NDU0Njc2MzIzMh4CFRQOAisBBgcjIiY9ASY1NDceARcuATU0NTQ1LgEnLgE1NDY3FR4BFz4BOwEeARc+ATMyFhceARUUBgcmIyIGBxUeATMyPgI1NC4CKwEHNAIzMxIKCxFuwY9SRW6JRAwLKxAmIoYYES8gAQERIRETECIdCxQLCDcwDgUEAQ4eEAgSBQMDDg4cEwULBhUwDx5EOiZMfqNXGCwCcgYFBgUjKAsCQnakYj9sUC0aGCcpCFZUKScXIg8GGhAREhMQAgsICCQRFCYLGAUHAk9CI0IhAgIHCAYTChMrCwcBAbYJAx4tNRhJe1oyKgAAAAACABT/9QKZAs8AFABTAAABDgMdAT4FNTQuAiMiBgMUBiMiJicuATU0PgI3BiMiJjU0NxU+ATc+ATcjPgE3Mj4CNT4BNzIeAhcWFRQHPgEzMh4CFRQOAgcBFQQGBQISMzg2LBsRHCcVIEMmFigLHxQQDAQGBwMaDh8tDwIKCA0eDgIJFAsCAwMCAxkOBRgaFQIFAxcvGDdoUTFKdI9FAdwXIiMrHx8EBAYKERoUJTAaCgv+ci0sCgssai0eNTQ4IggeIRcUAgULCQIKBQMHAyEnIgIMEQEEBwwHFxsVDwIDEzJWQkpbNRoHAAAAAAAAWABYARIBxgJqApYCwALuA1wDvAPwBCQEQgR+BMwFLgWaBhwGmgc0B6IH9AhuCMQI+AlECawKQAqyCwILZguyC74MCAxkDPQNaA3IDlYOjA7iDx4PsBAQEHgQ+BFgEbQSOhKmEwoTaBOmE/IURBR6FNwVPhVcFZYV1hYMFuIW4hdEF9QYehkEGZwZ0hpmGywbXhuGG5wb3hxGHJ4c3h1qHdQeCB6mH24f2CAcIGIgyCE2IbomtibAJsonTieYKGQorikaKYop4ipIKqIq9CsAKxArHCvkK/AsHCwkLCwsNCw8LEQsTCxULFwsZCxsLHQsfCyILJQsoCyoLLAsuCzALMgs0CzYLOAs6CzwLPgtAC0ILRAtGC0gLSgtMC04LUAtSC1QLVgtYC1oLXAteC2ALYgtkC2YLaAtqC2wLbgtwC3ILdAt2C46LoYuhi6GLwgvTC+eL9gwODCuMU4x9jKeM3A0NDUQNRg1IDUoNTA1tDYqAAAAAQAAAIAAAQATAGAABAASAAUAKv+6AAUALf9aAAUAqP+cAAoADv+aAAoAOf+oAAwAOf++ACMAIf/sACMAK//cACMAMv/CACMAp//cACQADP+6ACQALP/MACcALf/sACkALv+cAC4ADP+wAC4Ap/+2AKgAI//MAKgAJ//aAKgAp//CAAAAFAD2AAEAAAAAAAAA5gAAAAEAAAAAAAEADQDmAAEAAAAAAAIABADzAAEAAAAAAAMAHgD3AAEAAAAAAAQAEgEVAAEAAAAAAAUAAwEnAAEAAAAAAAYAEQEqAAEAAAAAAAwAHQE7AAEAAAAAAA0pfAFYAAEAAAAAAA4ALirUAAMAAQQJAAABzCsCAAMAAQQJAAEAGizOAAMAAQQJAAIACCzoAAMAAQQJAAMAPCzwAAMAAQQJAAQAJC0sAAMAAQQJAAUABi1QAAMAAQQJAAYAIi1WAAMAAQQJAAwAOi14AAMAAQQJAA1S+C2yAAMAAQQJAA4AXICqRGlnaXRpemVkIGRhdGEgY29weXJpZ2h0IDIwMDAtMjAwNCBtaWNrZXlhdmVudWUuY29tIDo6IFNvbWUgcmlnaHRzIHJlc2VydmVkIDo6IEZvciBwZXJzb25hbCwgbm9uY29tbWVyY2lhbCB1c2Ugb25seSA6OiBSZWxlYXNlZCB1bmRlciBDcmVhdGl2ZSBDb21tb25zIE5vbkNvbW1lcmNpYWwtU2hhcmVBbGlrZSBsaWNlbnNlIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL25jLXNhLzEuMC9XYWx0b2dyYXBoIFVJQm9sZE1HQkY6IFdhbHQgRGlzbmV5IFNjcmlwdDogMjAwMldhbHRvZ3JhcGggVUkgQm9sZDEuMFdhbHRvZ3JhcGhVSS1Cb2xkaHR0cDovL21pY2tleWF2ZW51ZS5jb20vZm9udHNUSEUgV09SSyAoQVMgREVGSU5FRCBCRUxPVykgSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgQ1JFQVRJVkUgQ09NTU9OUyBQVUJMSUMgTElDRU5TRSAoIkNDUEwiIE9SICJMSUNFTlNFIikuIFRIRSBXT1JLIElTIFBST1RFQ1RFRCBCWSBDT1BZUklHSFQgQU5EL09SIE9USEVSIEFQUExJQ0FCTEUgTEFXLiBBTlkgVVNFIE9GIFRIRSBXT1JLIE9USEVSIFRIQU4gQVMgQVVUSE9SSVpFRCBVTkRFUiBUSElTIExJQ0VOU0UgSVMgUFJPSElCSVRFRC4NCg0KQlkgRVhFUkNJU0lORyBBTlkgUklHSFRTIFRPIFRIRSBXT1JLIFBST1ZJREVEIEhFUkUsIFlPVSBBQ0NFUFQgQU5EIEFHUkVFIFRPIEJFIEJPVU5EIEJZIFRIRSBURVJNUyBPRiBUSElTIExJQ0VOU0UuIFRIRSBMSUNFTlNPUiBHUkFOVFMgWU9VIFRIRSBSSUdIVFMgQ09OVEFJTkVEIEhFUkUgSU4gQ09OU0lERVJBVElPTiBPRiBZT1VSIEFDQ0VQVEFOQ0UgT0YgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUy4NCg0KMS4gRGVmaW5pdGlvbnMNCg0KICAgMS4gIkNvbGxlY3RpdmUgV29yayIgbWVhbnMgYSB3b3JrLCBzdWNoIGFzIGEgcGVyaW9kaWNhbCBpc3N1ZSwgYW50aG9sb2d5IG9yIGVuY3ljbG9wZWRpYSwgaW4gd2hpY2ggdGhlIFdvcmsgaW4gaXRzIGVudGlyZXR5IGluIHVubW9kaWZpZWQgZm9ybSwgYWxvbmcgd2l0aCBhIG51bWJlciBvZiBvdGhlciBjb250cmlidXRpb25zLCBjb25zdGl0dXRpbmcgc2VwYXJhdGUgYW5kIGluZGVwZW5kZW50IHdvcmtzIGluIHRoZW1zZWx2ZXMsIGFyZSBhc3NlbWJsZWQgaW50byBhIGNvbGxlY3RpdmUgd2hvbGUuIEEgd29yayB0aGF0IGNvbnN0aXR1dGVzIGEgQ29sbGVjdGl2ZSBXb3JrIHdpbGwgbm90IGJlIGNvbnNpZGVyZWQgYSBEZXJpdmF0aXZlIFdvcmsgKGFzIGRlZmluZWQgYmVsb3cpIGZvciB0aGUgcHVycG9zZXMgb2YgdGhpcyBMaWNlbnNlLg0KICAgMi4gIkRlcml2YXRpdmUgV29yayIgbWVhbnMgYSB3b3JrIGJhc2VkIHVwb24gdGhlIFdvcmsgb3IgdXBvbiB0aGUgV29yayBhbmQgb3RoZXIgcHJlLWV4aXN0aW5nIHdvcmtzLCBzdWNoIGFzIGEgdHJhbnNsYXRpb24sIG11c2ljYWwgYXJyYW5nZW1lbnQsIGRyYW1hdGl6YXRpb24sIGZpY3Rpb25hbGl6YXRpb24sIG1vdGlvbiBwaWN0dXJlIHZlcnNpb24sIHNvdW5kIHJlY29yZGluZywgYXJ0IHJlcHJvZHVjdGlvbiwgYWJyaWRnbWVudCwgY29uZGVuc2F0aW9uLCBvciBhbnkgb3RoZXIgZm9ybSBpbiB3aGljaCB0aGUgV29yayBtYXkgYmUgcmVjYXN0LCB0cmFuc2Zvcm1lZCwgb3IgYWRhcHRlZCwgZXhjZXB0IHRoYXQgYSB3b3JrIHRoYXQgY29uc3RpdHV0ZXMgYSBDb2xsZWN0aXZlIFdvcmsgd2lsbCBub3QgYmUgY29uc2lkZXJlZCBhIERlcml2YXRpdmUgV29yayBmb3IgdGhlIHB1cnBvc2Ugb2YgdGhpcyBMaWNlbnNlLg0KICAgMy4gIkxpY2Vuc29yIiBtZWFucyB0aGUgaW5kaXZpZHVhbCBvciBlbnRpdHkgdGhhdCBvZmZlcnMgdGhlIFdvcmsgdW5kZXIgdGhlIHRlcm1zIG9mIHRoaXMgTGljZW5zZS4NCiAgIDQuICJPcmlnaW5hbCBBdXRob3IiIG1lYW5zIHRoZSBpbmRpdmlkdWFsIG9yIGVudGl0eSB3aG8gY3JlYXRlZCB0aGUgV29yay4NCiAgIDUuICJXb3JrIiBtZWFucyB0aGUgY29weXJpZ2h0YWJsZSB3b3JrIG9mIGF1dGhvcnNoaXAgb2ZmZXJlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlLg0KICAgNi4gIllvdSIgbWVhbnMgYW4gaW5kaXZpZHVhbCBvciBlbnRpdHkgZXhlcmNpc2luZyByaWdodHMgdW5kZXIgdGhpcyBMaWNlbnNlIHdobyBoYXMgbm90IHByZXZpb3VzbHkgdmlvbGF0ZWQgdGhlIHRlcm1zIG9mIHRoaXMgTGljZW5zZSB3aXRoIHJlc3BlY3QgdG8gdGhlIFdvcmssIG9yIHdobyBoYXMgcmVjZWl2ZWQgZXhwcmVzcyBwZXJtaXNzaW9uIGZyb20gdGhlIExpY2Vuc29yIHRvIGV4ZXJjaXNlIHJpZ2h0cyB1bmRlciB0aGlzIExpY2Vuc2UgZGVzcGl0ZSBhIHByZXZpb3VzIHZpb2xhdGlvbi4NCg0KMi4gRmFpciBVc2UgUmlnaHRzLiBOb3RoaW5nIGluIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byByZWR1Y2UsIGxpbWl0LCBvciByZXN0cmljdCBhbnkgcmlnaHRzIGFyaXNpbmcgZnJvbSBmYWlyIHVzZSwgZmlyc3Qgc2FsZSBvciBvdGhlciBsaW1pdGF0aW9ucyBvbiB0aGUgZXhjbHVzaXZlIHJpZ2h0cyBvZiB0aGUgY29weXJpZ2h0IG93bmVyIHVuZGVyIGNvcHlyaWdodCBsYXcgb3Igb3RoZXIgYXBwbGljYWJsZSBsYXdzLg0KDQozLiBMaWNlbnNlIEdyYW50LiBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIExpY2Vuc2UsIExpY2Vuc29yIGhlcmVieSBncmFudHMgWW91IGEgd29ybGR3aWRlLCByb3lhbHR5LWZyZWUsIG5vbi1leGNsdXNpdmUsIHBlcnBldHVhbCAoZm9yIHRoZSBkdXJhdGlvbiBvZiB0aGUgYXBwbGljYWJsZSBjb3B5cmlnaHQpIGxpY2Vuc2UgdG8gZXhlcmNpc2UgdGhlIHJpZ2h0cyBpbiB0aGUgV29yayBhcyBzdGF0ZWQgYmVsb3c6DQoNCiAgIDEuIHRvIHJlcHJvZHVjZSB0aGUgV29yaywgdG8gaW5jb3Jwb3JhdGUgdGhlIFdvcmsgaW50byBvbmUgb3IgbW9yZSBDb2xsZWN0aXZlIFdvcmtzLCBhbmQgdG8gcmVwcm9kdWNlIHRoZSBXb3JrIGFzIGluY29ycG9yYXRlZCBpbiB0aGUgQ29sbGVjdGl2ZSBXb3JrczsNCiAgIDIuIHRvIGNyZWF0ZSBhbmQgcmVwcm9kdWNlIERlcml2YXRpdmUgV29ya3M7DQogICAzLiB0byBkaXN0cmlidXRlIGNvcGllcyBvciBwaG9ub3JlY29yZHMgb2YsIGRpc3BsYXkgcHVibGljbHksIHBlcmZvcm0gcHVibGljbHksIGFuZCBwZXJmb3JtIHB1YmxpY2x5IGJ5IG1lYW5zIG9mIGEgZGlnaXRhbCBhdWRpbyB0cmFuc21pc3Npb24gdGhlIFdvcmsgaW5jbHVkaW5nIGFzIGluY29ycG9yYXRlZCBpbiBDb2xsZWN0aXZlIFdvcmtzOw0KICAgNC4gdG8gZGlzdHJpYnV0ZSBjb3BpZXMgb3IgcGhvbm9yZWNvcmRzIG9mLCBkaXNwbGF5IHB1YmxpY2x5LCBwZXJmb3JtIHB1YmxpY2x5LCBhbmQgcGVyZm9ybSBwdWJsaWNseSBieSBtZWFucyBvZiBhIGRpZ2l0YWwgYXVkaW8gdHJhbnNtaXNzaW9uIERlcml2YXRpdmUgV29ya3M7DQoNClRoZSBhYm92ZSByaWdodHMgbWF5IGJlIGV4ZXJjaXNlZCBpbiBhbGwgbWVkaWEgYW5kIGZvcm1hdHMgd2hldGhlciBub3cga25vd24gb3IgaGVyZWFmdGVyIGRldmlzZWQuIFRoZSBhYm92ZSByaWdodHMgaW5jbHVkZSB0aGUgcmlnaHQgdG8gbWFrZSBzdWNoIG1vZGlmaWNhdGlvbnMgYXMgYXJlIHRlY2huaWNhbGx5IG5lY2Vzc2FyeSB0byBleGVyY2lzZSB0aGUgcmlnaHRzIGluIG90aGVyIG1lZGlhIGFuZCBmb3JtYXRzLiBBbGwgcmlnaHRzIG5vdCBleHByZXNzbHkgZ3JhbnRlZCBieSBMaWNlbnNvciBhcmUgaGVyZWJ5IHJlc2VydmVkLg0KDQo0LiBSZXN0cmljdGlvbnMuIFRoZSBsaWNlbnNlIGdyYW50ZWQgaW4gU2VjdGlvbiAzIGFib3ZlIGlzIGV4cHJlc3NseSBtYWRlIHN1YmplY3QgdG8gYW5kIGxpbWl0ZWQgYnkgdGhlIGZvbGxvd2luZyByZXN0cmljdGlvbnM6DQoNCiAgIDEuIFlvdSBtYXkgZGlzdHJpYnV0ZSwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgb3IgcHVibGljbHkgZGlnaXRhbGx5IHBlcmZvcm0gdGhlIFdvcmsgb25seSB1bmRlciB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlLCBhbmQgWW91IG11c3QgaW5jbHVkZSBhIGNvcHkgb2YsIG9yIHRoZSBVbmlmb3JtIFJlc291cmNlIElkZW50aWZpZXIgZm9yLCB0aGlzIExpY2Vuc2Ugd2l0aCBldmVyeSBjb3B5IG9yIHBob25vcmVjb3JkIG9mIHRoZSBXb3JrIFlvdSBkaXN0cmlidXRlLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBvciBwdWJsaWNseSBkaWdpdGFsbHkgcGVyZm9ybS4gWW91IG1heSBub3Qgb2ZmZXIgb3IgaW1wb3NlIGFueSB0ZXJtcyBvbiB0aGUgV29yayB0aGF0IGFsdGVyIG9yIHJlc3RyaWN0IHRoZSB0ZXJtcyBvZiB0aGlzIExpY2Vuc2Ugb3IgdGhlIHJlY2lwaWVudHMnIGV4ZXJjaXNlIG9mIHRoZSByaWdodHMgZ3JhbnRlZCBoZXJldW5kZXIuIFlvdSBtYXkgbm90IHN1YmxpY2Vuc2UgdGhlIFdvcmsuIFlvdSBtdXN0IGtlZXAgaW50YWN0IGFsbCBub3RpY2VzIHRoYXQgcmVmZXIgdG8gdGhpcyBMaWNlbnNlIGFuZCB0byB0aGUgZGlzY2xhaW1lciBvZiB3YXJyYW50aWVzLiBZb3UgbWF5IG5vdCBkaXN0cmlidXRlLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBvciBwdWJsaWNseSBkaWdpdGFsbHkgcGVyZm9ybSB0aGUgV29yayB3aXRoIGFueSB0ZWNobm9sb2dpY2FsIG1lYXN1cmVzIHRoYXQgY29udHJvbCBhY2Nlc3Mgb3IgdXNlIG9mIHRoZSBXb3JrIGluIGEgbWFubmVyIGluY29uc2lzdGVudCB3aXRoIHRoZSB0ZXJtcyBvZiB0aGlzIExpY2Vuc2UgQWdyZWVtZW50LiBUaGUgYWJvdmUgYXBwbGllcyB0byB0aGUgV29yayBhcyBpbmNvcnBvcmF0ZWQgaW4gYSBDb2xsZWN0aXZlIFdvcmssIGJ1dCB0aGlzIGRvZXMgbm90IHJlcXVpcmUgdGhlIENvbGxlY3RpdmUgV29yayBhcGFydCBmcm9tIHRoZSBXb3JrIGl0c2VsZiB0byBiZSBtYWRlIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgTGljZW5zZS4gSWYgWW91IGNyZWF0ZSBhIENvbGxlY3RpdmUgV29yaywgdXBvbiBub3RpY2UgZnJvbSBhbnkgTGljZW5zb3IgWW91IG11c3QsIHRvIHRoZSBleHRlbnQgcHJhY3RpY2FibGUsIHJlbW92ZSBmcm9tIHRoZSBDb2xsZWN0aXZlIFdvcmsgYW55IHJlZmVyZW5jZSB0byBzdWNoIExpY2Vuc29yIG9yIHRoZSBPcmlnaW5hbCBBdXRob3IsIGFzIHJlcXVlc3RlZC4gSWYgWW91IGNyZWF0ZSBhIERlcml2YXRpdmUgV29yaywgdXBvbiBub3RpY2UgZnJvbSBhbnkgTGljZW5zb3IgWW91IG11c3QsIHRvIHRoZSBleHRlbnQgcHJhY3RpY2FibGUsIHJlbW92ZSBmcm9tIHRoZSBEZXJpdmF0aXZlIFdvcmsgYW55IHJlZmVyZW5jZSB0byBzdWNoIExpY2Vuc29yIG9yIHRoZSBPcmlnaW5hbCBBdXRob3IsIGFzIHJlcXVlc3RlZC4NCiAgIDIuIFlvdSBtYXkgZGlzdHJpYnV0ZSwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgb3IgcHVibGljbHkgZGlnaXRhbGx5IHBlcmZvcm0gYSBEZXJpdmF0aXZlIFdvcmsgb25seSB1bmRlciB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlLCBhbmQgWW91IG11c3QgaW5jbHVkZSBhIGNvcHkgb2YsIG9yIHRoZSBVbmlmb3JtIFJlc291cmNlIElkZW50aWZpZXIgZm9yLCB0aGlzIExpY2Vuc2Ugd2l0aCBldmVyeSBjb3B5IG9yIHBob25vcmVjb3JkIG9mIGVhY2ggRGVyaXZhdGl2ZSBXb3JrIFlvdSBkaXN0cmlidXRlLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBvciBwdWJsaWNseSBkaWdpdGFsbHkgcGVyZm9ybS4gWW91IG1heSBub3Qgb2ZmZXIgb3IgaW1wb3NlIGFueSB0ZXJtcyBvbiB0aGUgRGVyaXZhdGl2ZSBXb3JrcyB0aGF0IGFsdGVyIG9yIHJlc3RyaWN0IHRoZSB0ZXJtcyBvZiB0aGlzIExpY2Vuc2Ugb3IgdGhlIHJlY2lwaWVudHMnIGV4ZXJjaXNlIG9mIHRoZSByaWdodHMgZ3JhbnRlZCBoZXJldW5kZXIsIGFuZCBZb3UgbXVzdCBrZWVwIGludGFjdCBhbGwgbm90aWNlcyB0aGF0IHJlZmVyIHRvIHRoaXMgTGljZW5zZSBhbmQgdG8gdGhlIGRpc2NsYWltZXIgb2Ygd2FycmFudGllcy4gWW91IG1heSBub3QgZGlzdHJpYnV0ZSwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgb3IgcHVibGljbHkgZGlnaXRhbGx5IHBlcmZvcm0gdGhlIERlcml2YXRpdmUgV29yayB3aXRoIGFueSB0ZWNobm9sb2dpY2FsIG1lYXN1cmVzIHRoYXQgY29udHJvbCBhY2Nlc3Mgb3IgdXNlIG9mIHRoZSBXb3JrIGluIGEgbWFubmVyIGluY29uc2lzdGVudCB3aXRoIHRoZSB0ZXJtcyBvZiB0aGlzIExpY2Vuc2UgQWdyZWVtZW50LiBUaGUgYWJvdmUgYXBwbGllcyB0byB0aGUgRGVyaXZhdGl2ZSBXb3JrIGFzIGluY29ycG9yYXRlZCBpbiBhIENvbGxlY3RpdmUgV29yaywgYnV0IHRoaXMgZG9lcyBub3QgcmVxdWlyZSB0aGUgQ29sbGVjdGl2ZSBXb3JrIGFwYXJ0IGZyb20gdGhlIERlcml2YXRpdmUgV29yayBpdHNlbGYgdG8gYmUgbWFkZSBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIExpY2Vuc2UuDQogICAzLiBZb3UgbWF5IG5vdCBleGVyY2lzZSBhbnkgb2YgdGhlIHJpZ2h0cyBncmFudGVkIHRvIFlvdSBpbiBTZWN0aW9uIDMgYWJvdmUgaW4gYW55IG1hbm5lciB0aGF0IGlzIHByaW1hcmlseSBpbnRlbmRlZCBmb3Igb3IgZGlyZWN0ZWQgdG93YXJkIGNvbW1lcmNpYWwgYWR2YW50YWdlIG9yIHByaXZhdGUgbW9uZXRhcnkgY29tcGVuc2F0aW9uLiBUaGUgZXhjaGFuZ2Ugb2YgdGhlIFdvcmsgZm9yIG90aGVyIGNvcHlyaWdodGVkIHdvcmtzIGJ5IG1lYW5zIG9mIGRpZ2l0YWwgZmlsZS1zaGFyaW5nIG9yIG90aGVyd2lzZSBzaGFsbCBub3QgYmUgY29uc2lkZXJlZCB0byBiZSBpbnRlbmRlZCBmb3Igb3IgZGlyZWN0ZWQgdG93YXJkIGNvbW1lcmNpYWwgYWR2YW50YWdlIG9yIHByaXZhdGUgbW9uZXRhcnkgY29tcGVuc2F0aW9uLCBwcm92aWRlZCB0aGVyZSBpcyBubyBwYXltZW50IG9mIGFueSBtb25ldGFyeSBjb21wZW5zYXRpb24gaW4gY29ubmVjdGlvbiB3aXRoIHRoZSBleGNoYW5nZSBvZiBjb3B5cmlnaHRlZCB3b3Jrcy4NCg0KNS4gUmVwcmVzZW50YXRpb25zLCBXYXJyYW50aWVzIGFuZCBEaXNjbGFpbWVyDQoNCiAgIDEuIEJ5IG9mZmVyaW5nIHRoZSBXb3JrIGZvciBwdWJsaWMgcmVsZWFzZSB1bmRlciB0aGlzIExpY2Vuc2UsIExpY2Vuc29yIHJlcHJlc2VudHMgYW5kIHdhcnJhbnRzIHRoYXQsIHRvIHRoZSBiZXN0IG9mIExpY2Vuc29yJ3Mga25vd2xlZGdlIGFmdGVyIHJlYXNvbmFibGUgaW5xdWlyeToNCiAgICAgICAgIDEuIExpY2Vuc29yIGhhcyBzZWN1cmVkIGFsbCByaWdodHMgaW4gdGhlIFdvcmsgbmVjZXNzYXJ5IHRvIGdyYW50IHRoZSBsaWNlbnNlIHJpZ2h0cyBoZXJldW5kZXIgYW5kIHRvIHBlcm1pdCB0aGUgbGF3ZnVsIGV4ZXJjaXNlIG9mIHRoZSByaWdodHMgZ3JhbnRlZCBoZXJldW5kZXIgd2l0aG91dCBZb3UgaGF2aW5nIGFueSBvYmxpZ2F0aW9uIHRvIHBheSBhbnkgcm95YWx0aWVzLCBjb21wdWxzb3J5IGxpY2Vuc2UgZmVlcywgcmVzaWR1YWxzIG9yIGFueSBvdGhlciBwYXltZW50czsNCiAgICAgICAgIDIuIFRoZSBXb3JrIGRvZXMgbm90IGluZnJpbmdlIHRoZSBjb3B5cmlnaHQsIHRyYWRlbWFyaywgcHVibGljaXR5IHJpZ2h0cywgY29tbW9uIGxhdyByaWdodHMgb3IgYW55IG90aGVyIHJpZ2h0IG9mIGFueSB0aGlyZCBwYXJ0eSBvciBjb25zdGl0dXRlIGRlZmFtYXRpb24sIGludmFzaW9uIG9mIHByaXZhY3kgb3Igb3RoZXIgdG9ydGlvdXMgaW5qdXJ5IHRvIGFueSB0aGlyZCBwYXJ0eS4NCiAgIDIuIEVYQ0VQVCBBUyBFWFBSRVNTTFkgU1RBVEVEIElOIFRISVMgTElDRU5TRSBPUiBPVEhFUldJU0UgQUdSRUVEIElOIFdSSVRJTkcgT1IgUkVRVUlSRUQgQlkgQVBQTElDQUJMRSBMQVcsIFRIRSBXT1JLIElTIExJQ0VOU0VEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgUkVHQVJESU5HIFRIRSBDT05URU5UUyBPUiBBQ0NVUkFDWSBPRiBUSEUgV09SSy4NCg0KNi4gTGltaXRhdGlvbiBvbiBMaWFiaWxpdHkuIEVYQ0VQVCBUTyBUSEUgRVhURU5UIFJFUVVJUkVEIEJZIEFQUExJQ0FCTEUgTEFXLCBBTkQgRVhDRVBUIEZPUiBEQU1BR0VTIEFSSVNJTkcgRlJPTSBMSUFCSUxJVFkgVE8gQSBUSElSRCBQQVJUWSBSRVNVTFRJTkcgRlJPTSBCUkVBQ0ggT0YgVEhFIFdBUlJBTlRJRVMgSU4gU0VDVElPTiA1LCBJTiBOTyBFVkVOVCBXSUxMIExJQ0VOU09SIEJFIExJQUJMRSBUTyBZT1UgT04gQU5ZIExFR0FMIFRIRU9SWSBGT1IgQU5ZIFNQRUNJQUwsIElOQ0lERU5UQUwsIENPTlNFUVVFTlRJQUwsIFBVTklUSVZFIE9SIEVYRU1QTEFSWSBEQU1BR0VTIEFSSVNJTkcgT1VUIE9GIFRISVMgTElDRU5TRSBPUiBUSEUgVVNFIE9GIFRIRSBXT1JLLCBFVkVOIElGIExJQ0VOU09SIEhBUyBCRUVOIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy4NCg0KNy4gVGVybWluYXRpb24NCg0KICAgMS4gVGhpcyBMaWNlbnNlIGFuZCB0aGUgcmlnaHRzIGdyYW50ZWQgaGVyZXVuZGVyIHdpbGwgdGVybWluYXRlIGF1dG9tYXRpY2FsbHkgdXBvbiBhbnkgYnJlYWNoIGJ5IFlvdSBvZiB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlLiBJbmRpdmlkdWFscyBvciBlbnRpdGllcyB3aG8gaGF2ZSByZWNlaXZlZCBEZXJpdmF0aXZlIFdvcmtzIG9yIENvbGxlY3RpdmUgV29ya3MgZnJvbSBZb3UgdW5kZXIgdGhpcyBMaWNlbnNlLCBob3dldmVyLCB3aWxsIG5vdCBoYXZlIHRoZWlyIGxpY2Vuc2VzIHRlcm1pbmF0ZWQgcHJvdmlkZWQgc3VjaCBpbmRpdmlkdWFscyBvciBlbnRpdGllcyByZW1haW4gaW4gZnVsbCBjb21wbGlhbmNlIHdpdGggdGhvc2UgbGljZW5zZXMuIFNlY3Rpb25zIDEsIDIsIDUsIDYsIDcsIGFuZCA4IHdpbGwgc3Vydml2ZSBhbnkgdGVybWluYXRpb24gb2YgdGhpcyBMaWNlbnNlLg0KICAgMi4gU3ViamVjdCB0byB0aGUgYWJvdmUgdGVybXMgYW5kIGNvbmRpdGlvbnMsIHRoZSBsaWNlbnNlIGdyYW50ZWQgaGVyZSBpcyBwZXJwZXR1YWwgKGZvciB0aGUgZHVyYXRpb24gb2YgdGhlIGFwcGxpY2FibGUgY29weXJpZ2h0IGluIHRoZSBXb3JrKS4gTm90d2l0aHN0YW5kaW5nIHRoZSBhYm92ZSwgTGljZW5zb3IgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHJlbGVhc2UgdGhlIFdvcmsgdW5kZXIgZGlmZmVyZW50IGxpY2Vuc2UgdGVybXMgb3IgdG8gc3RvcCBkaXN0cmlidXRpbmcgdGhlIFdvcmsgYXQgYW55IHRpbWU7IHByb3ZpZGVkLCBob3dldmVyIHRoYXQgYW55IHN1Y2ggZWxlY3Rpb24gd2lsbCBub3Qgc2VydmUgdG8gd2l0aGRyYXcgdGhpcyBMaWNlbnNlIChvciBhbnkgb3RoZXIgbGljZW5zZSB0aGF0IGhhcyBiZWVuLCBvciBpcyByZXF1aXJlZCB0byBiZSwgZ3JhbnRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlKSwgYW5kIHRoaXMgTGljZW5zZSB3aWxsIGNvbnRpbnVlIGluIGZ1bGwgZm9yY2UgYW5kIGVmZmVjdCB1bmxlc3MgdGVybWluYXRlZCBhcyBzdGF0ZWQgYWJvdmUuDQoNCjguIE1pc2NlbGxhbmVvdXMNCg0KICAgMS4gRWFjaCB0aW1lIFlvdSBkaXN0cmlidXRlIG9yIHB1YmxpY2x5IGRpZ2l0YWxseSBwZXJmb3JtIHRoZSBXb3JrIG9yIGEgQ29sbGVjdGl2ZSBXb3JrLCB0aGUgTGljZW5zb3Igb2ZmZXJzIHRvIHRoZSByZWNpcGllbnQgYSBsaWNlbnNlIHRvIHRoZSBXb3JrIG9uIHRoZSBzYW1lIHRlcm1zIGFuZCBjb25kaXRpb25zIGFzIHRoZSBsaWNlbnNlIGdyYW50ZWQgdG8gWW91IHVuZGVyIHRoaXMgTGljZW5zZS4NCiAgIDIuIEVhY2ggdGltZSBZb3UgZGlzdHJpYnV0ZSBvciBwdWJsaWNseSBkaWdpdGFsbHkgcGVyZm9ybSBhIERlcml2YXRpdmUgV29yaywgTGljZW5zb3Igb2ZmZXJzIHRvIHRoZSByZWNpcGllbnQgYSBsaWNlbnNlIHRvIHRoZSBvcmlnaW5hbCBXb3JrIG9uIHRoZSBzYW1lIHRlcm1zIGFuZCBjb25kaXRpb25zIGFzIHRoZSBsaWNlbnNlIGdyYW50ZWQgdG8gWW91IHVuZGVyIHRoaXMgTGljZW5zZS4NCiAgIDMuIElmIGFueSBwcm92aXNpb24gb2YgdGhpcyBMaWNlbnNlIGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IgZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBMaWNlbnNlLCBhbmQgd2l0aG91dCBmdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyB0byB0aGlzIGFncmVlbWVudCwgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4NCiAgIDQuIE5vIHRlcm0gb3IgcHJvdmlzaW9uIG9mIHRoaXMgTGljZW5zZSBzaGFsbCBiZSBkZWVtZWQgd2FpdmVkIGFuZCBubyBicmVhY2ggY29uc2VudGVkIHRvIHVubGVzcyBzdWNoIHdhaXZlciBvciBjb25zZW50IHNoYWxsIGJlIGluIHdyaXRpbmcgYW5kIHNpZ25lZCBieSB0aGUgcGFydHkgdG8gYmUgY2hhcmdlZCB3aXRoIHN1Y2ggd2FpdmVyIG9yIGNvbnNlbnQuDQogICA1LiBUaGlzIExpY2Vuc2UgY29uc3RpdHV0ZXMgdGhlIGVudGlyZSBhZ3JlZW1lbnQgYmV0d2VlbiB0aGUgcGFydGllcyB3aXRoIHJlc3BlY3QgdG8gdGhlIFdvcmsgbGljZW5zZWQgaGVyZS4gVGhlcmUgYXJlIG5vIHVuZGVyc3RhbmRpbmdzLCBhZ3JlZW1lbnRzIG9yIHJlcHJlc2VudGF0aW9ucyB3aXRoIHJlc3BlY3QgdG8gdGhlIFdvcmsgbm90IHNwZWNpZmllZCBoZXJlLiBMaWNlbnNvciBzaGFsbCBub3QgYmUgYm91bmQgYnkgYW55IGFkZGl0aW9uYWwgcHJvdmlzaW9ucyB0aGF0IG1heSBhcHBlYXIgaW4gYW55IGNvbW11bmljYXRpb24gZnJvbSBZb3UuIFRoaXMgTGljZW5zZSBtYXkgbm90IGJlIG1vZGlmaWVkIHdpdGhvdXQgdGhlIG11dHVhbCB3cml0dGVuIGFncmVlbWVudCBvZiB0aGUgTGljZW5zb3IgYW5kIFlvdS5odHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9uYy1zYS8xLjAvAEQAaQBnAGkAdABpAHoAZQBkACAAZABhAHQAYQAgAGMAbwBwAHkAcgBpAGcAaAB0ACAAMgAwADAAMAAtADIAMAAwADQAIABtAGkAYwBrAGUAeQBhAHYAZQBuAHUAZQAuAGMAbwBtACAAOgA6ACAAUwBvAG0AZQAgAHIAaQBnAGgAdABzACAAcgBlAHMAZQByAHYAZQBkACAAOgA6ACAARgBvAHIAIABwAGUAcgBzAG8AbgBhAGwALAAgAG4AbwBuAGMAbwBtAG0AZQByAGMAaQBhAGwAIAB1AHMAZQAgAG8AbgBsAHkAIAA6ADoAIABSAGUAbABlAGEAcwBlAGQAIAB1AG4AZABlAHIAIABDAHIAZQBhAHQAaQB2AGUAIABDAG8AbQBtAG8AbgBzACAATgBvAG4AQwBvAG0AbQBlAHIAYwBpAGEAbAAtAFMAaABhAHIAZQBBAGwAaQBrAGUAIABsAGkAYwBlAG4AcwBlACAAaAB0AHQAcAA6AC8ALwBjAHIAZQBhAHQAaQB2AGUAYwBvAG0AbQBvAG4AcwAuAG8AcgBnAC8AbABpAGMAZQBuAHMAZQBzAC8AbgBjAC0AcwBhAC8AMQAuADAALwBXAGEAbAB0AG8AZwByAGEAcABoACAAVQBJAEIAbwBsAGQATQBHAEIARgA6ACAAVwBhAGwAdAAgAEQAaQBzAG4AZQB5ACAAUwBjAHIAaQBwAHQAOgAgADIAMAAwADIAVwBhAGwAdABvAGcAcgBhAHAAaAAgAFUASQAgAEIAbwBsAGQAMQAuADAAVwBhAGwAdABvAGcAcgBhAHAAaABVAEkALQBCAG8AbABkAGgAdAB0AHAAOgAvAC8AbQBpAGMAawBlAHkAYQB2AGUAbgB1AGUALgBjAG8AbQAvAGYAbwBuAHQAcwBUAEgARQAgAFcATwBSAEsAIAAoAEEAUwAgAEQARQBGAEkATgBFAEQAIABCAEUATABPAFcAKQAgAEkAUwAgAFAAUgBPAFYASQBEAEUARAAgAFUATgBEAEUAUgAgAFQASABFACAAVABFAFIATQBTACAATwBGACAAVABIAEkAUwAgAEMAUgBFAEEAVABJAFYARQAgAEMATwBNAE0ATwBOAFMAIABQAFUAQgBMAEkAQwAgAEwASQBDAEUATgBTAEUAIAAoACIAQwBDAFAATAAiACAATwBSACAAIgBMAEkAQwBFAE4AUwBFACIAKQAuACAAVABIAEUAIABXAE8AUgBLACAASQBTACAAUABSAE8AVABFAEMAVABFAEQAIABCAFkAIABDAE8AUABZAFIASQBHAEgAVAAgAEEATgBEAC8ATwBSACAATwBUAEgARQBSACAAQQBQAFAATABJAEMAQQBCAEwARQAgAEwAQQBXAC4AIABBAE4AWQAgAFUAUwBFACAATwBGACAAVABIAEUAIABXAE8AUgBLACAATwBUAEgARQBSACAAVABIAEEATgAgAEEAUwAgAEEAVQBUAEgATwBSAEkAWgBFAEQAIABVAE4ARABFAFIAIABUAEgASQBTACAATABJAEMARQBOAFMARQAgAEkAUwAgAFAAUgBPAEgASQBCAEkAVABFAEQALgANAAoADQAKAEIAWQAgAEUAWABFAFIAQwBJAFMASQBOAEcAIABBAE4AWQAgAFIASQBHAEgAVABTACAAVABPACAAVABIAEUAIABXAE8AUgBLACAAUABSAE8AVgBJAEQARQBEACAASABFAFIARQAsACAAWQBPAFUAIABBAEMAQwBFAFAAVAAgAEEATgBEACAAQQBHAFIARQBFACAAVABPACAAQgBFACAAQgBPAFUATgBEACAAQgBZACAAVABIAEUAIABUAEUAUgBNAFMAIABPAEYAIABUAEgASQBTACAATABJAEMARQBOAFMARQAuACAAVABIAEUAIABMAEkAQwBFAE4AUwBPAFIAIABHAFIAQQBOAFQAUwAgAFkATwBVACAAVABIAEUAIABSAEkARwBIAFQAUwAgAEMATwBOAFQAQQBJAE4ARQBEACAASABFAFIARQAgAEkATgAgAEMATwBOAFMASQBEAEUAUgBBAFQASQBPAE4AIABPAEYAIABZAE8AVQBSACAAQQBDAEMARQBQAFQAQQBOAEMARQAgAE8ARgAgAFMAVQBDAEgAIABUAEUAUgBNAFMAIABBAE4ARAAgAEMATwBOAEQASQBUAEkATwBOAFMALgANAAoADQAKADEALgAgAEQAZQBmAGkAbgBpAHQAaQBvAG4AcwANAAoADQAKACAAIAAgADEALgAgACIAQwBvAGwAbABlAGMAdABpAHYAZQAgAFcAbwByAGsAIgAgAG0AZQBhAG4AcwAgAGEAIAB3AG8AcgBrACwAIABzAHUAYwBoACAAYQBzACAAYQAgAHAAZQByAGkAbwBkAGkAYwBhAGwAIABpAHMAcwB1AGUALAAgAGEAbgB0AGgAbwBsAG8AZwB5ACAAbwByACAAZQBuAGMAeQBjAGwAbwBwAGUAZABpAGEALAAgAGkAbgAgAHcAaABpAGMAaAAgAHQAaABlACAAVwBvAHIAawAgAGkAbgAgAGkAdABzACAAZQBuAHQAaQByAGUAdAB5ACAAaQBuACAAdQBuAG0AbwBkAGkAZgBpAGUAZAAgAGYAbwByAG0ALAAgAGEAbABvAG4AZwAgAHcAaQB0AGgAIABhACAAbgB1AG0AYgBlAHIAIABvAGYAIABvAHQAaABlAHIAIABjAG8AbgB0AHIAaQBiAHUAdABpAG8AbgBzACwAIABjAG8AbgBzAHQAaQB0AHUAdABpAG4AZwAgAHMAZQBwAGEAcgBhAHQAZQAgAGEAbgBkACAAaQBuAGQAZQBwAGUAbgBkAGUAbgB0ACAAdwBvAHIAawBzACAAaQBuACAAdABoAGUAbQBzAGUAbAB2AGUAcwAsACAAYQByAGUAIABhAHMAcwBlAG0AYgBsAGUAZAAgAGkAbgB0AG8AIABhACAAYwBvAGwAbABlAGMAdABpAHYAZQAgAHcAaABvAGwAZQAuACAAQQAgAHcAbwByAGsAIAB0AGgAYQB0ACAAYwBvAG4AcwB0AGkAdAB1AHQAZQBzACAAYQAgAEMAbwBsAGwAZQBjAHQAaQB2AGUAIABXAG8AcgBrACAAdwBpAGwAbAAgAG4AbwB0ACAAYgBlACAAYwBvAG4AcwBpAGQAZQByAGUAZAAgAGEAIABEAGUAcgBpAHYAYQB0AGkAdgBlACAAVwBvAHIAawAgACgAYQBzACAAZABlAGYAaQBuAGUAZAAgAGIAZQBsAG8AdwApACAAZgBvAHIAIAB0AGgAZQAgAHAAdQByAHAAbwBzAGUAcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlAC4ADQAKACAAIAAgADIALgAgACIARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAIgAgAG0AZQBhAG4AcwAgAGEAIAB3AG8AcgBrACAAYgBhAHMAZQBkACAAdQBwAG8AbgAgAHQAaABlACAAVwBvAHIAawAgAG8AcgAgAHUAcABvAG4AIAB0AGgAZQAgAFcAbwByAGsAIABhAG4AZAAgAG8AdABoAGUAcgAgAHAAcgBlAC0AZQB4AGkAcwB0AGkAbgBnACAAdwBvAHIAawBzACwAIABzAHUAYwBoACAAYQBzACAAYQAgAHQAcgBhAG4AcwBsAGEAdABpAG8AbgAsACAAbQB1AHMAaQBjAGEAbAAgAGEAcgByAGEAbgBnAGUAbQBlAG4AdAAsACAAZAByAGEAbQBhAHQAaQB6AGEAdABpAG8AbgAsACAAZgBpAGMAdABpAG8AbgBhAGwAaQB6AGEAdABpAG8AbgAsACAAbQBvAHQAaQBvAG4AIABwAGkAYwB0AHUAcgBlACAAdgBlAHIAcwBpAG8AbgAsACAAcwBvAHUAbgBkACAAcgBlAGMAbwByAGQAaQBuAGcALAAgAGEAcgB0ACAAcgBlAHAAcgBvAGQAdQBjAHQAaQBvAG4ALAAgAGEAYgByAGkAZABnAG0AZQBuAHQALAAgAGMAbwBuAGQAZQBuAHMAYQB0AGkAbwBuACwAIABvAHIAIABhAG4AeQAgAG8AdABoAGUAcgAgAGYAbwByAG0AIABpAG4AIAB3AGgAaQBjAGgAIAB0AGgAZQAgAFcAbwByAGsAIABtAGEAeQAgAGIAZQAgAHIAZQBjAGEAcwB0ACwAIAB0AHIAYQBuAHMAZgBvAHIAbQBlAGQALAAgAG8AcgAgAGEAZABhAHAAdABlAGQALAAgAGUAeABjAGUAcAB0ACAAdABoAGEAdAAgAGEAIAB3AG8AcgBrACAAdABoAGEAdAAgAGMAbwBuAHMAdABpAHQAdQB0AGUAcwAgAGEAIABDAG8AbABsAGUAYwB0AGkAdgBlACAAVwBvAHIAawAgAHcAaQBsAGwAIABuAG8AdAAgAGIAZQAgAGMAbwBuAHMAaQBkAGUAcgBlAGQAIABhACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAIABmAG8AcgAgAHQAaABlACAAcAB1AHIAcABvAHMAZQAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlAC4ADQAKACAAIAAgADMALgAgACIATABpAGMAZQBuAHMAbwByACIAIABtAGUAYQBuAHMAIAB0AGgAZQAgAGkAbgBkAGkAdgBpAGQAdQBhAGwAIABvAHIAIABlAG4AdABpAHQAeQAgAHQAaABhAHQAIABvAGYAZgBlAHIAcwAgAHQAaABlACAAVwBvAHIAawAgAHUAbgBkAGUAcgAgAHQAaABlACAAdABlAHIAbQBzACAAbwBmACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUALgANAAoAIAAgACAANAAuACAAIgBPAHIAaQBnAGkAbgBhAGwAIABBAHUAdABoAG8AcgAiACAAbQBlAGEAbgBzACAAdABoAGUAIABpAG4AZABpAHYAaQBkAHUAYQBsACAAbwByACAAZQBuAHQAaQB0AHkAIAB3AGgAbwAgAGMAcgBlAGEAdABlAGQAIAB0AGgAZQAgAFcAbwByAGsALgANAAoAIAAgACAANQAuACAAIgBXAG8AcgBrACIAIABtAGUAYQBuAHMAIAB0AGgAZQAgAGMAbwBwAHkAcgBpAGcAaAB0AGEAYgBsAGUAIAB3AG8AcgBrACAAbwBmACAAYQB1AHQAaABvAHIAcwBoAGkAcAAgAG8AZgBmAGUAcgBlAGQAIAB1AG4AZABlAHIAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlAC4ADQAKACAAIAAgADYALgAgACIAWQBvAHUAIgAgAG0AZQBhAG4AcwAgAGEAbgAgAGkAbgBkAGkAdgBpAGQAdQBhAGwAIABvAHIAIABlAG4AdABpAHQAeQAgAGUAeABlAHIAYwBpAHMAaQBuAGcAIAByAGkAZwBoAHQAcwAgAHUAbgBkAGUAcgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACAAdwBoAG8AIABoAGEAcwAgAG4AbwB0ACAAcAByAGUAdgBpAG8AdQBzAGwAeQAgAHYAaQBvAGwAYQB0AGUAZAAgAHQAaABlACAAdABlAHIAbQBzACAAbwBmACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUAIAB3AGkAdABoACAAcgBlAHMAcABlAGMAdAAgAHQAbwAgAHQAaABlACAAVwBvAHIAawAsACAAbwByACAAdwBoAG8AIABoAGEAcwAgAHIAZQBjAGUAaQB2AGUAZAAgAGUAeABwAHIAZQBzAHMAIABwAGUAcgBtAGkAcwBzAGkAbwBuACAAZgByAG8AbQAgAHQAaABlACAATABpAGMAZQBuAHMAbwByACAAdABvACAAZQB4AGUAcgBjAGkAcwBlACAAcgBpAGcAaAB0AHMAIAB1AG4AZABlAHIAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAGQAZQBzAHAAaQB0AGUAIABhACAAcAByAGUAdgBpAG8AdQBzACAAdgBpAG8AbABhAHQAaQBvAG4ALgANAAoADQAKADIALgAgAEYAYQBpAHIAIABVAHMAZQAgAFIAaQBnAGgAdABzAC4AIABOAG8AdABoAGkAbgBnACAAaQBuACAAdABoAGkAcwAgAGwAaQBjAGUAbgBzAGUAIABpAHMAIABpAG4AdABlAG4AZABlAGQAIAB0AG8AIAByAGUAZAB1AGMAZQAsACAAbABpAG0AaQB0ACwAIABvAHIAIAByAGUAcwB0AHIAaQBjAHQAIABhAG4AeQAgAHIAaQBnAGgAdABzACAAYQByAGkAcwBpAG4AZwAgAGYAcgBvAG0AIABmAGEAaQByACAAdQBzAGUALAAgAGYAaQByAHMAdAAgAHMAYQBsAGUAIABvAHIAIABvAHQAaABlAHIAIABsAGkAbQBpAHQAYQB0AGkAbwBuAHMAIABvAG4AIAB0AGgAZQAgAGUAeABjAGwAdQBzAGkAdgBlACAAcgBpAGcAaAB0AHMAIABvAGYAIAB0AGgAZQAgAGMAbwBwAHkAcgBpAGcAaAB0ACAAbwB3AG4AZQByACAAdQBuAGQAZQByACAAYwBvAHAAeQByAGkAZwBoAHQAIABsAGEAdwAgAG8AcgAgAG8AdABoAGUAcgAgAGEAcABwAGwAaQBjAGEAYgBsAGUAIABsAGEAdwBzAC4ADQAKAA0ACgAzAC4AIABMAGkAYwBlAG4AcwBlACAARwByAGEAbgB0AC4AIABTAHUAYgBqAGUAYwB0ACAAdABvACAAdABoAGUAIAB0AGUAcgBtAHMAIABhAG4AZAAgAGMAbwBuAGQAaQB0AGkAbwBuAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAsACAATABpAGMAZQBuAHMAbwByACAAaABlAHIAZQBiAHkAIABnAHIAYQBuAHQAcwAgAFkAbwB1ACAAYQAgAHcAbwByAGwAZAB3AGkAZABlACwAIAByAG8AeQBhAGwAdAB5AC0AZgByAGUAZQAsACAAbgBvAG4ALQBlAHgAYwBsAHUAcwBpAHYAZQAsACAAcABlAHIAcABlAHQAdQBhAGwAIAAoAGYAbwByACAAdABoAGUAIABkAHUAcgBhAHQAaQBvAG4AIABvAGYAIAB0AGgAZQAgAGEAcABwAGwAaQBjAGEAYgBsAGUAIABjAG8AcAB5AHIAaQBnAGgAdAApACAAbABpAGMAZQBuAHMAZQAgAHQAbwAgAGUAeABlAHIAYwBpAHMAZQAgAHQAaABlACAAcgBpAGcAaAB0AHMAIABpAG4AIAB0AGgAZQAgAFcAbwByAGsAIABhAHMAIABzAHQAYQB0AGUAZAAgAGIAZQBsAG8AdwA6AA0ACgANAAoAIAAgACAAMQAuACAAdABvACAAcgBlAHAAcgBvAGQAdQBjAGUAIAB0AGgAZQAgAFcAbwByAGsALAAgAHQAbwAgAGkAbgBjAG8AcgBwAG8AcgBhAHQAZQAgAHQAaABlACAAVwBvAHIAawAgAGkAbgB0AG8AIABvAG4AZQAgAG8AcgAgAG0AbwByAGUAIABDAG8AbABsAGUAYwB0AGkAdgBlACAAVwBvAHIAawBzACwAIABhAG4AZAAgAHQAbwAgAHIAZQBwAHIAbwBkAHUAYwBlACAAdABoAGUAIABXAG8AcgBrACAAYQBzACAAaQBuAGMAbwByAHAAbwByAGEAdABlAGQAIABpAG4AIAB0AGgAZQAgAEMAbwBsAGwAZQBjAHQAaQB2AGUAIABXAG8AcgBrAHMAOwANAAoAIAAgACAAMgAuACAAdABvACAAYwByAGUAYQB0AGUAIABhAG4AZAAgAHIAZQBwAHIAbwBkAHUAYwBlACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAcwA7AA0ACgAgACAAIAAzAC4AIAB0AG8AIABkAGkAcwB0AHIAaQBiAHUAdABlACAAYwBvAHAAaQBlAHMAIABvAHIAIABwAGgAbwBuAG8AcgBlAGMAbwByAGQAcwAgAG8AZgAsACAAZABpAHMAcABsAGEAeQAgAHAAdQBiAGwAaQBjAGwAeQAsACAAcABlAHIAZgBvAHIAbQAgAHAAdQBiAGwAaQBjAGwAeQAsACAAYQBuAGQAIABwAGUAcgBmAG8AcgBtACAAcAB1AGIAbABpAGMAbAB5ACAAYgB5ACAAbQBlAGEAbgBzACAAbwBmACAAYQAgAGQAaQBnAGkAdABhAGwAIABhAHUAZABpAG8AIAB0AHIAYQBuAHMAbQBpAHMAcwBpAG8AbgAgAHQAaABlACAAVwBvAHIAawAgAGkAbgBjAGwAdQBkAGkAbgBnACAAYQBzACAAaQBuAGMAbwByAHAAbwByAGEAdABlAGQAIABpAG4AIABDAG8AbABsAGUAYwB0AGkAdgBlACAAVwBvAHIAawBzADsADQAKACAAIAAgADQALgAgAHQAbwAgAGQAaQBzAHQAcgBpAGIAdQB0AGUAIABjAG8AcABpAGUAcwAgAG8AcgAgAHAAaABvAG4AbwByAGUAYwBvAHIAZABzACAAbwBmACwAIABkAGkAcwBwAGwAYQB5ACAAcAB1AGIAbABpAGMAbAB5ACwAIABwAGUAcgBmAG8AcgBtACAAcAB1AGIAbABpAGMAbAB5ACwAIABhAG4AZAAgAHAAZQByAGYAbwByAG0AIABwAHUAYgBsAGkAYwBsAHkAIABiAHkAIABtAGUAYQBuAHMAIABvAGYAIABhACAAZABpAGcAaQB0AGEAbAAgAGEAdQBkAGkAbwAgAHQAcgBhAG4AcwBtAGkAcwBzAGkAbwBuACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAcwA7AA0ACgANAAoAVABoAGUAIABhAGIAbwB2AGUAIAByAGkAZwBoAHQAcwAgAG0AYQB5ACAAYgBlACAAZQB4AGUAcgBjAGkAcwBlAGQAIABpAG4AIABhAGwAbAAgAG0AZQBkAGkAYQAgAGEAbgBkACAAZgBvAHIAbQBhAHQAcwAgAHcAaABlAHQAaABlAHIAIABuAG8AdwAgAGsAbgBvAHcAbgAgAG8AcgAgAGgAZQByAGUAYQBmAHQAZQByACAAZABlAHYAaQBzAGUAZAAuACAAVABoAGUAIABhAGIAbwB2AGUAIAByAGkAZwBoAHQAcwAgAGkAbgBjAGwAdQBkAGUAIAB0AGgAZQAgAHIAaQBnAGgAdAAgAHQAbwAgAG0AYQBrAGUAIABzAHUAYwBoACAAbQBvAGQAaQBmAGkAYwBhAHQAaQBvAG4AcwAgAGEAcwAgAGEAcgBlACAAdABlAGMAaABuAGkAYwBhAGwAbAB5ACAAbgBlAGMAZQBzAHMAYQByAHkAIAB0AG8AIABlAHgAZQByAGMAaQBzAGUAIAB0AGgAZQAgAHIAaQBnAGgAdABzACAAaQBuACAAbwB0AGgAZQByACAAbQBlAGQAaQBhACAAYQBuAGQAIABmAG8AcgBtAGEAdABzAC4AIABBAGwAbAAgAHIAaQBnAGgAdABzACAAbgBvAHQAIABlAHgAcAByAGUAcwBzAGwAeQAgAGcAcgBhAG4AdABlAGQAIABiAHkAIABMAGkAYwBlAG4AcwBvAHIAIABhAHIAZQAgAGgAZQByAGUAYgB5ACAAcgBlAHMAZQByAHYAZQBkAC4ADQAKAA0ACgA0AC4AIABSAGUAcwB0AHIAaQBjAHQAaQBvAG4AcwAuACAAVABoAGUAIABsAGkAYwBlAG4AcwBlACAAZwByAGEAbgB0AGUAZAAgAGkAbgAgAFMAZQBjAHQAaQBvAG4AIAAzACAAYQBiAG8AdgBlACAAaQBzACAAZQB4AHAAcgBlAHMAcwBsAHkAIABtAGEAZABlACAAcwB1AGIAagBlAGMAdAAgAHQAbwAgAGEAbgBkACAAbABpAG0AaQB0AGUAZAAgAGIAeQAgAHQAaABlACAAZgBvAGwAbABvAHcAaQBuAGcAIAByAGUAcwB0AHIAaQBjAHQAaQBvAG4AcwA6AA0ACgANAAoAIAAgACAAMQAuACAAWQBvAHUAIABtAGEAeQAgAGQAaQBzAHQAcgBpAGIAdQB0AGUALAAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBzAHAAbABhAHkALAAgAHAAdQBiAGwAaQBjAGwAeQAgAHAAZQByAGYAbwByAG0ALAAgAG8AcgAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBnAGkAdABhAGwAbAB5ACAAcABlAHIAZgBvAHIAbQAgAHQAaABlACAAVwBvAHIAawAgAG8AbgBsAHkAIAB1AG4AZABlAHIAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACwAIABhAG4AZAAgAFkAbwB1ACAAbQB1AHMAdAAgAGkAbgBjAGwAdQBkAGUAIABhACAAYwBvAHAAeQAgAG8AZgAsACAAbwByACAAdABoAGUAIABVAG4AaQBmAG8AcgBtACAAUgBlAHMAbwB1AHIAYwBlACAASQBkAGUAbgB0AGkAZgBpAGUAcgAgAGYAbwByACwAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAHcAaQB0AGgAIABlAHYAZQByAHkAIABjAG8AcAB5ACAAbwByACAAcABoAG8AbgBvAHIAZQBjAG8AcgBkACAAbwBmACAAdABoAGUAIABXAG8AcgBrACAAWQBvAHUAIABkAGkAcwB0AHIAaQBiAHUAdABlACwAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAcwBwAGwAYQB5ACwAIABwAHUAYgBsAGkAYwBsAHkAIABwAGUAcgBmAG8AcgBtACwAIABvAHIAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAZwBpAHQAYQBsAGwAeQAgAHAAZQByAGYAbwByAG0ALgAgAFkAbwB1ACAAbQBhAHkAIABuAG8AdAAgAG8AZgBmAGUAcgAgAG8AcgAgAGkAbQBwAG8AcwBlACAAYQBuAHkAIAB0AGUAcgBtAHMAIABvAG4AIAB0AGgAZQAgAFcAbwByAGsAIAB0AGgAYQB0ACAAYQBsAHQAZQByACAAbwByACAAcgBlAHMAdAByAGkAYwB0ACAAdABoAGUAIAB0AGUAcgBtAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAG8AcgAgAHQAaABlACAAcgBlAGMAaQBwAGkAZQBuAHQAcwAnACAAZQB4AGUAcgBjAGkAcwBlACAAbwBmACAAdABoAGUAIAByAGkAZwBoAHQAcwAgAGcAcgBhAG4AdABlAGQAIABoAGUAcgBlAHUAbgBkAGUAcgAuACAAWQBvAHUAIABtAGEAeQAgAG4AbwB0ACAAcwB1AGIAbABpAGMAZQBuAHMAZQAgAHQAaABlACAAVwBvAHIAawAuACAAWQBvAHUAIABtAHUAcwB0ACAAawBlAGUAcAAgAGkAbgB0AGEAYwB0ACAAYQBsAGwAIABuAG8AdABpAGMAZQBzACAAdABoAGEAdAAgAHIAZQBmAGUAcgAgAHQAbwAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACAAYQBuAGQAIAB0AG8AIAB0AGgAZQAgAGQAaQBzAGMAbABhAGkAbQBlAHIAIABvAGYAIAB3AGEAcgByAGEAbgB0AGkAZQBzAC4AIABZAG8AdQAgAG0AYQB5ACAAbgBvAHQAIABkAGkAcwB0AHIAaQBiAHUAdABlACwAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAcwBwAGwAYQB5ACwAIABwAHUAYgBsAGkAYwBsAHkAIABwAGUAcgBmAG8AcgBtACwAIABvAHIAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAZwBpAHQAYQBsAGwAeQAgAHAAZQByAGYAbwByAG0AIAB0AGgAZQAgAFcAbwByAGsAIAB3AGkAdABoACAAYQBuAHkAIAB0AGUAYwBoAG4AbwBsAG8AZwBpAGMAYQBsACAAbQBlAGEAcwB1AHIAZQBzACAAdABoAGEAdAAgAGMAbwBuAHQAcgBvAGwAIABhAGMAYwBlAHMAcwAgAG8AcgAgAHUAcwBlACAAbwBmACAAdABoAGUAIABXAG8AcgBrACAAaQBuACAAYQAgAG0AYQBuAG4AZQByACAAaQBuAGMAbwBuAHMAaQBzAHQAZQBuAHQAIAB3AGkAdABoACAAdABoAGUAIAB0AGUAcgBtAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAEEAZwByAGUAZQBtAGUAbgB0AC4AIABUAGgAZQAgAGEAYgBvAHYAZQAgAGEAcABwAGwAaQBlAHMAIAB0AG8AIAB0AGgAZQAgAFcAbwByAGsAIABhAHMAIABpAG4AYwBvAHIAcABvAHIAYQB0AGUAZAAgAGkAbgAgAGEAIABDAG8AbABsAGUAYwB0AGkAdgBlACAAVwBvAHIAawAsACAAYgB1AHQAIAB0AGgAaQBzACAAZABvAGUAcwAgAG4AbwB0ACAAcgBlAHEAdQBpAHIAZQAgAHQAaABlACAAQwBvAGwAbABlAGMAdABpAHYAZQAgAFcAbwByAGsAIABhAHAAYQByAHQAIABmAHIAbwBtACAAdABoAGUAIABXAG8AcgBrACAAaQB0AHMAZQBsAGYAIAB0AG8AIABiAGUAIABtAGEAZABlACAAcwB1AGIAagBlAGMAdAAgAHQAbwAgAHQAaABlACAAdABlAHIAbQBzACAAbwBmACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUALgAgAEkAZgAgAFkAbwB1ACAAYwByAGUAYQB0AGUAIABhACAAQwBvAGwAbABlAGMAdABpAHYAZQAgAFcAbwByAGsALAAgAHUAcABvAG4AIABuAG8AdABpAGMAZQAgAGYAcgBvAG0AIABhAG4AeQAgAEwAaQBjAGUAbgBzAG8AcgAgAFkAbwB1ACAAbQB1AHMAdAAsACAAdABvACAAdABoAGUAIABlAHgAdABlAG4AdAAgAHAAcgBhAGMAdABpAGMAYQBiAGwAZQAsACAAcgBlAG0AbwB2AGUAIABmAHIAbwBtACAAdABoAGUAIABDAG8AbABsAGUAYwB0AGkAdgBlACAAVwBvAHIAawAgAGEAbgB5ACAAcgBlAGYAZQByAGUAbgBjAGUAIAB0AG8AIABzAHUAYwBoACAATABpAGMAZQBuAHMAbwByACAAbwByACAAdABoAGUAIABPAHIAaQBnAGkAbgBhAGwAIABBAHUAdABoAG8AcgAsACAAYQBzACAAcgBlAHEAdQBlAHMAdABlAGQALgAgAEkAZgAgAFkAbwB1ACAAYwByAGUAYQB0AGUAIABhACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsALAAgAHUAcABvAG4AIABuAG8AdABpAGMAZQAgAGYAcgBvAG0AIABhAG4AeQAgAEwAaQBjAGUAbgBzAG8AcgAgAFkAbwB1ACAAbQB1AHMAdAAsACAAdABvACAAdABoAGUAIABlAHgAdABlAG4AdAAgAHAAcgBhAGMAdABpAGMAYQBiAGwAZQAsACAAcgBlAG0AbwB2AGUAIABmAHIAbwBtACAAdABoAGUAIABEAGUAcgBpAHYAYQB0AGkAdgBlACAAVwBvAHIAawAgAGEAbgB5ACAAcgBlAGYAZQByAGUAbgBjAGUAIAB0AG8AIABzAHUAYwBoACAATABpAGMAZQBuAHMAbwByACAAbwByACAAdABoAGUAIABPAHIAaQBnAGkAbgBhAGwAIABBAHUAdABoAG8AcgAsACAAYQBzACAAcgBlAHEAdQBlAHMAdABlAGQALgANAAoAIAAgACAAMgAuACAAWQBvAHUAIABtAGEAeQAgAGQAaQBzAHQAcgBpAGIAdQB0AGUALAAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBzAHAAbABhAHkALAAgAHAAdQBiAGwAaQBjAGwAeQAgAHAAZQByAGYAbwByAG0ALAAgAG8AcgAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBnAGkAdABhAGwAbAB5ACAAcABlAHIAZgBvAHIAbQAgAGEAIABEAGUAcgBpAHYAYQB0AGkAdgBlACAAVwBvAHIAawAgAG8AbgBsAHkAIAB1AG4AZABlAHIAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACwAIABhAG4AZAAgAFkAbwB1ACAAbQB1AHMAdAAgAGkAbgBjAGwAdQBkAGUAIABhACAAYwBvAHAAeQAgAG8AZgAsACAAbwByACAAdABoAGUAIABVAG4AaQBmAG8AcgBtACAAUgBlAHMAbwB1AHIAYwBlACAASQBkAGUAbgB0AGkAZgBpAGUAcgAgAGYAbwByACwAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAHcAaQB0AGgAIABlAHYAZQByAHkAIABjAG8AcAB5ACAAbwByACAAcABoAG8AbgBvAHIAZQBjAG8AcgBkACAAbwBmACAAZQBhAGMAaAAgAEQAZQByAGkAdgBhAHQAaQB2AGUAIABXAG8AcgBrACAAWQBvAHUAIABkAGkAcwB0AHIAaQBiAHUAdABlACwAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAcwBwAGwAYQB5ACwAIABwAHUAYgBsAGkAYwBsAHkAIABwAGUAcgBmAG8AcgBtACwAIABvAHIAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAZwBpAHQAYQBsAGwAeQAgAHAAZQByAGYAbwByAG0ALgAgAFkAbwB1ACAAbQBhAHkAIABuAG8AdAAgAG8AZgBmAGUAcgAgAG8AcgAgAGkAbQBwAG8AcwBlACAAYQBuAHkAIAB0AGUAcgBtAHMAIABvAG4AIAB0AGgAZQAgAEQAZQByAGkAdgBhAHQAaQB2AGUAIABXAG8AcgBrAHMAIAB0AGgAYQB0ACAAYQBsAHQAZQByACAAbwByACAAcgBlAHMAdAByAGkAYwB0ACAAdABoAGUAIAB0AGUAcgBtAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAG8AcgAgAHQAaABlACAAcgBlAGMAaQBwAGkAZQBuAHQAcwAnACAAZQB4AGUAcgBjAGkAcwBlACAAbwBmACAAdABoAGUAIAByAGkAZwBoAHQAcwAgAGcAcgBhAG4AdABlAGQAIABoAGUAcgBlAHUAbgBkAGUAcgAsACAAYQBuAGQAIABZAG8AdQAgAG0AdQBzAHQAIABrAGUAZQBwACAAaQBuAHQAYQBjAHQAIABhAGwAbAAgAG4AbwB0AGkAYwBlAHMAIAB0AGgAYQB0ACAAcgBlAGYAZQByACAAdABvACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUAIABhAG4AZAAgAHQAbwAgAHQAaABlACAAZABpAHMAYwBsAGEAaQBtAGUAcgAgAG8AZgAgAHcAYQByAHIAYQBuAHQAaQBlAHMALgAgAFkAbwB1ACAAbQBhAHkAIABuAG8AdAAgAGQAaQBzAHQAcgBpAGIAdQB0AGUALAAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBzAHAAbABhAHkALAAgAHAAdQBiAGwAaQBjAGwAeQAgAHAAZQByAGYAbwByAG0ALAAgAG8AcgAgAHAAdQBiAGwAaQBjAGwAeQAgAGQAaQBnAGkAdABhAGwAbAB5ACAAcABlAHIAZgBvAHIAbQAgAHQAaABlACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAIAB3AGkAdABoACAAYQBuAHkAIAB0AGUAYwBoAG4AbwBsAG8AZwBpAGMAYQBsACAAbQBlAGEAcwB1AHIAZQBzACAAdABoAGEAdAAgAGMAbwBuAHQAcgBvAGwAIABhAGMAYwBlAHMAcwAgAG8AcgAgAHUAcwBlACAAbwBmACAAdABoAGUAIABXAG8AcgBrACAAaQBuACAAYQAgAG0AYQBuAG4AZQByACAAaQBuAGMAbwBuAHMAaQBzAHQAZQBuAHQAIAB3AGkAdABoACAAdABoAGUAIAB0AGUAcgBtAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAgAEEAZwByAGUAZQBtAGUAbgB0AC4AIABUAGgAZQAgAGEAYgBvAHYAZQAgAGEAcABwAGwAaQBlAHMAIAB0AG8AIAB0AGgAZQAgAEQAZQByAGkAdgBhAHQAaQB2AGUAIABXAG8AcgBrACAAYQBzACAAaQBuAGMAbwByAHAAbwByAGEAdABlAGQAIABpAG4AIABhACAAQwBvAGwAbABlAGMAdABpAHYAZQAgAFcAbwByAGsALAAgAGIAdQB0ACAAdABoAGkAcwAgAGQAbwBlAHMAIABuAG8AdAAgAHIAZQBxAHUAaQByAGUAIAB0AGgAZQAgAEMAbwBsAGwAZQBjAHQAaQB2AGUAIABXAG8AcgBrACAAYQBwAGEAcgB0ACAAZgByAG8AbQAgAHQAaABlACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsAIABpAHQAcwBlAGwAZgAgAHQAbwAgAGIAZQAgAG0AYQBkAGUAIABzAHUAYgBqAGUAYwB0ACAAdABvACAAdABoAGUAIAB0AGUAcgBtAHMAIABvAGYAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAuAA0ACgAgACAAIAAzAC4AIABZAG8AdQAgAG0AYQB5ACAAbgBvAHQAIABlAHgAZQByAGMAaQBzAGUAIABhAG4AeQAgAG8AZgAgAHQAaABlACAAcgBpAGcAaAB0AHMAIABnAHIAYQBuAHQAZQBkACAAdABvACAAWQBvAHUAIABpAG4AIABTAGUAYwB0AGkAbwBuACAAMwAgAGEAYgBvAHYAZQAgAGkAbgAgAGEAbgB5ACAAbQBhAG4AbgBlAHIAIAB0AGgAYQB0ACAAaQBzACAAcAByAGkAbQBhAHIAaQBsAHkAIABpAG4AdABlAG4AZABlAGQAIABmAG8AcgAgAG8AcgAgAGQAaQByAGUAYwB0AGUAZAAgAHQAbwB3AGEAcgBkACAAYwBvAG0AbQBlAHIAYwBpAGEAbAAgAGEAZAB2AGEAbgB0AGEAZwBlACAAbwByACAAcAByAGkAdgBhAHQAZQAgAG0AbwBuAGUAdABhAHIAeQAgAGMAbwBtAHAAZQBuAHMAYQB0AGkAbwBuAC4AIABUAGgAZQAgAGUAeABjAGgAYQBuAGcAZQAgAG8AZgAgAHQAaABlACAAVwBvAHIAawAgAGYAbwByACAAbwB0AGgAZQByACAAYwBvAHAAeQByAGkAZwBoAHQAZQBkACAAdwBvAHIAawBzACAAYgB5ACAAbQBlAGEAbgBzACAAbwBmACAAZABpAGcAaQB0AGEAbAAgAGYAaQBsAGUALQBzAGgAYQByAGkAbgBnACAAbwByACAAbwB0AGgAZQByAHcAaQBzAGUAIABzAGgAYQBsAGwAIABuAG8AdAAgAGIAZQAgAGMAbwBuAHMAaQBkAGUAcgBlAGQAIAB0AG8AIABiAGUAIABpAG4AdABlAG4AZABlAGQAIABmAG8AcgAgAG8AcgAgAGQAaQByAGUAYwB0AGUAZAAgAHQAbwB3AGEAcgBkACAAYwBvAG0AbQBlAHIAYwBpAGEAbAAgAGEAZAB2AGEAbgB0AGEAZwBlACAAbwByACAAcAByAGkAdgBhAHQAZQAgAG0AbwBuAGUAdABhAHIAeQAgAGMAbwBtAHAAZQBuAHMAYQB0AGkAbwBuACwAIABwAHIAbwB2AGkAZABlAGQAIAB0AGgAZQByAGUAIABpAHMAIABuAG8AIABwAGEAeQBtAGUAbgB0ACAAbwBmACAAYQBuAHkAIABtAG8AbgBlAHQAYQByAHkAIABjAG8AbQBwAGUAbgBzAGEAdABpAG8AbgAgAGkAbgAgAGMAbwBuAG4AZQBjAHQAaQBvAG4AIAB3AGkAdABoACAAdABoAGUAIABlAHgAYwBoAGEAbgBnAGUAIABvAGYAIABjAG8AcAB5AHIAaQBnAGgAdABlAGQAIAB3AG8AcgBrAHMALgANAAoADQAKADUALgAgAFIAZQBwAHIAZQBzAGUAbgB0AGEAdABpAG8AbgBzACwAIABXAGEAcgByAGEAbgB0AGkAZQBzACAAYQBuAGQAIABEAGkAcwBjAGwAYQBpAG0AZQByAA0ACgANAAoAIAAgACAAMQAuACAAQgB5ACAAbwBmAGYAZQByAGkAbgBnACAAdABoAGUAIABXAG8AcgBrACAAZgBvAHIAIABwAHUAYgBsAGkAYwAgAHIAZQBsAGUAYQBzAGUAIAB1AG4AZABlAHIAIAB0AGgAaQBzACAATABpAGMAZQBuAHMAZQAsACAATABpAGMAZQBuAHMAbwByACAAcgBlAHAAcgBlAHMAZQBuAHQAcwAgAGEAbgBkACAAdwBhAHIAcgBhAG4AdABzACAAdABoAGEAdAAsACAAdABvACAAdABoAGUAIABiAGUAcwB0ACAAbwBmACAATABpAGMAZQBuAHMAbwByACcAcwAgAGsAbgBvAHcAbABlAGQAZwBlACAAYQBmAHQAZQByACAAcgBlAGEAcwBvAG4AYQBiAGwAZQAgAGkAbgBxAHUAaQByAHkAOgANAAoAIAAgACAAIAAgACAAIAAgACAAMQAuACAATABpAGMAZQBuAHMAbwByACAAaABhAHMAIABzAGUAYwB1AHIAZQBkACAAYQBsAGwAIAByAGkAZwBoAHQAcwAgAGkAbgAgAHQAaABlACAAVwBvAHIAawAgAG4AZQBjAGUAcwBzAGEAcgB5ACAAdABvACAAZwByAGEAbgB0ACAAdABoAGUAIABsAGkAYwBlAG4AcwBlACAAcgBpAGcAaAB0AHMAIABoAGUAcgBlAHUAbgBkAGUAcgAgAGEAbgBkACAAdABvACAAcABlAHIAbQBpAHQAIAB0AGgAZQAgAGwAYQB3AGYAdQBsACAAZQB4AGUAcgBjAGkAcwBlACAAbwBmACAAdABoAGUAIAByAGkAZwBoAHQAcwAgAGcAcgBhAG4AdABlAGQAIABoAGUAcgBlAHUAbgBkAGUAcgAgAHcAaQB0AGgAbwB1AHQAIABZAG8AdQAgAGgAYQB2AGkAbgBnACAAYQBuAHkAIABvAGIAbABpAGcAYQB0AGkAbwBuACAAdABvACAAcABhAHkAIABhAG4AeQAgAHIAbwB5AGEAbAB0AGkAZQBzACwAIABjAG8AbQBwAHUAbABzAG8AcgB5ACAAbABpAGMAZQBuAHMAZQAgAGYAZQBlAHMALAAgAHIAZQBzAGkAZAB1AGEAbABzACAAbwByACAAYQBuAHkAIABvAHQAaABlAHIAIABwAGEAeQBtAGUAbgB0AHMAOwANAAoAIAAgACAAIAAgACAAIAAgACAAMgAuACAAVABoAGUAIABXAG8AcgBrACAAZABvAGUAcwAgAG4AbwB0ACAAaQBuAGYAcgBpAG4AZwBlACAAdABoAGUAIABjAG8AcAB5AHIAaQBnAGgAdAAsACAAdAByAGEAZABlAG0AYQByAGsALAAgAHAAdQBiAGwAaQBjAGkAdAB5ACAAcgBpAGcAaAB0AHMALAAgAGMAbwBtAG0AbwBuACAAbABhAHcAIAByAGkAZwBoAHQAcwAgAG8AcgAgAGEAbgB5ACAAbwB0AGgAZQByACAAcgBpAGcAaAB0ACAAbwBmACAAYQBuAHkAIAB0AGgAaQByAGQAIABwAGEAcgB0AHkAIABvAHIAIABjAG8AbgBzAHQAaQB0AHUAdABlACAAZABlAGYAYQBtAGEAdABpAG8AbgAsACAAaQBuAHYAYQBzAGkAbwBuACAAbwBmACAAcAByAGkAdgBhAGMAeQAgAG8AcgAgAG8AdABoAGUAcgAgAHQAbwByAHQAaQBvAHUAcwAgAGkAbgBqAHUAcgB5ACAAdABvACAAYQBuAHkAIAB0AGgAaQByAGQAIABwAGEAcgB0AHkALgANAAoAIAAgACAAMgAuACAARQBYAEMARQBQAFQAIABBAFMAIABFAFgAUABSAEUAUwBTAEwAWQAgAFMAVABBAFQARQBEACAASQBOACAAVABIAEkAUwAgAEwASQBDAEUATgBTAEUAIABPAFIAIABPAFQASABFAFIAVwBJAFMARQAgAEEARwBSAEUARQBEACAASQBOACAAVwBSAEkAVABJAE4ARwAgAE8AUgAgAFIARQBRAFUASQBSAEUARAAgAEIAWQAgAEEAUABQAEwASQBDAEEAQgBMAEUAIABMAEEAVwAsACAAVABIAEUAIABXAE8AUgBLACAASQBTACAATABJAEMARQBOAFMARQBEACAATwBOACAAQQBOACAAIgBBAFMAIABJAFMAIgAgAEIAQQBTAEkAUwAsACAAVwBJAFQASABPAFUAVAAgAFcAQQBSAFIAQQBOAFQASQBFAFMAIABPAEYAIABBAE4AWQAgAEsASQBOAEQALAAgAEUASQBUAEgARQBSACAARQBYAFAAUgBFAFMAUwAgAE8AUgAgAEkATQBQAEwASQBFAEQAIABJAE4AQwBMAFUARABJAE4ARwAsACAAVwBJAFQASABPAFUAVAAgAEwASQBNAEkAVABBAFQASQBPAE4ALAAgAEEATgBZACAAVwBBAFIAUgBBAE4AVABJAEUAUwAgAFIARQBHAEEAUgBEAEkATgBHACAAVABIAEUAIABDAE8ATgBUAEUATgBUAFMAIABPAFIAIABBAEMAQwBVAFIAQQBDAFkAIABPAEYAIABUAEgARQAgAFcATwBSAEsALgANAAoADQAKADYALgAgAEwAaQBtAGkAdABhAHQAaQBvAG4AIABvAG4AIABMAGkAYQBiAGkAbABpAHQAeQAuACAARQBYAEMARQBQAFQAIABUAE8AIABUAEgARQAgAEUAWABUAEUATgBUACAAUgBFAFEAVQBJAFIARQBEACAAQgBZACAAQQBQAFAATABJAEMAQQBCAEwARQAgAEwAQQBXACwAIABBAE4ARAAgAEUAWABDAEUAUABUACAARgBPAFIAIABEAEEATQBBAEcARQBTACAAQQBSAEkAUwBJAE4ARwAgAEYAUgBPAE0AIABMAEkAQQBCAEkATABJAFQAWQAgAFQATwAgAEEAIABUAEgASQBSAEQAIABQAEEAUgBUAFkAIABSAEUAUwBVAEwAVABJAE4ARwAgAEYAUgBPAE0AIABCAFIARQBBAEMASAAgAE8ARgAgAFQASABFACAAVwBBAFIAUgBBAE4AVABJAEUAUwAgAEkATgAgAFMARQBDAFQASQBPAE4AIAA1ACwAIABJAE4AIABOAE8AIABFAFYARQBOAFQAIABXAEkATABMACAATABJAEMARQBOAFMATwBSACAAQgBFACAATABJAEEAQgBMAEUAIABUAE8AIABZAE8AVQAgAE8ATgAgAEEATgBZACAATABFAEcAQQBMACAAVABIAEUATwBSAFkAIABGAE8AUgAgAEEATgBZACAAUwBQAEUAQwBJAEEATAAsACAASQBOAEMASQBEAEUATgBUAEEATAAsACAAQwBPAE4AUwBFAFEAVQBFAE4AVABJAEEATAAsACAAUABVAE4ASQBUAEkAVgBFACAATwBSACAARQBYAEUATQBQAEwAQQBSAFkAIABEAEEATQBBAEcARQBTACAAQQBSAEkAUwBJAE4ARwAgAE8AVQBUACAATwBGACAAVABIAEkAUwAgAEwASQBDAEUATgBTAEUAIABPAFIAIABUAEgARQAgAFUAUwBFACAATwBGACAAVABIAEUAIABXAE8AUgBLACwAIABFAFYARQBOACAASQBGACAATABJAEMARQBOAFMATwBSACAASABBAFMAIABCAEUARQBOACAAQQBEAFYASQBTAEUARAAgAE8ARgAgAFQASABFACAAUABPAFMAUwBJAEIASQBMAEkAVABZACAATwBGACAAUwBVAEMASAAgAEQAQQBNAEEARwBFAFMALgANAAoADQAKADcALgAgAFQAZQByAG0AaQBuAGEAdABpAG8AbgANAAoADQAKACAAIAAgADEALgAgAFQAaABpAHMAIABMAGkAYwBlAG4AcwBlACAAYQBuAGQAIAB0AGgAZQAgAHIAaQBnAGgAdABzACAAZwByAGEAbgB0AGUAZAAgAGgAZQByAGUAdQBuAGQAZQByACAAdwBpAGwAbAAgAHQAZQByAG0AaQBuAGEAdABlACAAYQB1AHQAbwBtAGEAdABpAGMAYQBsAGwAeQAgAHUAcABvAG4AIABhAG4AeQAgAGIAcgBlAGEAYwBoACAAYgB5ACAAWQBvAHUAIABvAGYAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlAC4AIABJAG4AZABpAHYAaQBkAHUAYQBsAHMAIABvAHIAIABlAG4AdABpAHQAaQBlAHMAIAB3AGgAbwAgAGgAYQB2AGUAIAByAGUAYwBlAGkAdgBlAGQAIABEAGUAcgBpAHYAYQB0AGkAdgBlACAAVwBvAHIAawBzACAAbwByACAAQwBvAGwAbABlAGMAdABpAHYAZQAgAFcAbwByAGsAcwAgAGYAcgBvAG0AIABZAG8AdQAgAHUAbgBkAGUAcgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACwAIABoAG8AdwBlAHYAZQByACwAIAB3AGkAbABsACAAbgBvAHQAIABoAGEAdgBlACAAdABoAGUAaQByACAAbABpAGMAZQBuAHMAZQBzACAAdABlAHIAbQBpAG4AYQB0AGUAZAAgAHAAcgBvAHYAaQBkAGUAZAAgAHMAdQBjAGgAIABpAG4AZABpAHYAaQBkAHUAYQBsAHMAIABvAHIAIABlAG4AdABpAHQAaQBlAHMAIAByAGUAbQBhAGkAbgAgAGkAbgAgAGYAdQBsAGwAIABjAG8AbQBwAGwAaQBhAG4AYwBlACAAdwBpAHQAaAAgAHQAaABvAHMAZQAgAGwAaQBjAGUAbgBzAGUAcwAuACAAUwBlAGMAdABpAG8AbgBzACAAMQAsACAAMgAsACAANQAsACAANgAsACAANwAsACAAYQBuAGQAIAA4ACAAdwBpAGwAbAAgAHMAdQByAHYAaQB2AGUAIABhAG4AeQAgAHQAZQByAG0AaQBuAGEAdABpAG8AbgAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlAC4ADQAKACAAIAAgADIALgAgAFMAdQBiAGoAZQBjAHQAIAB0AG8AIAB0AGgAZQAgAGEAYgBvAHYAZQAgAHQAZQByAG0AcwAgAGEAbgBkACAAYwBvAG4AZABpAHQAaQBvAG4AcwAsACAAdABoAGUAIABsAGkAYwBlAG4AcwBlACAAZwByAGEAbgB0AGUAZAAgAGgAZQByAGUAIABpAHMAIABwAGUAcgBwAGUAdAB1AGEAbAAgACgAZgBvAHIAIAB0AGgAZQAgAGQAdQByAGEAdABpAG8AbgAgAG8AZgAgAHQAaABlACAAYQBwAHAAbABpAGMAYQBiAGwAZQAgAGMAbwBwAHkAcgBpAGcAaAB0ACAAaQBuACAAdABoAGUAIABXAG8AcgBrACkALgAgAE4AbwB0AHcAaQB0AGgAcwB0AGEAbgBkAGkAbgBnACAAdABoAGUAIABhAGIAbwB2AGUALAAgAEwAaQBjAGUAbgBzAG8AcgAgAHIAZQBzAGUAcgB2AGUAcwAgAHQAaABlACAAcgBpAGcAaAB0ACAAdABvACAAcgBlAGwAZQBhAHMAZQAgAHQAaABlACAAVwBvAHIAawAgAHUAbgBkAGUAcgAgAGQAaQBmAGYAZQByAGUAbgB0ACAAbABpAGMAZQBuAHMAZQAgAHQAZQByAG0AcwAgAG8AcgAgAHQAbwAgAHMAdABvAHAAIABkAGkAcwB0AHIAaQBiAHUAdABpAG4AZwAgAHQAaABlACAAVwBvAHIAawAgAGEAdAAgAGEAbgB5ACAAdABpAG0AZQA7ACAAcAByAG8AdgBpAGQAZQBkACwAIABoAG8AdwBlAHYAZQByACAAdABoAGEAdAAgAGEAbgB5ACAAcwB1AGMAaAAgAGUAbABlAGMAdABpAG8AbgAgAHcAaQBsAGwAIABuAG8AdAAgAHMAZQByAHYAZQAgAHQAbwAgAHcAaQB0AGgAZAByAGEAdwAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACAAKABvAHIAIABhAG4AeQAgAG8AdABoAGUAcgAgAGwAaQBjAGUAbgBzAGUAIAB0AGgAYQB0ACAAaABhAHMAIABiAGUAZQBuACwAIABvAHIAIABpAHMAIAByAGUAcQB1AGkAcgBlAGQAIAB0AG8AIABiAGUALAAgAGcAcgBhAG4AdABlAGQAIAB1AG4AZABlAHIAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACkALAAgAGEAbgBkACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUAIAB3AGkAbABsACAAYwBvAG4AdABpAG4AdQBlACAAaQBuACAAZgB1AGwAbAAgAGYAbwByAGMAZQAgAGEAbgBkACAAZQBmAGYAZQBjAHQAIAB1AG4AbABlAHMAcwAgAHQAZQByAG0AaQBuAGEAdABlAGQAIABhAHMAIABzAHQAYQB0AGUAZAAgAGEAYgBvAHYAZQAuAA0ACgANAAoAOAAuACAATQBpAHMAYwBlAGwAbABhAG4AZQBvAHUAcwANAAoADQAKACAAIAAgADEALgAgAEUAYQBjAGgAIAB0AGkAbQBlACAAWQBvAHUAIABkAGkAcwB0AHIAaQBiAHUAdABlACAAbwByACAAcAB1AGIAbABpAGMAbAB5ACAAZABpAGcAaQB0AGEAbABsAHkAIABwAGUAcgBmAG8AcgBtACAAdABoAGUAIABXAG8AcgBrACAAbwByACAAYQAgAEMAbwBsAGwAZQBjAHQAaQB2AGUAIABXAG8AcgBrACwAIAB0AGgAZQAgAEwAaQBjAGUAbgBzAG8AcgAgAG8AZgBmAGUAcgBzACAAdABvACAAdABoAGUAIAByAGUAYwBpAHAAaQBlAG4AdAAgAGEAIABsAGkAYwBlAG4AcwBlACAAdABvACAAdABoAGUAIABXAG8AcgBrACAAbwBuACAAdABoAGUAIABzAGEAbQBlACAAdABlAHIAbQBzACAAYQBuAGQAIABjAG8AbgBkAGkAdABpAG8AbgBzACAAYQBzACAAdABoAGUAIABsAGkAYwBlAG4AcwBlACAAZwByAGEAbgB0AGUAZAAgAHQAbwAgAFkAbwB1ACAAdQBuAGQAZQByACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUALgANAAoAIAAgACAAMgAuACAARQBhAGMAaAAgAHQAaQBtAGUAIABZAG8AdQAgAGQAaQBzAHQAcgBpAGIAdQB0AGUAIABvAHIAIABwAHUAYgBsAGkAYwBsAHkAIABkAGkAZwBpAHQAYQBsAGwAeQAgAHAAZQByAGYAbwByAG0AIABhACAARABlAHIAaQB2AGEAdABpAHYAZQAgAFcAbwByAGsALAAgAEwAaQBjAGUAbgBzAG8AcgAgAG8AZgBmAGUAcgBzACAAdABvACAAdABoAGUAIAByAGUAYwBpAHAAaQBlAG4AdAAgAGEAIABsAGkAYwBlAG4AcwBlACAAdABvACAAdABoAGUAIABvAHIAaQBnAGkAbgBhAGwAIABXAG8AcgBrACAAbwBuACAAdABoAGUAIABzAGEAbQBlACAAdABlAHIAbQBzACAAYQBuAGQAIABjAG8AbgBkAGkAdABpAG8AbgBzACAAYQBzACAAdABoAGUAIABsAGkAYwBlAG4AcwBlACAAZwByAGEAbgB0AGUAZAAgAHQAbwAgAFkAbwB1ACAAdQBuAGQAZQByACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUALgANAAoAIAAgACAAMwAuACAASQBmACAAYQBuAHkAIABwAHIAbwB2AGkAcwBpAG8AbgAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACAAaQBzACAAaQBuAHYAYQBsAGkAZAAgAG8AcgAgAHUAbgBlAG4AZgBvAHIAYwBlAGEAYgBsAGUAIAB1AG4AZABlAHIAIABhAHAAcABsAGkAYwBhAGIAbABlACAAbABhAHcALAAgAGkAdAAgAHMAaABhAGwAbAAgAG4AbwB0ACAAYQBmAGYAZQBjAHQAIAB0AGgAZQAgAHYAYQBsAGkAZABpAHQAeQAgAG8AcgAgAGUAbgBmAG8AcgBjAGUAYQBiAGkAbABpAHQAeQAgAG8AZgAgAHQAaABlACAAcgBlAG0AYQBpAG4AZABlAHIAIABvAGYAIAB0AGgAZQAgAHQAZQByAG0AcwAgAG8AZgAgAHQAaABpAHMAIABMAGkAYwBlAG4AcwBlACwAIABhAG4AZAAgAHcAaQB0AGgAbwB1AHQAIABmAHUAcgB0AGgAZQByACAAYQBjAHQAaQBvAG4AIABiAHkAIAB0AGgAZQAgAHAAYQByAHQAaQBlAHMAIAB0AG8AIAB0AGgAaQBzACAAYQBnAHIAZQBlAG0AZQBuAHQALAAgAHMAdQBjAGgAIABwAHIAbwB2AGkAcwBpAG8AbgAgAHMAaABhAGwAbAAgAGIAZQAgAHIAZQBmAG8AcgBtAGUAZAAgAHQAbwAgAHQAaABlACAAbQBpAG4AaQBtAHUAbQAgAGUAeAB0AGUAbgB0ACAAbgBlAGMAZQBzAHMAYQByAHkAIAB0AG8AIABtAGEAawBlACAAcwB1AGMAaAAgAHAAcgBvAHYAaQBzAGkAbwBuACAAdgBhAGwAaQBkACAAYQBuAGQAIABlAG4AZgBvAHIAYwBlAGEAYgBsAGUALgANAAoAIAAgACAANAAuACAATgBvACAAdABlAHIAbQAgAG8AcgAgAHAAcgBvAHYAaQBzAGkAbwBuACAAbwBmACAAdABoAGkAcwAgAEwAaQBjAGUAbgBzAGUAIABzAGgAYQBsAGwAIABiAGUAIABkAGUAZQBtAGUAZAAgAHcAYQBpAHYAZQBkACAAYQBuAGQAIABuAG8AIABiAHIAZQBhAGMAaAAgAGMAbwBuAHMAZQBuAHQAZQBkACAAdABvACAAdQBuAGwAZQBzAHMAIABzAHUAYwBoACAAdwBhAGkAdgBlAHIAIABvAHIAIABjAG8AbgBzAGUAbgB0ACAAcwBoAGEAbABsACAAYgBlACAAaQBuACAAdwByAGkAdABpAG4AZwAgAGEAbgBkACAAcwBpAGcAbgBlAGQAIABiAHkAIAB0AGgAZQAgAHAAYQByAHQAeQAgAHQAbwAgAGIAZQAgAGMAaABhAHIAZwBlAGQAIAB3AGkAdABoACAAcwB1AGMAaAAgAHcAYQBpAHYAZQByACAAbwByACAAYwBvAG4AcwBlAG4AdAAuAA0ACgAgACAAIAA1AC4AIABUAGgAaQBzACAATABpAGMAZQBuAHMAZQAgAGMAbwBuAHMAdABpAHQAdQB0AGUAcwAgAHQAaABlACAAZQBuAHQAaQByAGUAIABhAGcAcgBlAGUAbQBlAG4AdAAgAGIAZQB0AHcAZQBlAG4AIAB0AGgAZQAgAHAAYQByAHQAaQBlAHMAIAB3AGkAdABoACAAcgBlAHMAcABlAGMAdAAgAHQAbwAgAHQAaABlACAAVwBvAHIAawAgAGwAaQBjAGUAbgBzAGUAZAAgAGgAZQByAGUALgAgAFQAaABlAHIAZQAgAGEAcgBlACAAbgBvACAAdQBuAGQAZQByAHMAdABhAG4AZABpAG4AZwBzACwAIABhAGcAcgBlAGUAbQBlAG4AdABzACAAbwByACAAcgBlAHAAcgBlAHMAZQBuAHQAYQB0AGkAbwBuAHMAIAB3AGkAdABoACAAcgBlAHMAcABlAGMAdAAgAHQAbwAgAHQAaABlACAAVwBvAHIAawAgAG4AbwB0ACAAcwBwAGUAYwBpAGYAaQBlAGQAIABoAGUAcgBlAC4AIABMAGkAYwBlAG4AcwBvAHIAIABzAGgAYQBsAGwAIABuAG8AdAAgAGIAZQAgAGIAbwB1AG4AZAAgAGIAeQAgAGEAbgB5ACAAYQBkAGQAaQB0AGkAbwBuAGEAbAAgAHAAcgBvAHYAaQBzAGkAbwBuAHMAIAB0AGgAYQB0ACAAbQBhAHkAIABhAHAAcABlAGEAcgAgAGkAbgAgAGEAbgB5ACAAYwBvAG0AbQB1AG4AaQBjAGEAdABpAG8AbgAgAGYAcgBvAG0AIABZAG8AdQAuACAAVABoAGkAcwAgAEwAaQBjAGUAbgBzAGUAIABtAGEAeQAgAG4AbwB0ACAAYgBlACAAbQBvAGQAaQBmAGkAZQBkACAAdwBpAHQAaABvAHUAdAAgAHQAaABlACAAbQB1AHQAdQBhAGwAIAB3AHIAaQB0AHQAZQBuACAAYQBnAHIAZQBlAG0AZQBuAHQAIABvAGYAIAB0AGgAZQAgAEwAaQBjAGUAbgBzAG8AcgAgAGEAbgBkACAAWQBvAHUALgBoAHQAdABwADoALwAvAGMAcgBlAGEAdABpAHYAZQBjAG8AbQBtAG8AbgBzAC4AbwByAGcALwBsAGkAYwBlAG4AcwBlAHMALwBuAGMALQBzAGEALwAxAC4AMAAvAAIAAAAAAAD/6QAjAAAAAAAAAAAAAAAAAAAAAAAAAAAAuQAAAAMABgAHAAgACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AIgAjAD4APwBAAEEAQgBGAEcASABJAEoASwBMAE4ATwBQAFEAUgBWAFcAWABaAFsAXABdAGEAqwDYALYAtAC1AIcAsgCzANkAjACsAKMAhACFAL0AhgCOAIsAigECAI0BAwDeAKIABAAFAEUAVQC3AAkAsQAgAL4AvwCpAKoAiACkAMQAxQCmAB8AxgAhAF4AYACdAFQAUwBNALsAlgCJALAAkABfAK0AyQDHAK4AYgBjAGoAaQBrAG0AbABuAKAAZABvAMsAZQDIAMoAcQBwAHIAcwDPAMwAzQDOAHUAdAB2AHcA0wDQANEArwBnAJEAegB5AHsAfQB8AKEA1gDUANUAaAB/AH4AgACBALoAZgB4AEQAWQEEAAIBBQEGAOgA8QDyAPMBBwDnAOYA9QD0APYA6wDsAOQA5QDqAO4GbWFjcm9uDnBlcmlvZGNlbnRlcmVkBS5udWxsBGEuMDEEdi4wMgRFdXJvAAAAAAH//wADAAAAAQABAQEBAQAMAPgI/wAIAAf//QAJAAj//QAKAAj//QALAAn//AAMAAr//AANAAv//AAOAAz/+wAPAAz/+wAQAA3/+wARAA7/+wASAA//+gATABD/+gAUABD/+gAVABH/+QAWABL/+QAXABP/+QAYABT/+QAZABT/+AAaABX/+AAbABb/+AAcABf/9wAdABj/9wAeABj/9wAfABn/9gAgABr/9gAhABv/9gAiABz/9gAjABz/9QAkAB3/9QAlAB7/9QAmAB//9AAnACD/9AAoACD/9AApACH/9AAqACL/8wArACP/8wAsACT/8wAtACT/8gAuACX/8gAvACb/8gAwACf/8gAxACj/8QAyACj/8QAzACn/8QA0ACr/8AA1ACv/8AA2ACz/8AA3ACz/7wA4AC3/7wA5AC7/7wA6AC//7wA7ADD/7gA8ADD/7gA9ADH/7gA+ADL/7QA/ADP/7QBAADT/7QBBADT/7QBCADX/7ABDADb/7ABEADf/7ABFADj/6wBGADj/6wBHADn/6wBIADr/6wBJADv/6gBKADz/6gBLADz/6gBMAD3/6QBNAD7/6QBOAD//6QBPAED/6QBQAED/6ABRAEH/6ABSAEL/6ABTAEP/5wBUAET/5wBVAET/5wBWAEX/5gBXAEb/5gBYAEf/5gBZAEj/5gBaAEj/5QBbAEn/5QBcAEr/5QBdAEv/5ABeAEz/5ABfAEz/5ABgAE3/5ABhAE7/4wBiAE//4wBjAFD/4wBkAFD/4gBlAFH/4gBmAFL/4gBnAFP/4gBoAFT/4QBpAFT/4QBqAFX/4QBrAFb/4ABsAFf/4ABtAFj/4ABuAFj/3wBvAFn/3wBwAFr/3wBxAFv/3wByAFz/3gBzAFz/3gB0AF3/3gB1AF7/3QB2AF//3QB3AGD/3QB4AGD/3QB5AGH/3AB6AGL/3AB7AGP/3AB8AGT/2wB9AGT/2wB+AGX/2wB/AGb/2wCAAGf/2gCBAGj/2gCCAGj/2gCDAGn/2QCEAGr/2QCFAGv/2QCGAGz/2QCHAGz/2ACIAG3/2ACJAG7/2ACKAG//1wCLAHD/1wCMAHD/1wCNAHH/1gCOAHL/1gCPAHP/1gCQAHT/1gCRAHT/1QCSAHX/1QCTAHb/1QCUAHf/1ACVAHj/1ACWAHj/1ACXAHn/1ACYAHr/0wCZAHv/0wCaAHz/0wCbAHz/0gCcAH3/0gCdAH7/0gCeAH//0gCfAID/0QCgAID/0QChAIH/0QCiAIL/0ACjAIP/0ACkAIT/0AClAIT/zwCmAIX/zwCnAIb/zwCoAIf/zwCpAIj/zgCqAIj/zgCrAIn/zgCsAIr/zQCtAIv/zQCuAIz/zQCvAIz/zQCwAI3/zACxAI7/zACyAI//zACzAJD/ywC0AJD/ywC1AJH/ywC2AJL/ywC3AJP/ygC4AJT/ygC5AJT/ygC6AJX/yQC7AJb/yQC8AJf/yQC9AJj/yQC+AJj/yAC/AJn/yADAAJr/yADBAJv/xwDCAJz/xwDDAJz/xwDEAJ3/xgDFAJ7/xgDGAJ//xgDHAKD/xgDIAKD/xQDJAKH/xQDKAKL/xQDLAKP/xADMAKT/xADNAKT/xADOAKX/xADPAKb/wwDQAKf/wwDRAKj/wwDSAKj/wgDTAKn/wgDUAKr/wgDVAKv/wgDWAKz/wQDXAKz/wQDYAK3/wQDZAK7/wADaAK//wADbALD/wADcALD/vwDdALH/vwDeALL/vwDfALP/vwDgALT/vgDhALT/vgDiALX/vgDjALb/vQDkALf/vQDlALj/vQDmALj/vQDnALn/vADoALr/vADpALv/vADqALz/uwDrALz/uwDsAL3/uwDtAL7/uwDuAL//ugDvAMD/ugDwAMD/ugDxAMH/uQDyAML/uQDzAMP/uQD0AMT/uAD1AMT/uAD2AMX/uAD3AMb/uAD4AMf/twD5AMj/twD6AMj/twD7AMn/tgD8AMr/tgD9AMv/tgD+AMz/tgD/AMz/tQ==";
+
+// src/components/WandyHand.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function dist(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.hypot(dx, dy);
+}
+function polylineLength(points) {
+  let L = 0;
+  for (let i = 1; i < points.length; i++) L += dist(points[i - 1], points[i]);
+  return L;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return function() {
+    t += 1831565813;
+    let r = Math.imul(t ^ t >>> 15, t | 1);
+    r ^= r + Math.imul(r ^ r >>> 7, r | 61);
+    return ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hashStringToSeed(str) {
+  let h = 1779033703 ^ str.length;
+  for (let i = 0; i < str.length; i++) {
+    h = Math.imul(h ^ str.charCodeAt(i), 3432918353);
+    h = h << 13 | h >>> 19;
+  }
+  return h >>> 0;
+}
+function randomBetween(rng, min, max) {
+  return min + (max - min) * rng();
+}
+function randomOffset(rng, magnitude) {
+  return {
+    x: randomBetween(rng, -magnitude, magnitude),
+    y: randomBetween(rng, -magnitude, magnitude)
+  };
+}
+function easeInOut(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+}
+function sampleCubic(p0, p1, p2, p3, steps) {
+  const pts = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const mt = 1 - t;
+    const x = mt * mt * mt * p0.x + 3 * mt * mt * t * p1.x + 3 * mt * t * t * p2.x + t * t * t * p3.x;
+    const y = mt * mt * mt * p0.y + 3 * mt * mt * t * p1.y + 3 * mt * t * t * p2.y + t * t * t * p3.y;
+    pts.push({ x, y });
+  }
+  return pts;
+}
+function sampleQuadratic(p0, p1, p2, steps) {
+  const pts = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const mt = 1 - t;
+    const x = mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x;
+    const y = mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y;
+    pts.push({ x, y });
+  }
+  return pts;
+}
+function pathToPolylines(commands, samplesPerCurve = 16) {
+  const polylines = [];
+  let current = [];
+  let pen = { x: 0, y: 0 };
+  let start = { x: 0, y: 0 };
+  const pushCurrent = () => {
+    if (current.length > 1) polylines.push(current);
+    current = [];
+  };
+  for (const cmd of commands) {
+    if (cmd.type === "M") {
+      pushCurrent();
+      pen = { x: cmd.x, y: cmd.y };
+      start = { ...pen };
+      current.push({ ...pen });
+    } else if (cmd.type === "L") {
+      pen = { x: cmd.x, y: cmd.y };
+      current.push({ ...pen });
+    } else if (cmd.type === "C") {
+      const p0 = pen;
+      const p1 = { x: cmd.x1, y: cmd.y1 };
+      const p2 = { x: cmd.x2, y: cmd.y2 };
+      const p3 = { x: cmd.x, y: cmd.y };
+      const pts = sampleCubic(p0, p1, p2, p3, samplesPerCurve);
+      current.push(...pts.slice(1));
+      pen = p3;
+    } else if (cmd.type === "Q") {
+      const p0 = pen;
+      const p1 = { x: cmd.x1, y: cmd.y1 };
+      const p2 = { x: cmd.x, y: cmd.y };
+      const pts = sampleQuadratic(p0, p1, p2, samplesPerCurve);
+      current.push(...pts.slice(1));
+      pen = p2;
+    } else if (cmd.type === "Z") {
+      current.push({ ...start });
+      pushCurrent();
+    }
+  }
+  pushCurrent();
+  return polylines;
+}
+function polygonSignedArea(points) {
+  let area = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area / 2;
+}
+function polylineBounds(points) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of points) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  if (!points.length) return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  return { minX, minY, maxX, maxY };
+}
+function getEndDirection(points) {
+  for (let i = points.length - 1; i > 0; i--) {
+    const curr = points[i];
+    const prev = points[i - 1];
+    const dx = curr.x - prev.x;
+    const dy = curr.y - prev.y;
+    const mag = Math.hypot(dx, dy);
+    if (mag > 0) return { x: dx / mag, y: dy / mag };
+  }
+  return { x: 1, y: 0 };
+}
+function drawPolylineStamped(ctx, pts, visibleLen, totalLen, strokeWidth, strokeColor, baselineOffset, offsets, poolingStrength) {
+  if (pts.length < 2 || visibleLen <= 0 || totalLen <= 0) return;
+  const maxDistance = Math.min(visibleLen, totalLen);
+  if (maxDistance <= 0) return;
+  const spacing = Math.max(0.5, strokeWidth * 0.3);
+  let nextStamp = 0;
+  let segmentIndex = 1;
+  let segmentStartLen = 0;
+  let segmentLength = dist(pts[0], pts[1]);
+  const lastIndex = pts.length - 1;
+  const advanceSegment = () => {
+    while (segmentLength === 0 && segmentIndex < lastIndex) {
+      segmentIndex++;
+      segmentLength = dist(pts[segmentIndex - 1], pts[segmentIndex]);
+    }
+  };
+  advanceSegment();
+  const stampAt = (distance) => {
+    const targetDistance = Math.min(distance, maxDistance);
+    while (segmentIndex < pts.length && targetDistance > segmentStartLen + segmentLength && segmentIndex < lastIndex) {
+      segmentStartLen += segmentLength;
+      segmentIndex++;
+      segmentLength = dist(pts[segmentIndex - 1], pts[segmentIndex]);
+      advanceSegment();
+    }
+    const clampedSegmentLen = segmentLength || 1;
+    const segmentDistance = Math.max(0, targetDistance - segmentStartLen);
+    const t = segmentLength === 0 ? 0 : segmentDistance / clampedSegmentLen;
+    const a = pts[segmentIndex - 1];
+    const b = pts[segmentIndex];
+    const point = {
+      x: lerp(a.x, b.x, t),
+      y: lerp(a.y, b.y, t)
+    };
+    const localProgress = maxDistance > 0 ? Math.min(1, targetDistance / maxDistance) : 1;
+    const delta = localProgress < 0.5 ? {
+      x: lerp(offsets.start.x, offsets.mid.x, localProgress * 2),
+      y: lerp(offsets.start.y, offsets.mid.y, localProgress * 2)
+    } : {
+      x: lerp(offsets.mid.x, offsets.end.x, (localProgress - 0.5) * 2),
+      y: lerp(offsets.mid.y, offsets.end.y, (localProgress - 0.5) * 2)
+    };
+    point.x += baselineOffset.x + delta.x;
+    point.y += baselineOffset.y + delta.y;
+    const pressure = Math.max(0, Math.sin(Math.PI * localProgress));
+    const poolingFactor = localProgress >= 0.7 ? Math.pow((localProgress - 0.7) / 0.3, 1.1) : 0;
+    const radius = Math.max(
+      0.1,
+      strokeWidth * (0.35 + 0.65 * pressure) * (1 + poolingStrength * poolingFactor)
+    );
+    ctx.moveTo(point.x + radius, point.y);
+    ctx.arc(point.x, point.y, radius, 0, Math.PI * 2);
+  };
+  ctx.save();
+  ctx.fillStyle = strokeColor;
+  ctx.beginPath();
+  while (nextStamp <= maxDistance) {
+    stampAt(nextStamp);
+    nextStamp += spacing;
+  }
+  if (nextStamp - spacing < maxDistance) {
+    stampAt(maxDistance);
+  }
+  ctx.fill();
+  ctx.restore();
+}
+function drawOvershootTail(ctx, basePoint, direction, overshootPx, strokeWidth, strokeColor) {
+  if (overshootPx <= 0) return;
+  const dirMag = Math.hypot(direction.x, direction.y) || 1;
+  const dir = { x: direction.x / dirMag, y: direction.y / dirMag };
+  const spacing = Math.max(1, strokeWidth * 0.4);
+  ctx.save();
+  ctx.fillStyle = strokeColor;
+  ctx.beginPath();
+  for (let traveled = 0; traveled <= overshootPx; traveled += spacing) {
+    const progress = Math.min(1, traveled / Math.max(overshootPx, 1e-4));
+    const radius = Math.max(0.1, strokeWidth * (0.25 + 0.35 * (1 - progress)));
+    const x = basePoint.x + dir.x * traveled;
+    const y = basePoint.y + dir.y * traveled;
+    ctx.moveTo(x + radius, y);
+    ctx.arc(x, y, radius, 0, Math.PI * 2);
+  }
+  ctx.fill();
+  ctx.restore();
+}
+function createFlourishPath(endPoint, direction, rng) {
+  const dirMag = Math.hypot(direction.x, direction.y);
+  if (!dirMag) return null;
+  const dir = { x: direction.x / dirMag, y: direction.y / dirMag };
+  const normal = { x: -dir.y, y: dir.x };
+  const flourishLen = randomBetween(rng, 6, 14);
+  const curl = randomBetween(rng, -0.6, 0.6);
+  const control = {
+    x: endPoint.x + dir.x * (flourishLen * 0.5) + normal.x * flourishLen * 0.3 * curl,
+    y: endPoint.y + dir.y * (flourishLen * 0.5) + normal.y * flourishLen * 0.3 * curl
+  };
+  const finalPoint = {
+    x: endPoint.x + dir.x * flourishLen + normal.x * flourishLen * 0.15 * curl,
+    y: endPoint.y + dir.y * flourishLen + normal.y * flourishLen * 0.15 * curl
+  };
+  const flourishPoints = sampleQuadratic(endPoint, control, finalPoint, 12);
+  const length = polylineLength(flourishPoints);
+  if (length <= 0) return null;
+  return { points: flourishPoints, length };
+}
+var ZERO_OFFSETS = {
+  start: { x: 0, y: 0 },
+  mid: { x: 0, y: 0 },
+  end: { x: 0, y: 0 }
+};
+function resolveCurveSamples(controlValue) {
+  return Math.max(2, Math.round(controlValue * controlValue * 0.75));
+}
+function computeBounds(polylines) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const line of polylines) {
+    for (const p of line) {
+      minX = Math.min(minX, p.x);
+      minY = Math.min(minY, p.y);
+      maxX = Math.max(maxX, p.x);
+      maxY = Math.max(maxY, p.y);
+    }
+  }
+  if (minX === Infinity || minY === Infinity || maxX === -Infinity || maxY === -Infinity) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+function prepareText(font, text, fontSize, samplesPerCurve) {
+  const glyphs = font.stringToGlyphs(text);
+  const characters = Array.from(text);
+  const contours = [];
+  let totalLen = 0;
+  let penX = 0;
+  const scale = fontSize / font.unitsPerEm;
+  let currentWordIndex = 0;
+  let hasGlyphInCurrentWord = false;
+  const lengthThreshold = Math.max(fontSize * 0.65, 20);
+  const areaThreshold = Math.max(fontSize * fontSize * 0.02, 40);
+  const punctuationRegex = /[!?,.;:'"()]/;
+  for (let i = 0; i < glyphs.length; i++) {
+    const glyph = glyphs[i];
+    const char = characters[i] ?? "";
+    const isWhitespaceChar = /\s/.test(char);
+    const isPunctuationGlyph = punctuationRegex.test(char);
+    if (isWhitespaceChar) {
+      if (hasGlyphInCurrentWord) {
+        currentWordIndex++;
+        hasGlyphInCurrentWord = false;
+      }
+      const advanceWidth2 = glyph.advanceWidth && glyph.advanceWidth > 0 ? glyph.advanceWidth : font.unitsPerEm;
+      penX += advanceWidth2 * scale;
+      continue;
+    }
+    hasGlyphInCurrentWord = true;
+    const commands = glyph.getPath(penX, 0, fontSize).commands;
+    const glyphLines = pathToPolylines(commands, samplesPerCurve);
+    for (let contourIndex = 0; contourIndex < glyphLines.length; contourIndex++) {
+      const pl = glyphLines[contourIndex];
+      if (pl.length < 2) continue;
+      const length = polylineLength(pl);
+      if (length <= 0) continue;
+      const bounds2 = polylineBounds(pl);
+      const boundsArea = (bounds2.maxX - bounds2.minX) * (bounds2.maxY - bounds2.minY);
+      const signedArea = polygonSignedArea(pl);
+      const isHole = signedArea < 0;
+      const isSecondary = isPunctuationGlyph || length < lengthThreshold || boundsArea < areaThreshold;
+      contours.push({
+        id: `word${currentWordIndex}-glyph${i}-contour${contourIndex}`,
+        points: pl,
+        length,
+        bounds: bounds2,
+        boundsArea,
+        glyphIndex: i,
+        wordIndex: currentWordIndex,
+        signedArea,
+        isHole,
+        isSecondary,
+        isPunctuation: isPunctuationGlyph
+      });
+      totalLen += length;
+    }
+    const advanceWidth = glyph.advanceWidth && glyph.advanceWidth > 0 ? glyph.advanceWidth : font.unitsPerEm;
+    penX += advanceWidth * scale;
+    if (i < glyphs.length - 1) {
+      const kern = font.getKerningValue(glyph, glyphs[i + 1]);
+      penX += kern * scale;
+    }
+  }
+  const polylines = contours.map((c) => c.points);
+  const bounds = computeBounds(polylines);
+  return { contours, polylines, totalLen, bounds };
+}
+function createStrokePlan(contours, totalLen, durationMs, text, imperfectionsEnabled) {
+  if (!contours.length || totalLen <= 0) {
+    return { strokes: [], totalMs: 0 };
+  }
+  const seed = hashStringToSeed(text);
+  const rng = mulberry32(seed || 1);
+  const effectiveDuration = durationMs > 0 ? durationMs : Math.max(totalLen, 1);
+  const baseSpeed = totalLen / Math.max(effectiveDuration, 1);
+  const wordGroups = /* @__PURE__ */ new Map();
+  for (const contour of contours) {
+    const existing = wordGroups.get(contour.wordIndex) ?? {
+      primaries: [],
+      secondaries: [],
+      baselineDrift: { x: 0, y: 0 }
+    };
+    if (!wordGroups.has(contour.wordIndex)) {
+      existing.baselineDrift = imperfectionsEnabled ? {
+        x: randomBetween(rng, -1, 1),
+        y: randomBetween(rng, -1, 1)
+      } : { x: 0, y: 0 };
+    }
+    if (contour.isSecondary) existing.secondaries.push(contour);
+    else existing.primaries.push(contour);
+    wordGroups.set(contour.wordIndex, existing);
+  }
+  const sortContours = (items) => items.sort((a, b) => {
+    if (a.glyphIndex !== b.glyphIndex) {
+      return a.glyphIndex - b.glyphIndex;
+    }
+    if (a.isHole !== b.isHole) {
+      return Number(a.isHole) - Number(b.isHole);
+    }
+    return b.boundsArea - a.boundsArea;
+  });
+  const wordIndices = Array.from(wordGroups.keys()).sort((a, b) => a - b);
+  const strokes = [];
+  let cursor = 0;
+  let lastWordIndex = null;
+  const scheduleContour = (contour, kind, baselineDrift, isLastInWord) => {
+    const length = contour.length;
+    const durationMultiplier = lerp(0.8, 1.2, rng());
+    const baseDuration = baseSpeed > 0 ? length / baseSpeed : length / Math.max(totalLen, 1);
+    const durationMsForStroke = Math.max(baseDuration * durationMultiplier, 24);
+    const isNewWord = lastWordIndex === null || contour.wordIndex !== lastWordIndex;
+    let pauseBeforeMs = 0;
+    if (strokes.length > 0) {
+      if (isNewWord) {
+        pauseBeforeMs = randomBetween(rng, 120, 250);
+      } else if (contour.isPunctuation) {
+        pauseBeforeMs = randomBetween(rng, 60, 140);
+      } else {
+        pauseBeforeMs = randomBetween(rng, 10, 60);
+        if (kind === "secondary") {
+          pauseBeforeMs += randomBetween(rng, 40, 110);
+        }
+      }
+    }
+    cursor += pauseBeforeMs;
+    const startMs = cursor;
+    cursor += durationMsForStroke;
+    const offsets = imperfectionsEnabled ? {
+      start: randomOffset(rng, 0.8),
+      mid: randomOffset(rng, 0.6),
+      end: randomOffset(rng, 0.8)
+    } : ZERO_OFFSETS;
+    const poolingStrength = imperfectionsEnabled ? randomBetween(rng, 0.05, 0.32) : 0;
+    const overshootPx = imperfectionsEnabled ? kind === "secondary" ? randomBetween(rng, 1.5, 4) : randomBetween(rng, 2, 6) : 0;
+    const endDirection = getEndDirection(contour.points);
+    let flourish;
+    if (imperfectionsEnabled && isLastInWord && kind === "main" && rng() < 0.35) {
+      const flourishPath = createFlourishPath(
+        contour.points[contour.points.length - 1],
+        endDirection,
+        rng
+      );
+      if (flourishPath) {
+        flourish = flourishPath;
+      }
+    }
+    strokes.push({
+      id: contour.id,
+      points: contour.points,
+      length,
+      startMs,
+      durationMs: durationMsForStroke,
+      pauseBeforeMs,
+      wordBoundary: isNewWord,
+      kind,
+      wordIndex: contour.wordIndex,
+      baselineDrift,
+      offsets,
+      poolingStrength,
+      overshootPx,
+      endDirection,
+      flourish
+    });
+    lastWordIndex = contour.wordIndex;
+  };
+  for (const wordIndex of wordIndices) {
+    const group = wordGroups.get(wordIndex);
+    if (!group) continue;
+    const orderedPrimaries = sortContours(group.primaries).map((contour) => ({
+      contour,
+      kind: "main"
+    }));
+    const orderedSecondaries = sortContours(group.secondaries).map(
+      (contour) => ({
+        contour,
+        kind: "secondary"
+      })
+    );
+    const orderedContours = [...orderedPrimaries, ...orderedSecondaries];
+    orderedContours.forEach(({ contour, kind }, idx) => {
+      const isLastInWord = idx === orderedContours.length - 1;
+      scheduleContour(contour, kind, group.baselineDrift, isLastInWord);
+    });
+  }
+  const totalMs = cursor;
+  return { strokes, totalMs };
+}
+var WANDY_HAND_DEFAULTS = {
+  fontSize: 160,
+  durationMs: 2200,
+  strokeWidth: 3.2,
+  penOpacity: 1,
+  strokeColor: "#fff",
+  lineCap: "round",
+  lineJoin: "round",
+  samplesPerCurve: 5,
+  strokeMode: "outline",
+  canvasPadding: 8,
+  backgroundColor: "transparent",
+  imperfectionsEnabled: false,
+  animate: true
+};
+function WandyHand({
+  text,
+  fontUrl,
+  fontSize,
+  durationMs = WANDY_HAND_DEFAULTS.durationMs,
+  strokeWidth = WANDY_HAND_DEFAULTS.strokeWidth,
+  penOpacity = WANDY_HAND_DEFAULTS.penOpacity,
+  strokeColor = WANDY_HAND_DEFAULTS.strokeColor,
+  lineCap = WANDY_HAND_DEFAULTS.lineCap,
+  lineJoin = WANDY_HAND_DEFAULTS.lineJoin,
+  samplesPerCurve = WANDY_HAND_DEFAULTS.samplesPerCurve,
+  strokeMode = WANDY_HAND_DEFAULTS.strokeMode,
+  canvasPadding = WANDY_HAND_DEFAULTS.canvasPadding,
+  backgroundColor = WANDY_HAND_DEFAULTS.backgroundColor,
+  imperfectionsEnabled = WANDY_HAND_DEFAULTS.imperfectionsEnabled,
+  size,
+  animate = WANDY_HAND_DEFAULTS.animate,
+  onDrawn
+}) {
+  const canvasRef = useRef9(null);
+  const rafRef = useRef9(null);
+  const [font, setFont] = useState(null);
+  const resolvedFontUrl = fontUrl ?? waltographUI_default;
+  const onDrawnRef = useRef9(onDrawn);
+  const drawRunRef = useRef9(0);
+  const drawNotifiedRef = useRef9(false);
+  const resolvedFontSize = typeof fontSize === "number" && fontSize > 0 ? fontSize : 160;
+  const sizeValue = size !== void 0 ? typeof size === "number" ? `${Math.max(0, size)}px` : `${size}` : null;
+  const LINE_CAP_MAP = {
+    round: "round",
+    butt: "butt",
+    square: "square"
+  };
+  const LINE_JOIN_MAP = {
+    round: "round",
+    miter: "miter",
+    bevel: "bevel"
+  };
+  const STROKE_MODE_MAP = {
+    outline: "outline",
+    "outline reveal": "outline",
+    "full stroke": "full",
+    full: "full"
+  };
+  const normalizeLineCap = (value) => {
+    if (!value) return "round";
+    const lower = value.toLowerCase();
+    return LINE_CAP_MAP[lower] ?? "round";
+  };
+  const normalizeLineJoin = (value) => {
+    if (!value) return "round";
+    const lower = value.toLowerCase();
+    return LINE_JOIN_MAP[lower] ?? "round";
+  };
+  const normalizeStrokeMode = (value) => {
+    if (!value) return "outline";
+    const lower = value.toLowerCase();
+    return STROKE_MODE_MAP[lower] ?? "outline";
+  };
+  const resolvedLineCap = normalizeLineCap(lineCap);
+  const resolvedLineJoin = normalizeLineJoin(lineJoin);
+  const resolvedStrokeMode = normalizeStrokeMode(strokeMode);
+  const resolvedSamplesPerCurve = resolveCurveSamples(samplesPerCurve);
+  useEffect9(() => {
+    onDrawnRef.current = onDrawn;
+  }, [onDrawn]);
+  useEffect9(() => {
+    let cancelled = false;
+    const loadFont = async () => {
+      try {
+        const response = await fetch(resolvedFontUrl);
+        if (!response.ok) {
+          throw new Error(
+            `Failed to load font (${response.status} ${response.statusText})`
+          );
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType && !contentType.includes("font") && !contentType.includes("application/octet-stream") && !resolvedFontUrl.startsWith("data:")) {
+          throw new Error(
+            `Unexpected font content-type "${contentType}" for ${resolvedFontUrl}`
+          );
+        }
+        const buffer = await response.arrayBuffer();
+        const loaded = opentype.parse(buffer);
+        if (!cancelled) setFont(loaded);
+      } catch (err) {
+        if (!cancelled) {
+          console.error(err);
+          setFont(null);
+        }
+      }
+    };
+    loadFont();
+    return () => {
+      cancelled = true;
+    };
+  }, [resolvedFontUrl]);
+  const prepared = useMemo4(() => {
+    if (!font) return null;
+    const safe = text.trim().length ? text : " ";
+    return prepareText(font, safe, resolvedFontSize, resolvedSamplesPerCurve);
+  }, [font, text, resolvedFontSize, resolvedSamplesPerCurve]);
+  const aspectRatio = useMemo4(() => {
+    if (!prepared) return null;
+    const width = prepared.bounds.maxX - prepared.bounds.minX;
+    const height = prepared.bounds.maxY - prepared.bounds.minY;
+    return width > 0 && height > 0 ? width / height : null;
+  }, [prepared]);
+  const strokePlan = useMemo4(() => {
+    if (!prepared) return null;
+    const safe = text.trim().length ? text : " ";
+    return createStrokePlan(
+      prepared.contours,
+      prepared.totalLen,
+      durationMs,
+      safe,
+      imperfectionsEnabled
+    );
+  }, [prepared, durationMs, text, imperfectionsEnabled]);
+  useEffect9(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !prepared || !strokePlan) return;
+    drawRunRef.current += 1;
+    drawNotifiedRef.current = false;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    const safeCanvas = canvas;
+    const safeCtx = ctx;
+    const { polylines, bounds } = prepared;
+    const { strokes, totalMs } = strokePlan;
+    const textW = bounds.maxX - bounds.minX;
+    const textH = bounds.maxY - bounds.minY;
+    const targetAspect = textW > 0 && textH > 0 ? textW / textH : null;
+    function resize() {
+      const dpr = Math.max(1, window.devicePixelRatio || 1);
+      const host = safeCanvas.parentElement ?? safeCanvas;
+      const rect = host.getBoundingClientRect();
+      let nextWidth = rect.width;
+      let nextHeight = rect.height;
+      if (targetAspect) {
+        const rectAspect = rect.width / Math.max(rect.height, 1);
+        if (rectAspect > targetAspect) {
+          nextWidth = rect.height * targetAspect;
+          nextHeight = rect.height;
+        } else {
+          nextWidth = rect.width;
+          nextHeight = rect.width / targetAspect;
+        }
+      }
+      safeCanvas.style.width = `${Math.max(1, nextWidth)}px`;
+      safeCanvas.style.height = `${Math.max(1, nextHeight)}px`;
+      safeCanvas.width = Math.floor(Math.max(1, nextWidth) * dpr);
+      safeCanvas.height = Math.floor(Math.max(1, nextHeight) * dpr);
+      safeCtx.setTransform(dpr, 0, 0, dpr, 0, 0);
+      if (!animate) {
+        renderFrame(Number.POSITIVE_INFINITY, 1);
+        rafRef.current = null;
+        return;
+      }
+      if (rafRef.current === null) {
+        rafRef.current = requestAnimationFrame(draw);
+      }
+    }
+    resize();
+    window.addEventListener("resize", resize);
+    const start = performance.now();
+    const totalTimeline = totalMs > 0 ? totalMs : Math.max(durationMs, 1);
+    function renderFrame(timelineElapsed, timelineProgress) {
+      safeCtx.clearRect(0, 0, safeCanvas.width, safeCanvas.height);
+      safeCtx.lineCap = resolvedLineCap;
+      safeCtx.lineJoin = resolvedLineJoin;
+      safeCtx.lineWidth = strokeWidth;
+      safeCtx.globalAlpha = penOpacity;
+      safeCtx.strokeStyle = strokeColor;
+      const pad = canvasPadding;
+      const viewW = safeCanvas.clientWidth;
+      const viewH = safeCanvas.clientHeight;
+      const scaleToFit = Math.min(
+        (viewW - pad * 2) / (textW || 1),
+        (viewH - pad * 2) / (textH || 1)
+      );
+      const scale = sizeValue === null ? scaleToFit : Math.min(1, scaleToFit);
+      const cx = viewW / 2;
+      const cy = viewH / 2;
+      safeCtx.save();
+      safeCtx.translate(cx, cy);
+      safeCtx.scale(scale, scale);
+      safeCtx.translate(-(bounds.minX + textW / 2), -(bounds.minY + textH / 2));
+      const filledContours = [];
+      for (const stroke of strokes) {
+        if (!stroke.points.length || stroke.length <= 0) continue;
+        const strokeStart = stroke.startMs;
+        const strokeEnd = stroke.startMs + stroke.durationMs;
+        if (timelineElapsed >= strokeEnd) {
+          drawPolylineStamped(
+            safeCtx,
+            stroke.points,
+            stroke.length,
+            stroke.length,
+            strokeWidth,
+            strokeColor,
+            stroke.baselineDrift,
+            stroke.offsets,
+            stroke.poolingStrength
+          );
+          if (resolvedStrokeMode === "full") {
+            filledContours.push(stroke.points);
+          }
+          const lastPoint = stroke.points[stroke.points.length - 1];
+          const tipPoint = {
+            x: lastPoint.x + stroke.baselineDrift.x + stroke.offsets.end.x,
+            y: lastPoint.y + stroke.baselineDrift.y + stroke.offsets.end.y
+          };
+          drawOvershootTail(
+            safeCtx,
+            tipPoint,
+            stroke.endDirection,
+            stroke.overshootPx,
+            strokeWidth,
+            strokeColor
+          );
+          if (stroke.flourish) {
+            drawPolylineStamped(
+              safeCtx,
+              stroke.flourish.points,
+              stroke.flourish.length,
+              stroke.flourish.length,
+              strokeWidth * 0.9,
+              strokeColor,
+              stroke.baselineDrift,
+              ZERO_OFFSETS,
+              stroke.poolingStrength * 0.5
+            );
+          }
+          continue;
+        }
+        if (timelineElapsed >= strokeStart) {
+          const localElapsed = timelineElapsed - strokeStart;
+          const localTLinear = Math.min(
+            1,
+            localElapsed / Math.max(stroke.durationMs, 1)
+          );
+          const easedT = easeInOut(localTLinear);
+          const partialLen = stroke.length * easedT;
+          drawPolylineStamped(
+            safeCtx,
+            stroke.points,
+            partialLen,
+            stroke.length,
+            strokeWidth,
+            strokeColor,
+            stroke.baselineDrift,
+            stroke.offsets,
+            stroke.poolingStrength
+          );
+        }
+        break;
+      }
+      if (resolvedStrokeMode === "full") {
+        const contoursToFill = timelineProgress >= 1 ? polylines : filledContours;
+        if (contoursToFill.length) {
+          safeCtx.save();
+          safeCtx.fillStyle = strokeColor;
+          safeCtx.beginPath();
+          for (const pl of contoursToFill) {
+            if (!pl.length) continue;
+            safeCtx.moveTo(pl[0].x, pl[0].y);
+            for (let i = 1; i < pl.length; i++) {
+              safeCtx.lineTo(pl[i].x, pl[i].y);
+            }
+            safeCtx.closePath();
+          }
+          safeCtx.fill("evenodd");
+          safeCtx.restore();
+        }
+      }
+      safeCtx.restore();
+      if (timelineProgress >= 1 && !drawNotifiedRef.current) {
+        drawNotifiedRef.current = true;
+        onDrawnRef.current?.();
+      }
+    }
+    function draw(now) {
+      const elapsedRaw = now - start;
+      const timelineElapsed = Math.min(elapsedRaw, totalTimeline);
+      const timelineProgress = totalTimeline > 0 ? timelineElapsed / totalTimeline : 1;
+      renderFrame(timelineElapsed, timelineProgress);
+      if (timelineProgress < 1) {
+        rafRef.current = requestAnimationFrame(draw);
+      } else {
+        rafRef.current = null;
+      }
+    }
+    if (rafRef.current) cancelAnimationFrame(rafRef.current);
+    if (animate) {
+      rafRef.current = requestAnimationFrame(draw);
+    } else {
+      renderFrame(Number.POSITIVE_INFINITY, 1);
+      rafRef.current = null;
+    }
+    return () => {
+      window.removeEventListener("resize", resize);
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    };
+  }, [
+    prepared,
+    strokePlan,
+    durationMs,
+    strokeWidth,
+    strokeColor,
+    canvasPadding,
+    resolvedLineCap,
+    resolvedLineJoin,
+    penOpacity,
+    resolvedStrokeMode,
+    sizeValue,
+    animate
+  ]);
+  return /* @__PURE__ */ jsx10(
+    "div",
+    {
+      className: "flex w-full flex-col text-white",
+      style: {
+        background: backgroundColor,
+        ...sizeValue ? { width: sizeValue } : null,
+        ...aspectRatio ? { aspectRatio } : null
+      },
+      children: /* @__PURE__ */ jsx10("div", { className: "relative flex flex-1 items-center justify-center", children: /* @__PURE__ */ jsx10("canvas", { ref: canvasRef, style: { display: "block" } }) })
+    }
+  );
+}
 export {
+  AnimatedDrawingSVG,
   EFECTO_ASCII_COMPONENT_DEFAULTS,
   EFECTO_ASCII_POST_PROCESSING_DEFAULTS,
   Efecto,
   FractalFlower,
   MenuGlitch,
   OranoParticles,
-  ShaderArt
+  ShaderArt,
+  Snow,
+  WANDY_HAND_DEFAULTS,
+  WandyHand
 };