// @ts-nocheck
// # Simple-Markdown Core
//
// This is a fork of Khan-academy's Simple-Markdown[1], initially forked in 2022
// to add Svelte support[2], and used for paper clover's q+a markdown flavor.
//
// 1: https://github.com/Khan/perseus/tree/main/packages/simple-markdown/src
// 2: https://github.com/paperclover/svelte-simple-markdown
export type Rules = Record<string, ParserRule>;
export interface ParserRule {
  name: string;
  match: MatchFunction;
  parse: ParseFunction;
  quality?: QualityFunction;
}

export class RuleList extends Array<ParserRule> {
  constructor(input?: ArrayLike<ParserRule>) {
    super();
    if (input) {
      this.push(...Array.from(input));
    }
  }

  insertBefore(rule: string, newRule: ParserRule): void {
    const index = this.findIndex((r) => r.name === rule);
    if (index === -1) {
      throw new Error(`Rule ${rule} not found`);
    }
    this.splice(index, 0, newRule);
  }

  insertAfter(rule: string, newRule: ParserRule): void {
    const index = this.findIndex((r) => r.name === rule);
    if (index === -1) {
      throw new Error(`Rule ${rule} not found`);
    }
    this.splice(index + 1, 0, newRule);
  }

  toRuleObject(): Record<string, ParserRule> {
    const result: Record<string, ParserRule> = {};
    this.forEach((rule) => {
      result[rule.name] = rule;
    });
    return result;
  }

  add(rule: ParserRule): void {
    this.push(rule);
  }

  get(rule: string): ParserRule | undefined {
    return this.find((r) => r.name === rule);
  }

  remove(rule: string): void {
    const index = this.findIndex((r) => r.name === rule);
    if (index === -1) {
      throw new Error(`Rule ${rule} not found`);
    }
    this.splice(index, 1);
  }

  clone() {
    return new RuleList(this);
  }
}

/**
 * Creates a parser for a given set of rules, with the precedence
 * specified as a list of rules.
 *
 * @param rules
 *     an object containing
 *     rule type -> {match, order, parse} objects
 *     (lower order is higher precedence)
 * @param [defaultState]
 *
 * @returns
 *     The resulting parse function, with the following parameters:
 *     @source: the input source string to be parsed
 *     @state: an optional object to be threaded through parse
 *         calls. Allows clients to add stateful operations to
 *         parsing, such as keeping track of how many levels deep
 *         some nesting is. For an example use-case, see passage-ref
 *         parsing in src/widgets/passage/passage-markdown.jsx
 */
export function createParser(
  ruleListInput: RuleList,
  defaultState: Partial<ParserState> = {},
) {
  let rules = ruleListInput.toRuleObject();
  let ruleList = Object.keys(rules);

  let latestState: ParserState;

  let nestedParse = function (source: string, state?: ParserState) {
    let result: ASTNode[] = [];
    state = state || latestState;
    latestState = state;

    while (source) {
      // store the best match, it's rule, and quality:
      let ruleType = null;
      let rule = null;
      let capture = null;
      let quality = NaN; // loop control variables:

      let i = 0;
      let currRuleType = ruleList[0];

      let currRule = rules[currRuleType];

      do {
        let currCapture = currRule.match(source, state);

        if (currCapture) {
          let currQuality = currRule.quality
            ? currRule.quality(currCapture, state)
            : 0;

          // This should always be true the first time because
          // the initial quality is NaN (that's why there's the
          // condition negation).
          if (!(currQuality <= quality)) {
            ruleType = currRuleType;
            rule = currRule;
            capture = currCapture;
            quality = currQuality;
          }
        }

        // Move on to the next item.
        // Note that this makes `currRule` be the next item
        i++;
        currRuleType = ruleList[i];
        currRule = rules[currRuleType];
      } while (
        // keep looping while we're still within the ruleList
        currRule &&
        // if we don't have a match yet, continue
        (!capture ||
          // or if we have a match, but the next rule is
          // at the same order, and has a quality measurement
          // functions, then this rule must have a quality
          // measurement function (since they are sorted before
          // those without), and we need to check if there is
          // a better quality match
          currRule.quality)
      );

      if (!rule || !capture || !ruleType) {
        throw new Error(
          "Could not find a matching rule for the below " +
            "content. The rule with highest `order` should " +
            "always match content provided to it. Check " +
            "the definition of `match` for '" +
            ruleList[ruleList.length - 1] +
            "'. It seems to not match the following source:\n" +
            source,
        );
      }

      if (capture.index) {
        // If present and non-zero, i.e. a non-^ regexp result:
        throw new Error(
          "`match` must return a capture starting at index 0 " +
            "(the current parse index). Did you forget a ^ at the " +
            "start of the RegExp?",
        );
      }

      let parsed = rule.parse(capture, nestedParse, state);

      // We maintain the same object here so that rules can
      // store references to the objects they return and
      // modify them later. (oops sorry! but this adds a lot
      // of power--see reflinks.)

      // We also let rules override the default type of
      // their parsed node if they would like to, so that
      // there can be a single output function for all links,
      // even if there are several rules to parse them.
      if (!parsed.type) {
        parsed.type = ruleType;
      }

      // Collapse text nodes
      if (
        parsed.type === "text" && result[result.length - 1]?.type === "text"
      ) {
        result[result.length - 1].content += parsed.content;
      } else {
        result.push(parsed as ASTNode);
      }

      state.prevCapture = capture;
      source = source.substring(state.prevCapture[0].length);
    }

    return result;
  };

  let outerParse = function (
    source: string,
    state: ParserState = { inline: false },
  ) {
    latestState = populateInitialState(state, defaultState);

    if (!latestState.inline && !latestState.disableAutoBlockNewlines) {
      source = source + "\n\n";
    }

    // We store the previous capture so that match functions can
    // use some limited amount of lookbehind. Lists use this to
    // ensure they don't match arbitrary '- ' or '* ' in inline
    // text (see the list rule for more information). This stores
    // the full regex capture object, if there is one.
    latestState.prevCapture = undefined;
    return nestedParse(preprocess(source), latestState);
  };

  return outerParse;
}

type Multiple<T> = T | T[];
type Nullable<T> = T | null | undefined;

export type MatchFunction = (
  source: string,
  state: ParserState,
) => Nullable<RegExpMatchArray>;

export type Parser = (source: string, state?: ParserState) => ASTNode[];

export type ParseFunction = (
  source: RegExpMatchArray,
  nestedParse: Parser,
  state: ParserState,
) => TypeOptionalASTNode;

export type QualityFunction = (
  capture: RegExpMatchArray,
  state: ParserState,
) => number;

export interface ParserState {
  inline: boolean;
  prevCapture?: RegExpMatchArray;
  [key: string]: any;
}

export interface ASTNode {
  type: string;
  content?: ASTNode[] | string;
  [key: string]: any;
}

export type TypeOptionalASTNode = Omit<ASTNode, "type"> & { type?: string };

export interface RefNode {
  type: string;
  content?: Multiple<ASTNode>;
  target?: string;
  title?: string;
  alt?: string;
}

/** Creates a match function for an inline scoped element from a regex */
export function inlineRegex(regex: RegExp): MatchFunction {
  return (source, state) => {
    if (state.inline) {
      return regex.exec(source);
    } else {
      return null;
    }
  };
}

/** Creates a match function for a block scoped element from a regex */
export function blockRegex(regex: RegExp): MatchFunction {
  return (source, state) => {
    if (state.inline) {
      return null;
    } else {
      return regex.exec(source);
    }
  };
}

/** Creates a match function from a regex, ignoring block/inline scope */
export function anyScopeRegex(regex: RegExp): MatchFunction {
  return (source) => {
    return regex.exec(source);
  };
}

const UNESCAPE_URL_R = /\\([^0-9A-Za-z\s])/g;
export function unescapeUrl(rawUrlString: string) {
  return rawUrlString.replace(UNESCAPE_URL_R, "$1");
}

/**
 * Parse some content with the parser `parse`, with state.inline
 * set to true. Useful for block elements; not generally necessary
 * to be used by inline elements (where state.inline is already true.
 */
export function parseInline(
  parse: Parser,
  content: string,
  state: ParserState,
) {
  const isCurrentlyInline = state.inline || false;
  state.inline = true;
  const result = parse(content, state);
  state.inline = isCurrentlyInline;
  return result;
}

export function parseBlock(parse: Parser, content: string, state: ParserState) {
  const isCurrentlyInline = state.inline || false;
  state.inline = false;
  const result = parse(content + "\n\n", state);
  state.inline = isCurrentlyInline;
  return result;
}

export function parseCaptureInline(
  capture: RegExpMatchArray,
  parse: Parser,
  state: ParserState,
) {
  return {
    content: parseInline(parse, capture[1], state),
  };
}

export function ignoreCapture() {
  return {};
}

export function sanitizeUrl(url?: string) {
  if (url == null) {
    return null;
  }
  try {
    const prot = new URL(url, "https://localhost").protocol;
    if (
      prot.indexOf("javascript:") === 0 ||
      prot.indexOf("vbscript:") === 0 ||
      prot.indexOf("data:") === 0
    ) {
      return null;
    }
  } catch (e) {
    // invalid URLs should throw a TypeError
    // see for instance: `new URL("");`
    return null;
  }
  return url;
}

const CR_NEWLINE_R = /\r\n?/g;
const TAB_R = /\t/g;
const FORMFEED_R = /\f/g;

/**
 * Turn various whitespace into easy-to-process whitespace
 */
function preprocess(source: string) {
  return source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(
    TAB_R,
    "    ",
  );
}

function populateInitialState(
  givenState: Partial<ParserState>,
  defaultState: Partial<ParserState>,
) {
  let state = givenState || {};

  for (let prop in defaultState) {
    if (Object.prototype.hasOwnProperty.call(defaultState, prop)) {
      state[prop] = defaultState[prop];
    }
  }

  return state as ParserState;
}

// recognize a `*` `-`, `+`, `1.`, `2.`... list bullet
const LIST_BULLET = "(?:[*+-]|\\d+\\.)";

// recognize the start of a list item:
// leading space plus a bullet plus a space (`   * `)
const LIST_ITEM_PREFIX = "( *)(" + LIST_BULLET + ") +";
const LIST_ITEM_PREFIX_R = new RegExp("^" + LIST_ITEM_PREFIX);

// recognize an individual list item:
//  * hi
//    this is part of the same item
//
//    as is this, which is a new paragraph in the same item
//
//  * but this is not part of the same item
const LIST_ITEM_R = new RegExp(
  LIST_ITEM_PREFIX + "[^\\n]*(?:\\n" + "(?!\\1" + LIST_BULLET +
    " )[^\\n]*)*(\n|$)",
  "gm",
);
const BLOCK_END_R = /\n{2,}$/;
const INLINE_CODE_ESCAPE_BACKTICKS_R = /^ (?= *`)|(` *) $/g;

// recognize the end of a paragraph block inside a list item:
// two or more newlines at end end of the item
const LIST_BLOCK_END_R = BLOCK_END_R;
const LIST_ITEM_END_R = / *\n+$/;

// check whether a list item has paragraphs: if it does,
// we leave the newlines at the end
const LIST_R = new RegExp(
  "^( *)(" +
    LIST_BULLET +
    ") " +
    "[\\s\\S]+?(?:\n{2,}(?! )" +
    "(?!\\1" +
    LIST_BULLET +
    " )\\n*" +
    // the \\s*$ here is so that we can parse the inside of nested
    // lists, where our content might end before we receive two `\n`s
    "|\\s*\n*$)",
);
const LIST_LOOKBEHIND_R = /(?:^|\n)( *)$/;

const TABLES = (function () {
  const TABLE_ROW_SEPARATOR_TRIM = /^ *\| *| *\| *$/g;
  const TABLE_CELL_END_TRIM = / *$/;
  const TABLE_RIGHT_ALIGN = /^ *-+: *$/;
  const TABLE_CENTER_ALIGN = /^ *:-+: *$/;
  const TABLE_LEFT_ALIGN = /^ *:-+ *$/; // TODO: This needs a real type

  const parseTableAlignCapture = (alignCapture: string) => {
    if (TABLE_RIGHT_ALIGN.test(alignCapture)) {
      return "right";
    } else if (TABLE_CENTER_ALIGN.test(alignCapture)) {
      return "center";
    } else if (TABLE_LEFT_ALIGN.test(alignCapture)) {
      return "left";
    } else {
      return null;
    }
  };

  const parseTableAlign = (source: string, trimEndSeparators: boolean) => {
    if (trimEndSeparators) {
      source = source.replace(TABLE_ROW_SEPARATOR_TRIM, "");
    }

    const alignText = source.trim().split("|");
    return alignText.map(parseTableAlignCapture);
  };

  const parseTableRow = (
    source: string,
    parse: Parser,
    state: ParserState,
    trimEndSeparators: boolean,
  ) => {
    const prevInTable = state.inTable;
    state.inTable = true;
    const tableRow = parse(source.trim(), state);
    state.inTable = prevInTable;
    const cells: ASTNode[][] = [[]];
    tableRow.forEach(function (node, i) {
      if (node.type === "tableSeparator") {
        // Filter out empty table separators at the start/end:
        if (!trimEndSeparators || (i !== 0 && i !== tableRow.length - 1)) {
          // Split the current row:
          cells.push([]);
        }
      } else {
        if (
          typeof node.content === "string" &&
          (tableRow[i + 1] == null || tableRow[i + 1].type === "tableSeparator")
        ) {
          node.content = node.content.replace(TABLE_CELL_END_TRIM, "");
        }

        cells[cells.length - 1].push(node);
      }
    });
    return cells;
  };

  /**
   * @param {string} source
   * @param {SimpleMarkdown.Parser} parse
   * @param {SimpleMarkdown.State} state
   * @param {boolean} trimEndSeparators
   * @returns {SimpleMarkdown.ASTNode[][]}
   */
  const parseTableCells = function (
    source: string,
    parse: Parser,
    state: ParserState,
    trimEndSeparators: boolean,
  ) {
    const rowsText = source.trim().split("\n");
    return rowsText.map(function (rowText) {
      return parseTableRow(rowText, parse, state, trimEndSeparators);
    });
  };

  /**
   * @param {boolean} trimEndSeparators
   * @returns {SimpleMarkdown.SingleNodeParseFunction}
   */
  const parseTable = function (trimEndSeparators: boolean) {
    return function (
      capture: RegExpMatchArray,
      parse: Parser,
      state: ParserState,
    ) {
      state.inline = true;
      const header = parseTableRow(capture[1], parse, state, trimEndSeparators);
      const align = parseTableAlign(capture[2], trimEndSeparators);
      const cells = parseTableCells(
        capture[3],
        parse,
        state,
        trimEndSeparators,
      );
      state.inline = false;
      return {
        type: "table",
        header: header,
        align: align,
        cells: cells,
      };
    };
  };

  return {
    parseTable: parseTable(true),
    parseNpTable: parseTable(false),
    TABLE_REGEX: /^ *(\|.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/,
    NPTABLE_REGEX:
      /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,
  };
})();

const LINK_INSIDE = "(?:\\[[^\\]]*\\]|[^\\[\\]]|\\](?=[^\\[]*\\]))*";
const LINK_HREF_AND_TITLE =
  "\\s*<?((?:\\([^)]*\\)|[^\\s\\\\]|\\\\.)*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*";
const AUTOLINK_MAILTO_CHECK_R = /mailto:/i;

function parseRef(
  capture: RegExpMatchArray,
  state: ParserState,
  refNode: RefNode,
) {
  const ref = (capture[2] || capture[1]).replace(/\s+/g, " ").toLowerCase();

  // We store information about previously seen defs on
  // state._defs (_ to deconflict with client-defined
  // state). If the def for this reflink/refimage has
  // already been seen, we can use its target/source
  // and title here:
  if (state._defs && state._defs[ref]) {
    const def = state._defs[ref];

    // `refNode` can be a link or an image. Both use
    // target and title properties.
    refNode.target = def.target;
    refNode.title = def.title;
  }

  // In case we haven't seen our def yet (or if someone
  // overwrites that def later on), we add this node
  // to the list of ref nodes for that def. Then, when
  // we find the def, we can modify this link/image AST
  // node :).
  // I'm sorry.
  state._refs = state._refs || {};
  state._refs[ref] = state._refs[ref] || [];

  state._refs[ref].push(refNode);

  return refNode;
}

export const defaultRules = new RuleList();
{
  defaultRules.add({
    name: "heading",
    match: blockRegex(/^ *(#{1,6})([^\n]+?)#* *(?:\n *)+\n/),
    parse: function (capture, parse, state) {
      return {
        level: capture[1].length,
        content: parseInline(parse, capture[2].trim(), state),
      };
    },
  });

  defaultRules.add({
    name: "nptable",
    match: blockRegex(TABLES.NPTABLE_REGEX),
    parse: TABLES.parseNpTable,
  });

  defaultRules.add({
    name: "lheading",
    match: blockRegex(/^([^\n]+)\n *(=|-){3,} *(?:\n *)+\n/),
    parse(capture, parse, state) {
      return {
        type: "heading",
        level: capture[2] === "=" ? 1 : 2,
        content: parseInline(parse, capture[1], state),
      };
    },
  });

  defaultRules.add({
    name: "hr",
    match: blockRegex(/^( *[-*_]){3,} *(?:\n *)+\n/),
    parse: ignoreCapture,
  });

  defaultRules.add({
    name: "codeBlock",
    match: blockRegex(/^(?: {4}[^\n]+\n*)+(?:\n *)+\n/),
    parse(capture) {
      const content = capture[0].replace(/^ {4}/gm, "").replace(/\n+$/, "");
      return {
        lang: undefined,
        content: content,
      };
    },
  });

  defaultRules.add({
    name: "fence",
    match: blockRegex(
      /^ *(`{3,}|~{3,}) *(?:(\S+) *)?\n([\s\S]+?)\n?\1 *(?:\n *)+\n/,
    ),
    parse(capture) {
      return {
        type: "codeBlock",
        lang: capture[2] || undefined,
        content: capture[3],
      };
    },
  });

  defaultRules.add({
    name: "blockQuote",
    match: blockRegex(/^( *>[^\n]+(\n[^\n]+)*\n*)+\n{2,}/),
    parse(capture, parse, state) {
      const content = capture[0].replace(/^ *> ?/gm, "");
      return {
        content: parse(content, state),
      };
    },
  });

  defaultRules.add({
    name: "list",

    match(source, state) {
      // We only want to break into a list if we are at the start of a
      // line. This is to avoid parsing "hi * there" with "* there"
      // becoming a part of a list.
      // You might wonder, "but that's inline, so of course it wouldn't
      // start a list?". You would be correct! Except that some of our
      // lists can be inline, because they might be inside another list,
      // in which case we can parse with inline scope, but need to allow
      // nested lists inside this inline scope.
      const prevCaptureStr = state.prevCapture == null
        ? ""
        : state.prevCapture[0];
      const isStartOfLineCapture = LIST_LOOKBEHIND_R.exec(prevCaptureStr);
      const isListBlock = state._list || !state.inline;

      if (isStartOfLineCapture && isListBlock) {
        source = isStartOfLineCapture[1] + source;
        return LIST_R.exec(source);
      } else {
        return null;
      }
    },
    parse(capture, parse, state) {
      const bullet = capture[2];
      const ordered = bullet.length > 1;
      const start = ordered ? +bullet : undefined;
      // We know this will match here, because of how the regexes are defined
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      const items = capture[0].replace(LIST_BLOCK_END_R, "\n").match(
        LIST_ITEM_R,
      )!;

      let lastItemWasAParagraph = false;
      const itemContent = items.map(function (item, i) {
        // We need to see how far indented this item is:
        const prefixCapture = LIST_ITEM_PREFIX_R.exec(item);
        const space = prefixCapture ? prefixCapture[0].length : 0; // And then we construct a regex to "unindent" the subsequent
        // lines of the items by that amount:

        const spaceRegex = new RegExp("^ {1," + space + "}", "gm"); // Before processing the item, we need a couple things

        const content = item // remove indents on trailing lines:
          .replace(spaceRegex, "") // remove the bullet:
          .replace(LIST_ITEM_PREFIX_R, ""); // I'm not sur4 why this is necessary again?
        // Handling "loose" lists, like:
        //
        //  * this is wrapped in a paragraph
        //
        //  * as is this
        //
        //  * as is this

        const isLastItem = i === items.length - 1;
        const containsBlocks = content.indexOf("\n\n") !== -1; // Any element in a list is a block if it contains multiple
        // newlines. The last element in the list can also be a block
        // if the previous item in the list was a block (this is
        // because non-last items in the list can end with \n\n, but
        // the last item can't, so we just "inherit" this property
        // from our previous element).

        const thisItemIsAParagraph = containsBlocks ||
          (isLastItem && lastItemWasAParagraph);
        lastItemWasAParagraph = thisItemIsAParagraph; // backup our state for restoration afterwards. We're going to
        // want to set state._list to true, and state.inline depending
        // on our list's looseness.

        const oldStateInline = state.inline;
        const oldStateList = state._list;
        state._list = true; // Parse inline if we're in a tight list, or block if we're in
        // a loose list.

        let adjustedContent;

        if (thisItemIsAParagraph) {
          state.inline = false;
          adjustedContent = content.replace(LIST_ITEM_END_R, "\n\n");
        } else {
          state.inline = true;
          adjustedContent = content.replace(LIST_ITEM_END_R, "");
        }

        const result = parse(adjustedContent, state); // Restore our state before returning

        state.inline = oldStateInline;
        state._list = oldStateList;
        return result;
      });

      return {
        ordered: ordered,
        start: start,
        content: itemContent,
      };
    },
  });

  defaultRules.add({
    name: "def",
    // TODO: This will match without a blank line before the next
    // block element, which is inconsistent with most of the rest of
    // simple-markdown.
    match: blockRegex(
      /^ *\[([^\]]+)\]: *<?([^\s>]*)>?(?: +["(]([^\n]+)[")])? *\n(?: *\n)*/,
    ),
    parse(capture, parse, state) {
      const def = capture[1].replace(/\s+/g, " ").toLowerCase();
      const target = capture[2];
      const title = capture[3];

      // Look for previous links/images using this def
      // If any links/images using this def have already been declared,
      // they will have added themselves to the state._refs[def] list
      // (_ to deconflict with client-defined state). We look through
      // that list of reflinks for this def, and modify those AST nodes
      // with our newly found information now.
      // Sorry :(.
      if (state._refs && state._refs[def]) {
        // `refNode` can be a link or an image
        state._refs[def].forEach((refNode: RefNode) => {
          refNode.target = target;
          refNode.title = title;
        });
      }

      // Add this def to our map of defs for any future links/images
      // In case we haven't found any or all of the refs referring to
      // this def yet, we add our def to the table of known defs, so
      // that future reflinks can modify themselves appropriately with
      // this information.
      state._defs = state._defs || {};
      state._defs[def] = {
        target: target,
        title: title,
      };

      // return the relevant parsed information
      // for debugging only.
      return {
        def: def,
        target: target,
        title: title,
      };
    },
  });

  defaultRules.add({
    name: "table",
    match: blockRegex(TABLES.TABLE_REGEX),
    parse: TABLES.parseTable,
  });

  defaultRules.add({
    name: "newline",
    match: blockRegex(/^(?:\n *)*\n/),
    parse: ignoreCapture,
  });

  defaultRules.add({
    name: "paragraph",
    match: blockRegex(/^((?:[^\n]|\n(?! *\n))+)(?:\n *)+\n/),
    parse: parseCaptureInline,
  });

  defaultRules.add({
    name: "escape",
    // We don't allow escaping numbers, letters, or spaces here so that
��@VXLL
p8�VxK<e@,vD�l3��5�� �???�????????�????????�??????????



d
�main.c�prop�
gt�p���
th���
r�w�tU�
n0tf�
c
�iwby�R
�



�







�







�







�







�







�







�







�







�







�







�











��"\DlM�ain��





Ke�xI�it0"a�izP
P�rop�	g0��
o



�`pAd�3264T���Ph�

O

�e�R�w��e�

'

�p{I*m�optPa�bP	N�mP	1�Pp
ac�O
�
��N�q*fp ci
nC�Q*bpcko



��ch�p�wSuPsys�p)e�VPr�5	�h��o



�







�







�







�







�







�







�









��������������ų`����j��
��(0��t�
Pro�ces ��r�atPdpTh� VxK�x �vpr�i�n�Bi�1.12Ar428�
(TR�l0aPe�)

U�p�gPam�64-biP an�d�
t�op��rp
tng�
�sy�1_Q1�Ful �5�
h2oR3E�XE:
CPl\��	F��s\G�tW�P�	ow�\0Zi�
g�1\2n��g�.px0�ZC�m��
l�e]� 9� �-UPoppPgrms�q
u�3p�0r�lp�	=��1�-�i�n�e�=�t�h�QQ-z�u�r%l�%$
#

�ZS�c�q%f�y��q1i0	Qz���� 
q�%�.���p
!%��Ifo�at%�e�e�s�vR�u�eP
f2�a�i0��DP
�s�bp
eF��CP(i�d�0r�A�&p��*c�]Qcv$V�ru�oPf�� S��1;�/ss�o0�S��0P;0�1Ak�"P�S0r0n�kR� d
f�U14tlp
ap#e�p DL�5�>o�
�&Q��� 0s"7�<�77�}7;��%~3pJ�<y?1;�N�
�Bq"qU�B�m��w�B��Q_}
M�?r�F�SnuUw�@QQKc��1/c��rp9s��J��EP=q;pr AP 1Y�Xu0B\jU
kP@2�`006�07
h�tp�I�t�
W]d�3[S#�S8a�\�Zb�P,m��q%�NP�2e�d\uU.06\v� � Ip:qjl�� WiF0\bPn\;C:8Progam� �lesl�CdmTon2jI"tJlJ
�r�
js�ofmv�	�
%ndw[Sy
Cm3�2G!P)e�Sh]
kv1�.0-!�M�
cAoiofFt�b�C P�-rE�
o�ma�kc� T�?olk�!t�7PuрTY�U�=�bU��c�dl�+e�Cc�5r�s�\ATp�D�	t�
\|L�
��y�Ё#P���t�%��\�`y�l*h�n��8�=S��zi�(t�>���"�"��iG�XKf\�0m�����.s@
o@Bp@A�s@Hi@�s�M�˾i@���o��YK�N�7bd��.j@w�Ga�Cp�Cn�	ovU�0m�&c�Rr�aeb|%�"����j��
���`"�``r�ZS c 0�f�
lU` y�]i`	i�TiU�[l�z d�D� ]L��w`a�cZs`b`g�.�T� :��w�� f 
�u�a{�	s�a�	U�m �a h�iA 
:

b"�?�VxK�	�x�"�64�I��sZm`n��w��e+e8-`sl��mf�k	;���yK�u�&�r`c��?rony^E GaCaR�<A��pU�Fu�x\�]d�-�ţ�.�(.7�-�Bo�s`=��*�k�%m&#�\1��b`Du/3!b��������~�~�~�f�Ke7�S>9��f?\��~���~ \�~~n�J�~!�*W]�~\�?1o�! P�Hq4{11�~o�~�~�3��~�~1��������_�?F
�~r[pGq�h�&\�
c��poP?�h�Um0
�??�2i�J�����U��2�2���
�
�~q0&���~���uېr�wnT�S;�d=�?�py&
@�pXR�.�|�qXQ\5y�p�rP�:�xAD�uAЫ�I�.�^т P�>�
k�wa0
v�}np�߇�+�L�Ѕ R!�KEP
�NPL��bPQ��_Y(_P
_��)�vP>��x�
��^&����dp3l��s��
��)����U0q1 �z�x���r�� W2_���t�ԋ��@p
��m�ڱ�wk�+r��k;�w! p��4e��)��l�p�
�1� 
o���/ ����q]�\0e_xl"r���1 UR зx00:7
��20�Q
i�00 (size:h117
52<bytls)��j��
��
&@�qThV  DL  kxn~.dl w"a� mp�p-d?Fu�ptE 5o
eQ
�"C
�\ProgaM F�lOs\V5wKx64
�"

U�To�:d�d�4au�< ��x�
���
7ŀ.E�
6A�m�
��3��168�#��"����KERN�LB��:S�ѢW@Mn@gVo@fANs�{s@@eq�T32�OW"�OD�@17�U�O43@N&2��c�&
���&�
R@owB�A��G�i�1p��r�4A��A�âGS->�kņDW�"�UN�l�Pb�c�npv-�M�jk�G��tMsm@n���w����A)n�tY,:;�_�6 �
ob0z9 :7`"�b1-�:+{�:�=t���e�Vq;b�`|s�D�;�(���m �vc�
1#��I`���.f�?��!�h Yt�P�i�?�~e ;�m?E#C��A-�1`�!E4 � 髧#k7r���2�h?�?�?��'+�'�'B;hm�l7`�sly'�j�L_-l0%�'{{�uX�'gy�'Q[m0Sgl� �<t��	0�~�Q�&E��E�&�?�6rz204�&?�`A�!��_0VsUt0��-l�@____ߎ�َ�_�|�_ip�\0
~i�5��
??�6]��C��
�_6�8��<Q�?=X-X6P��|јVБPI�#U_XxP"d0ya��is��0�g� �0mo�_g�ׄ��R_Wg_Ջ��1�9F�y��ag{_g���_S_g��mKP7��e�<\��a�ЩvPp0u	�*�*�q)�gB���*3�6���*_��� �4�}�
s��g�(��s�S�S_S__Y��SF?T4T8r�0pw?TwP�}q�c�P�o�`�S�'�'��_g
d��w0\S�Y0T��M�C\P
�e��h��5??�;�&��1gQ�6g?���&?��P�WR�h4[�o th�epDL:H"C:\Wind ows<s
yt�m3"2DRPVR T4.Rl�l"

��oa"e �t�0x0�7FED� (cize

�1g
k896Cb�
�s)4���j��
��P@�$��	� �ibpcr_2-�8�
0�] �ta�?h m�Yp��_U�Ru�l�?p�eh-�t����P�1o�g�a�& �!i�!�e�.\G��t���m��g�A6��\�T}��\��Z�����-3G�{��M\61�c3M�4@9�[&
\�+�
R@Uw�=��h Ô �5m�R�o@t@� K@~hRN@
LB�Ŏ U@c>@k@�b@ZsW�SyE(hm�^ve�~tH|-EA�t��Y�}N�zDh^1��DLI���b•\u��l@b�w��%G2� 68 C�
-Gau6�t�7?u"u?G?G?G�?G�?Gr�D�����OTj� �\�u�e c.�ew"_����;�yGV`lK�k�x����q?�#Be�^B @#��D1��7`/�;(knoUS�`RR��?(a��?(�G1�%�#07 1W��e�%0��4�n ���y�!�a�9&�}5mNG�LI�%pPF�_o_oL]?�?�3�������25_H۰,qS4��%8�%���9��f�%L���K_]߁`߁�%����������??;B0��
1%5'3�
�7�U��$ �/�P��X�7d�$�P�7���s�/�����1�$C�$�$8�$q+Iߧ������7KWM9�ߦ��� 0J�����^צ��^�^����CPD�߀��30`80?&Qwj^8V^S�IO0�����r9�_^��?1�EPI
1]94���1�M2~�Q͝&RP�W��R�F�LLL�͟^����9}_dR__�:C��q
1]�^�q2�L��^ym�&��T0M�PA�_I�Fu_d��dp"�A �K����
Wr0���9��29216 bytes)U���j��
��(L@��lTh�  DL �CFGMR3�.d�l wa�� mppj�d�Fu>pjtM }o[
e+Y:	"]:�\WinW�oSss�s�
ms\�"
�
�okd� u� 0x�
0�
�7�bE�
D�
4�� (�`iz��G2��184�N��O�JEA^U����U!�ME@`2u�M8@L0��AV��jΛo@�e�@t�Űk���J7�}E�Ϙ1�Q9@�QKe�V�PKDEV�OBJ�?s/s1?&�#�rE�k5&�%6�%9���%Tq�Kk��n`Ct�%������PrPog�a�� �`�i�Ya�V K �x���a\/�'U�'C�e7vs5bi4 t-sM+�DN�S [PIM����Ls!ץ�1�%�%D I!J��s37�`�7`&/��%�%W�%�2_�/s�����%��%l�s��9�E��B�%�,�30�&ц�%�L��f߾9�%�%���tP7Q����dPw�~\0~y0��??;E�P
1?%2P%68R%��l�p�b�sЖ-0_%/����?L�C�8\�?L7LG�tޚmP
jnPOw�\�ќ\��Oi�s�