Claude Fable 5.1 徹底検証

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

こまめな確認なら一番軽い設定で済ませる。
うまく使う人は二段階の深さを使い分ける。
りくつよりまず三度試して最適な量を探る。
つまらない定型作業は四割ほどの力で回す。
のるかそるかの判断は五段階の最大で挑む。
かける時間と費用は六つの案件で比べよう。
ぎりぎりの締切前は七割の深さで手を打つ。

こつは一日の初めに配分を決めることです。
うまく二種類の深さを場面で切り替えよう。
りずむよく三段階の軽い設定で定型を回す。
つまり四半期の戦略案には深い設定を使う。
のちに五分で振り返り選択の精度を上げる。
かかる時間は六割も減り質は落ちなかった。
ぎもんは七つの視点で見直し習慣にしよう。

こつは全てを一律に深く悩ませないことだ。
うまく浅いと深いの二段構えで使い分ける。
りくつは単純で軽中重の三段を選ぶだけだ。
つまらぬ定型作業は四割ほどの力で回せる。
のるかそるかの判断には五倍じっくり練る。
かかる費用と時間を六つの案件で見比べる。
ぎもんが残れば七割で止めて人に確かめる。

この道具は一律でなく深さを変えて使おう。
うまく回す鍵は浅さと深さの二刀流にある。
りくつを問う難題は三倍じっくり練らせる。
つぎに定型の作業は四秒で済む浅さでいい。
のこる仕事は五段の目盛りを案件で選ぼう。
かかる費用は深さで六倍も違うと心得よう。
ぎりぎりの締切こそ七分の深さで速く返す。

function match(pattern, text) {
  let pos = 0;

  function parseAlt() {
    const alts = [parseSeq()];
    while (pos < pattern.length && pattern[pos] === '|') {
      pos++;
      alts.push(parseSeq());
    }
    return alts.length === 1 ? alts[0] : { t: 'alt', alts };
  }

  function parseSeq() {
    const items = [];
    while (pos < pattern.length && pattern[pos] !== '|' && pattern[pos] !== ')') {
      let atom = parseAtom();
      while (pos < pattern.length && (pattern[pos] === '*' || pattern[pos] === '+' || pattern[pos] === '?')) {
        const q = pattern[pos++];
        atom = {
          t: 'rep',
          node: atom,
          min: q === '+' ? 1 : 0,
          max: q === '?' ? 1 : Infinity
        };
      }
      items.push(atom);
    }
    return { t: 'seq', items };
  }

  function parseAtom() {
    const c = pattern[pos++];
    if (c === '(') {
      const node = parseAlt();
      if (pattern[pos] !== ')') throw new Error('Unbalanced parenthesis');
      pos++;
      return node;
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      const e = pattern[pos++];
      if (e === undefined) throw new Error('Trailing backslash');
      if (e === 'd') return { t: 'cls', neg: false, items: [['0', '9']] };
      return { t: 'ch', c: e };
    }
    if (c === '.') return { t: 'any' };
    if (c === '*' || c === '+' || c === '?') throw new Error('Nothing to repeat');
    if (c === ')') throw new Error('Unmatched parenthesis');
    return { t: 'ch', c };
  }

  function parseClass() {
    let neg = false;
    if (pattern[pos] === '^') {
      neg = true;
      pos++;
    }
    const items = [];
    let first = true;
    while (pos < pattern.length && (pattern[pos] !== ']' || first)) {
      first = false;
      let lo = pattern[pos++];
      if (lo === '\\' && pos < pattern.length) lo = pattern[pos++];
      if (pattern[pos] === '-' && pos + 1 < pattern.length && pattern[pos + 1] !== ']') {
        pos++;
        let hi = pattern[pos++];
        if (hi === '\\' && pos < pattern.length) hi = pattern[pos++];
        items.push([lo, hi]);
      } else {
        items.push([lo, lo]);
      }
    }
    if (pattern[pos] !== ']') throw new Error('Unterminated character class');
    pos++;
    return { t: 'cls', neg, items };
  }

  const ast = parseAlt();
  if (pos < pattern.length) throw new Error('Unexpected character at ' + pos);

  function m(n, i, k) {
    switch (n.t) {
      case 'ch':
        return i < text.length && text[i] === n.c && k(i + 1);
      case 'any':
        return i < text.length && k(i + 1);
      case 'cls': {
        if (i >= text.length) return false;
        const ch = text[i];
        let hit = false;
        for (let j = 0; j < n.items.length; j++) {
          if (ch >= n.items[j][0] && ch <= n.items[j][1]) {
            hit = true;
            break;
          }
        }
        return hit !== n.neg && k(i + 1);
      }
      case 'seq': {
        const items = n.items;
        const step = (idx, j) => {
          if (idx === items.length) return k(j);
          return m(items[idx], j, jj => step(idx + 1, jj));
        };
        return step(0, i);
      }
      case 'alt':
        for (let a = 0; a < n.alts.length; a++) {
          if (m(n.alts[a], i, k)) return true;
        }
        return false;
      case 'rep': {
        const r = (count, j) => {
          if (count < n.max) {
            const ok = m(n.node, j, jj => {
              if (jj === j && count >= n.min) return false;
              return r(count + 1, jj);
            });
            if (ok) return true;
          }
          return count >= n.min && k(j);
        };
        return r(0, i);
      }
    }
    return false;
  }

  return m(ast, 0, i => i === text.length);
}

function match(pattern, text) {
  var pos = 0;

  function parseAlt() {
    var alts = [parseSeq()];
    while (pos < pattern.length && pattern[pos] === '|') {
      pos++;
      alts.push(parseSeq());
    }
    return { type: 'alt', alts: alts };
  }

  function parseSeq() {
    var items = [];
    while (pos < pattern.length && pattern[pos] !== '|' && pattern[pos] !== ')') {
      var atom = parseAtom();
      while (pos < pattern.length) {
        var q = pattern[pos];
        if (q === '*') { atom = { type: 'repeat', node: atom, min: 0, max: Infinity }; pos++; }
        else if (q === '+') { atom = { type: 'repeat', node: atom, min: 1, max: Infinity }; pos++; }
        else if (q === '?') { atom = { type: 'repeat', node: atom, min: 0, max: 1 }; pos++; }
        else break;
      }
      items.push(atom);
    }
    return items;
  }

  function parseAtom() {
    var c = pattern[pos];
    if (c === '(') {
      pos++;
      var inner = parseAlt();
      if (pattern[pos] === ')') pos++;
      return { type: 'group', node: inner };
    }
    if (c === '[') {
      pos++;
      var negate = false;
      if (pattern[pos] === '^') { negate = true; pos++; }
      var ranges = [];
      var first = true;
      while (pos < pattern.length && (pattern[pos] !== ']' || first)) {
        first = false;
        var lo = pattern[pos];
        if (lo === '\\' && pos + 1 < pattern.length) { pos++; lo = pattern[pos]; }
        pos++;
        var hi = lo;
        if (pattern[pos] === '-' && pos + 1 < pattern.length && pattern[pos + 1] !== ']') {
          pos++;
          hi = pattern[pos];
          if (hi === '\\' && pos + 1 < pattern.length) { pos++; hi = pattern[pos]; }
          pos++;
        }
        ranges.push([lo, hi]);
      }
      if (pattern[pos] === ']') pos++;
      return { type: 'class', negate: negate, ranges: ranges };
    }
    if (c === '\\') {
      pos++;
      var e = pattern[pos];
      pos++;
      if (e === 'd') return { type: 'digit' };
      return { type: 'char', c: e === undefined ? '\\' : e };
    }
    if (c === '.') { pos++; return { type: 'any' }; }
    pos++;
    return { type: 'char', c: c };
  }

  var ast = parseAlt();
  var len = text.length;

  function m(node, i, k) {
    switch (node.type) {
      case 'alt':
        for (var a = 0; a < node.alts.length; a++) {
          if (mseq(node.alts[a], 0, i, k)) return true;
        }
        return false;
      case 'group':
        return m(node.node, i, k);
      case 'char':
        return i < len && text[i] === node.c && k(i + 1);
      case 'any':
        return i < len && k(i + 1);
      case 'digit':
        return i < len && text[i] >= '0' && text[i] <= '9' && k(i + 1);
      case 'class':
        if (i >= len) return false;
        var ch = text[i];
        var hit = false;
        for (var r = 0; r < node.ranges.length; r++) {
          if (ch >= node.ranges[r][0] && ch <= node.ranges[r][1]) { hit = true; break; }
        }
        if (hit === node.negate) return false;
        return k(i + 1);
      case 'repeat':
        return rep(node, i, 0, k);
    }
    return false;
  }

  function mseq(items, idx, i, k) {
    if (idx === items.length) return k(i);
    return m(items[idx], i, function (j) { return mseq(items, idx + 1, j, k); });
  }

  function rep(node, i, count, k) {
    if (count < node.max) {
      var more = m(node.node, i, function (j) {
        if (j === i) return count + 1 >= node.min ? k(j) : false;
        return rep(node, j, count + 1, k);
      });
      if (more) return true;
    }
    if (count >= node.min) return k(i);
    return false;
  }

  return m(ast, 0, function (j) { return j === len; });
}

function match(pattern, text) {
  var pos = 0;
  var n = pattern.length;

  function parseAlt(depth) {
    var options = [parseSeq(depth)];
    while (pos < n && pattern[pos] === '|') {
      pos++;
      options.push(parseSeq(depth));
    }
    return options.length === 1 ? options[0] : { type: 'alt', options: options };
  }

  function parseSeq(depth) {
    var items = [];
    while (pos < n) {
      var ch = pattern[pos];
      if (ch === '|') break;
      if (ch === ')') {
        if (depth > 0) break;
        pos++;
        items.push({ type: 'char', c: ')' });
        continue;
      }
      var atom = parseAtom(depth);
      while (pos < n) {
        var q = pattern[pos];
        if (q === '*') { pos++; atom = { type: 'rep', node: atom, min: 0, max: Infinity }; }
        else if (q === '+') { pos++; atom = { type: 'rep', node: atom, min: 1, max: Infinity }; }
        else if (q === '?') { pos++; atom = { type: 'rep', node: atom, min: 0, max: 1 }; }
        else break;
      }
      items.push(atom);
    }
    return items.length === 1 ? items[0] : { type: 'seq', items: items };
  }

  function parseAtom(depth) {
    var ch = pattern[pos];
    if (ch === '(') {
      pos++;
      var inner = parseAlt(depth + 1);
      if (pos < n && pattern[pos] === ')') pos++;
      else throw new Error('Unmatched (');
      return { type: 'group', node: inner };
    }
    if (ch === '[') {
      pos++;
      return parseClass();
    }
    if (ch === '\\') {
      pos++;
      if (pos >= n) throw new Error('Trailing backslash');
      var e = pattern[pos++];
      if (e === 'd') return { type: 'digit' };
      return { type: 'char', c: e };
    }
    if (ch === '.') {
      pos++;
      return { type: 'any' };
    }
    pos++;
    return { type: 'char', c: ch };
  }

  function parseClass() {
    var negate = false;
    var ranges = [];
    if (pos < n && pattern[pos] === '^') { negate = true; pos++; }
    var first = true;
    while (true) {
      if (pos >= n) throw new Error('Unterminated [');
      var ch = pattern[pos];
      if (ch === ']' && !first) { pos++; break; }
      first = false;
      var lo;
      if (ch === '\\') {
        pos++;
        if (pos >= n) throw new Error('Trailing backslash');
        var e = pattern[pos++];
        if (e === 'd') { ranges.push(['0', '9']); continue; }
        lo = e;
      } else {
        pos++;
        lo = ch;
      }
      if (pos + 1 < n && pattern[pos] === '-' && pattern[pos + 1] !== ']') {
        pos++;
        var hi;
        if (pattern[pos] === '\\') {
          pos++;
          if (pos >= n) throw new Error('Trailing backslash');
          hi = pattern[pos++];
        } else {
          hi = pattern[pos++];
        }
        ranges.push([lo, hi]);
      } else {
        ranges.push([lo, lo]);
      }
    }
    return { type: 'class', negate: negate, ranges: ranges };
  }

  var ast = parseAlt(0);
  if (pos < n) throw new Error('Unexpected input');

  var len = text.length;

  function m(node, i, k) {
    switch (node.type) {
      case 'char':
        return i < len && text[i] === node.c && k(i + 1);
      case 'any':
        return i < len && k(i + 1);
      case 'digit':
        return i < len && text[i] >= '0' && text[i] <= '9' && k(i + 1);
      case 'class': {
        if (i >= len) return false;
        var c = text[i];
        var hit = false;
        for (var r = 0; r < node.ranges.length; r++) {
          if (c >= node.ranges[r][0] && c <= node.ranges[r][1]) { hit = true; break; }
        }
        if (hit === node.negate) return false;
        return k(i + 1);
      }
      case 'group':
        return m(node.node, i, k);
      case 'seq':
        return seq(node.items, 0, i, k);
      case 'alt':
        for (var a = 0; a < node.options.length; a++) {
          if (m(node.options[a], i, k)) return true;
        }
        return false;
      case 'rep':
        return rep(node, i, 0, k);
    }
    return false;
  }

  function seq(items, idx, i, k) {
    if (idx === items.length) return k(i);
    return m(items[idx], i, function (j) { return seq(items, idx + 1, j, k); });
  }

  function rep(node, i, count, k) {
    if (count < node.max) {
      var ok = m(node.node, i, function (j) {
        if (j > i) return rep(node, j, count + 1, k);
        return count < node.min ? k(j) : false;
      });
      if (ok) return true;
    }
    if (count >= node.min) return k(i);
    return false;
  }

  return m(ast, 0, function (i) { return i === len; });
}

function match(pattern, text) {
  var pos = 0;
  var len = pattern.length;

  function parseAlt(depth) {
    var options = [parseSeq(depth)];
    while (pos < len && pattern[pos] === '|') {
      pos++;
      options.push(parseSeq(depth));
    }
    return { type: 'alt', options: options };
  }

  function parseSeq(depth) {
    var seq = [];
    while (pos < len) {
      var c = pattern[pos];
      if (c === '|') break;
      if (c === ')' && depth > 0) break;
      var atom = parseAtom(depth);
      if (pos < len) {
        var q = pattern[pos];
        if (q === '*') { pos++; atom = { type: 'rep', node: atom, min: 0, max: Infinity }; }
        else if (q === '+') { pos++; atom = { type: 'rep', node: atom, min: 1, max: Infinity }; }
        else if (q === '?') { pos++; atom = { type: 'rep', node: atom, min: 0, max: 1 }; }
      }
      seq.push(atom);
    }
    return seq;
  }

  function parseAtom(depth) {
    var c = pattern[pos];
    if (c === '(') {
      pos++;
      var inner = parseAlt(depth + 1);
      if (pos < len && pattern[pos] === ')') pos++;
      return inner;
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      pos++;
      if (pos >= len) return { type: 'char', ch: '\\' };
      var e = pattern[pos++];
      if (e === 'd') return { type: 'class', negate: false, items: [{ lo: '0', hi: '9' }] };
      return { type: 'char', ch: e };
    }
    if (c === '.') { pos++; return { type: 'any' }; }
    pos++;
    return { type: 'char', ch: c };
  }

  function parseClass() {
    pos++;
    var negate = false;
    if (pos < len && pattern[pos] === '^') { negate = true; pos++; }
    var items = [];
    while (pos < len && pattern[pos] !== ']') {
      var c = pattern[pos++];
      if (c === '\\' && pos < len) {
        var e = pattern[pos++];
        if (e === 'd') { items.push({ lo: '0', hi: '9' }); continue; }
        c = e;
      }
      if (pos + 1 < len && pattern[pos] === '-' && pattern[pos + 1] !== ']') {
        pos++;
        var hi = pattern[pos++];
        if (hi === '\\' && pos < len) hi = pattern[pos++];
        items.push({ lo: c, hi: hi });
      } else {
        items.push({ lo: c, hi: c });
      }
    }
    if (pos < len) pos++;
    return { type: 'class', negate: negate, items: items };
  }

  function inClass(node, ch) {
    var found = false;
    for (var i = 0; i < node.items.length; i++) {
      if (ch >= node.items[i].lo && ch <= node.items[i].hi) { found = true; break; }
    }
    return node.negate ? !found : found;
  }

  function m(node, i, k) {
    switch (node.type) {
      case 'char':
        return i < text.length && text[i] === node.ch && k(i + 1);
      case 'any':
        return i < text.length && k(i + 1);
      case 'class':
        return i < text.length && inClass(node, text[i]) && k(i + 1);
      case 'alt':
        for (var j = 0; j < node.options.length; j++) {
          if (mseq(node.options[j], 0, i, k)) return true;
        }
        return false;
      case 'rep':
        return rep(node, 0, i, k);
    }
    return false;
  }

  function mseq(seq, idx, i, k) {
    if (idx === seq.length) return k(i);
    return m(seq[idx], i, function (j) { return mseq(seq, idx + 1, j, k); });
  }

  function rep(node, count, i, k) {
    if (count < node.max) {
      if (m(node.node, i, function (j) {
        if (j === i) return k(j);
        return rep(node, count + 1, j, k);
      })) return true;
    }
    if (count >= node.min) return k(i);
    return false;
  }

  var ast = parseAlt(0);
  return m(ast, 0, function (j) { return j === text.length; });
}

function match(pattern, text) {
  const chars = Array.from(String(pattern));
  const n = chars.length;
  let pos = 0;

  function parseAlt(depth) {
    const options = [parseConcat(depth)];
    while (pos < n && chars[pos] === '|') {
      pos++;
      options.push(parseConcat(depth));
    }
    return options.length === 1 ? options[0] : { type: 'alt', options };
  }

  function parseConcat(depth) {
    const items = [];
    while (pos < n) {
      const c = chars[pos];
      if (c === '|') break;
      if (c === ')' && depth > 0) break;
      let atom = parseAtom(depth);
      while (pos < n && (chars[pos] === '*' || chars[pos] === '+' || chars[pos] === '?')) {
        const q = chars[pos++];
        atom = { type: 'rep', node: atom, min: q === '+' ? 1 : 0, max: q === '?' ? 1 : Infinity };
      }
      items.push(atom);
    }
    if (items.length === 0) return { type: 'empty' };
    return items.length === 1 ? items[0] : { type: 'concat', items };
  }

  function parseAtom(depth) {
    const c = chars[pos++];
    if (c === '(') {
      const inner = parseAlt(depth + 1);
      if (pos < n && chars[pos] === ')') pos++;
      return inner;
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      if (pos >= n) return { type: 'char', ch: '\\' };
      const d = chars[pos++];
      if (d === 'd') return { type: 'set', negate: false, ranges: [[48, 57]] };
      return { type: 'char', ch: d };
    }
    if (c === '.') return { type: 'any' };
    return { type: 'char', ch: c };
  }

  function parseClass() {
    let negate = false;
    if (pos < n && chars[pos] === '^') {
      negate = true;
      pos++;
    }
    const ranges = [];
    while (pos < n && chars[pos] !== ']') {
      let c = chars[pos++];
      if (c === '\\' && pos < n) {
        const d = chars[pos++];
        if (d === 'd') {
          ranges.push([48, 57]);
          continue;
        }
        c = d;
      }
      const lo = c.codePointAt(0);
      let hi = lo;
      if (pos + 1 < n && chars[pos] === '-' && chars[pos + 1] !== ']') {
        pos++;
        let e = chars[pos++];
        if (e === '\\' && pos < n) e = chars[pos++];
        hi = e.codePointAt(0);
      }
      ranges.push([lo, hi]);
    }
    if (pos < n) pos++;
    return { type: 'set', negate, ranges };
  }

  const ast = parseAlt(0);

  const states = [];
  function add(test) {
    states.push({ test, next: [], accept: false });
    return states.length - 1;
  }
  function eps() {
    return add(null);
  }

  function build(node) {
    switch (node.type) {
      case 'empty': {
        const s = eps();
        return [s, s];
      }
      case 'char': {
        const ch = node.ch;
        const s = add((x) => x === ch);
        const e = eps();
        states[s].next.push(e);
        return [s, e];
      }
      case 'any': {
        const s = add(() => true);
        const e = eps();
        states[s].next.push(e);
        return [s, e];
      }
      case 'set': {
        const ranges = node.ranges;
        const negate = node.negate;
        const s = add((x) => {
          const cp = x.codePointAt(0);
          let hit = false;
          for (let i = 0; i < ranges.length; i++) {
            if (cp >= ranges[i][0] && cp <= ranges[i][1]) {
              hit = true;
              break;
            }
          }
          return hit !== negate;
        });
        const e = eps();
        states[s].next.push(e);
        return [s, e];
      }
      case 'concat': {
        let first = -1;
        let prevEnd = -1;
        for (const item of node.items) {
          const [s, e] = build(item);
          if (first < 0) first = s;
          else states[prevEnd].next.push(s);
          prevEnd = e;
        }
        return [first, prevEnd];
      }
      case 'alt': {
        const s = eps();
        const e = eps();
        for (const opt of node.options) {
          const [os, oe] = build(opt);
          states[s].next.push(os);
          states[oe].next.push(e);
        }
        return [s, e];
      }
      case 'rep': {
        const [is, ie] = build(node.node);
        const e = eps();
        if (node.max === 1) {
          const s = eps();
          states[s].next.push(is, e);
          states[ie].next.push(e);
          return [s, e];
        }
        const loop = eps();
        states[loop].next.push(is, e);
        states[ie].next.push(loop);
        return node.min === 1 ? [is, e] : [loop, e];
      }
    }
  }

  const [start, end] = build(ast);
  const acceptState = add(null);
  states[acceptState].accept = true;
  states[end].next.push(acceptState);

  const mark = new Array(states.length).fill(0);
  let gen = 0;
  function closure(stack) {
    gen++;
    const out = [];
    while (stack.length) {
      const s = stack.pop();
      if (mark[s] === gen) continue;
      mark[s] = gen;
      out.push(s);
      const st = states[s];
      if (st.test === null) {
        for (let i = 0; i < st.next.length; i++) stack.push(st.next[i]);
      }
    }
    return out;
  }

  let cur = closure([start]);
  for (const ch of String(text)) {
    const seeds = [];
    for (let i = 0; i < cur.length; i++) {
      const st = states[cur[i]];
      if (st.test !== null && st.test(ch)) {
        for (let j = 0; j < st.next.length; j++) seeds.push(st.next[j]);
      }
    }
    if (seeds.length === 0) return false;
    cur = closure(seeds);
  }
  for (let i = 0; i < cur.length; i++) {
    if (states[cur[i]].accept) return true;
  }
  return false;
}

if (typeof module !== 'undefined' && module.exports) {
  module.exports = match;
  module.exports.match = match;
}

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

こまかい確認作業は一番軽い設定で進める。
うまく使えば二種類の速さを選び分けよう。
りんぎ書の要約なら約三分で仕上げられる。
つよい思案が必要な案件は四段階目で挑む。
のんびりした午後でも五分で下書きが出る。
かたい難題には六割増しの労力で深掘りだ。
ぎもんが七つも残るなら深さを上げてみる。

これは一度きりの重要な判断を助ける技だ。
うまく二つの型を毎日の業務で使い分ける。
りようする目的次第で三段階の深さを選ぶ。
つまり四半期ごとに使い方を見直すべきだ。
のちの検証には五分ほどの余裕を持たせる。
かるい作業ならば六割の労力で済ませよう。
ぎりぎりの難題こそ七割増しで深く挑もう。

この使い分けこそ第一歩となる大切な鍵だ。
うまく二段階で深さを選ぶと成果が変わる。
りかいが浅い案件は三倍の労力を注ぎたい。
つねに四半期ごとに配分を見直していこう。
のこりの五分を点検に回すだけで質が違う。
かるい仕事なら六割の力で速く済ませよう。
ぎりぎりの難所は七割増しの労力で挑もう。

こまかな作業なら一瞬の判断で片づけよう。
うんと難しい件は二倍の熟慮で挑むべきだ。
りそうは三段階で頭の使い方を変える事だ。
つまり四半期の計画は深い検討が要るのだ。
のんびり五分待てば良質な答えが出てくる。
かかる費用も六割ほど減らせる場合がある。
ぎりぎりの締切でも七割の力で乗り切れる。

function match(pattern, text) {
  // ---------- Parser ----------
  let i = 0;

  function parseAlternation() {
    const options = [parseSequence()];
    while (i < pattern.length && pattern[i] === '|') {
      i++;
      options.push(parseSequence());
    }
    if (options.length === 1) return { type: 'seq', items: options[0] };
    return { type: 'alt', options: options.map(items => ({ type: 'seq', items })) };
  }

  function parseSequence() {
    const items = [];
    while (i < pattern.length && pattern[i] !== '|' && pattern[i] !== ')') {
      items.push(parseQuantified());
    }
    return items;
  }

  function parseQuantified() {
    let atom = parseAtom();
    while (i < pattern.length) {
      const c = pattern[i];
      if (c === '*') { i++; atom = { type: 'rep', min: 0, max: Infinity, node: atom }; }
      else if (c === '+') { i++; atom = { type: 'rep', min: 1, max: Infinity, node: atom }; }
      else if (c === '?') { i++; atom = { type: 'rep', min: 0, max: 1, node: atom }; }
      else break;
    }
    return atom;
  }

  function parseAtom() {
    const c = pattern[i];
    if (c === '(') {
      i++;
      const inner = parseAlternation();
      if (pattern[i] !== ')') throw new Error('unbalanced parenthesis');
      i++;
      return inner;
    }
    if (c === '[') {
      i++;
      let neg = false;
      if (pattern[i] === '^') { neg = true; i++; }
      const ranges = [];
      while (i < pattern.length && pattern[i] !== ']') {
        let ch = pattern[i];
        if (ch === '\\' && i + 1 < pattern.length) { i++; ch = pattern[i]; }
        i++;
        if (pattern[i] === '-' && i + 1 < pattern.length && pattern[i + 1] !== ']') {
          i++;
          let hi = pattern[i];
          if (hi === '\\' && i + 1 < pattern.length) { i++; hi = pattern[i]; }
          i++;
          ranges.push([ch, hi]);
        } else {
          ranges.push([ch, ch]);
        }
      }
      if (pattern[i] !== ']') throw new Error('unterminated class');
      i++;
      return { type: 'class', neg, ranges };
    }
    if (c === '\\') {
      i++;
      if (i >= pattern.length) throw new Error('trailing backslash');
      const e = pattern[i];
      i++;
      if (e === 'd') return { type: 'digit' };
      return { type: 'char', c: e };
    }
    if (c === '.') { i++; return { type: 'any' }; }
    i++;
    return { type: 'char', c };
  }

  const ast = parseAlternation();
  if (i < pattern.length) throw new Error('unexpected character in pattern');

  // ---------- Matcher (backtracking with continuations) ----------
  function matchesChar(node, ch) {
    switch (node.type) {
      case 'char': return ch === node.c;
      case 'any': return true;
      case 'digit': return ch >= '0' && ch <= '9';
      case 'class': {
        let hit = false;
        for (const [lo, hi] of node.ranges) {
          if (ch >= lo && ch <= hi) { hit = true; break; }
        }
        return node.neg ? !hit : hit;
      }
    }
    return false;
  }

  function m(node, pos, cont) {
    switch (node.type) {
      case 'char':
      case 'any':
      case 'digit':
      case 'class':
        return pos < text.length && matchesChar(node, text[pos]) && cont(pos + 1);
      case 'seq':
        return matchSeq(node.items, 0, pos, cont);
      case 'alt':
        for (const opt of node.options) {
          if (m(opt, pos, cont)) return true;
        }
        return false;
      case 'rep':
        return matchRep(node, 0, pos, cont);
    }
    return false;
  }

  function matchSeq(items, idx, pos, cont) {
    if (idx === items.length) return cont(pos);
    return m(items[idx], pos, p => matchSeq(items, idx + 1, p, cont));
  }

  function matchRep(node, count, pos, cont) {
    // greedy: try one more repetition first (if allowed)
    if (count < node.max) {
      if (m(node.node, pos, p => {
        if (p === pos) return false; // zero-width progress guard (prevents (a*)* loops)
        return matchRep(node, count + 1, p, cont);
      })) return true;
    }
    if (count >= node.min) return cont(pos);
    // allow satisfying min via zero-width matches of the inner node
    if (count < node.min && m(node.node, pos, p => p === pos)) return cont(pos);
    return false;
  }

  return m(ast, 0, p => p === text.length);
}

function match(pattern, text) {
  // ---- パーサ: pattern を AST に変換 ----
  let i = 0;

  function parseAlt() {
    const branches = [parseSeq()];
    while (i < pattern.length && pattern[i] === '|') {
      i++;
      branches.push(parseSeq());
    }
    return { type: 'alt', branches };
  }

  function parseSeq() {
    const items = [];
    while (i < pattern.length && pattern[i] !== '|' && pattern[i] !== ')') {
      let atom;
      const c = pattern[i];
      if (c === '(') {
        i++;
        const inner = parseAlt();
        if (pattern[i] !== ')') throw new Error('unmatched (');
        i++;
        atom = inner;
      } else if (c === '[') {
        i++;
        let neg = false;
        if (pattern[i] === '^') { neg = true; i++; }
        const ranges = [];
        while (i < pattern.length && pattern[i] !== ']') {
          let ch;
          if (pattern[i] === '\\') { i++; ch = pattern[i]; i++; }
          else { ch = pattern[i]; i++; }
          if (pattern[i] === '-' && i + 1 < pattern.length && pattern[i + 1] !== ']') {
            i++;
            let ch2;
            if (pattern[i] === '\\') { i++; ch2 = pattern[i]; i++; }
            else { ch2 = pattern[i]; i++; }
            ranges.push([ch, ch2]);
          } else {
            ranges.push([ch, ch]);
          }
        }
        if (pattern[i] !== ']') throw new Error('unmatched [');
        i++;
        atom = { type: 'class', neg, ranges };
      } else if (c === '\\') {
        i++;
        if (i >= pattern.length) throw new Error('trailing backslash');
        const e = pattern[i];
        i++;
        if (e === 'd') atom = { type: 'class', neg: false, ranges: [['0', '9']] };
        else atom = { type: 'char', ch: e };
      } else if (c === '.') {
        i++;
        atom = { type: 'any' };
      } else if (c === '*' || c === '+' || c === '?') {
        throw new Error('quantifier without target');
      } else {
        i++;
        atom = { type: 'char', ch: c };
      }
      if (i < pattern.length && (pattern[i] === '*' || pattern[i] === '+' || pattern[i] === '?')) {
        atom = { type: 'quant', q: pattern[i], node: atom };
        i++;
      }
      items.push(atom);
    }
    return { type: 'seq', items };
  }

  const ast = parseAlt();
  if (i !== pattern.length) throw new Error('unexpected ) in pattern');

  // ---- マッチャ: 継続渡し (CPS) によるバックトラック ----
  function m(node, pos, k) {
    switch (node.type) {
      case 'char':
        return pos < text.length && text[pos] === node.ch && k(pos + 1);
      case 'any':
        return pos < text.length && k(pos + 1);
      case 'class': {
        if (pos >= text.length) return false;
        const ch = text[pos];
        const inSet = node.ranges.some(([a, b]) => ch >= a && ch <= b);
        return (node.neg ? !inSet : inSet) && k(pos + 1);
      }
      case 'seq': {
        const items = node.items;
        const step = (idx, p) =>
          idx === items.length ? k(p) : m(items[idx], p, (p2) => step(idx + 1, p2));
        return step(0, pos);
      }
      case 'alt':
        return node.branches.some((b) => m(b, pos, k));
      case 'quant': {
        if (node.q === '?') return m(node.node, pos, k) || k(pos);
        if (node.q === '+') return m(node.node, pos, (p2) => star(node.node, p2, k));
        return star(node.node, pos, k);
      }
    }
    return false;
  }

  // 貪欲に繰り返しつつ、進捗ゼロの反復は打ち切って無限ループを防ぐ
  function star(inner, pos, k) {
    return m(inner, pos, (p2) => p2 > pos && star(inner, p2, k)) || k(pos);
  }

  return m(ast, 0, (p) => p === text.length) === true;
}

function match(pattern, text) {
  // ---------- Parser ----------
  let i = 0;

  function parseAlt() {
    const options = [parseSeq()];
    while (i < pattern.length && pattern[i] === '|') {
      i++;
      options.push(parseSeq());
    }
    return options.length === 1 ? options[0] : { type: 'alt', options };
  }

  function parseSeq() {
    const items = [];
    while (i < pattern.length && pattern[i] !== '|' && pattern[i] !== ')') {
      items.push(parseItem());
    }
    return { type: 'seq', items };
  }

  function parseItem() {
    let atom = parseAtom();
    while (i < pattern.length) {
      const c = pattern[i];
      if (c === '*') {
        i++;
        atom = { type: 'star', child: atom };
      } else if (c === '+') {
        i++;
        atom = { type: 'plus', child: atom };
      } else if (c === '?') {
        i++;
        atom = { type: 'opt', child: atom };
      } else {
        break;
      }
    }
    return atom;
  }

  function parseAtom() {
    const c = pattern[i];
    if (c === '(') {
      i++;
      const inner = parseAlt();
      if (pattern[i] === ')') i++;
      return inner;
    }
    if (c === '[') {
      i++;
      return parseClass();
    }
    if (c === '\\') {
      i++;
      const e = pattern[i];
      i++;
      if (e === 'd') {
        return { type: 'class', negate: false, items: [{ lo: '0', hi: '9' }] };
      }
      return { type: 'char', ch: e };
    }
    if (c === '.') {
      i++;
      return { type: 'dot' };
    }
    i++;
    return { type: 'char', ch: c };
  }

  function parseClass() {
    let negate = false;
    if (pattern[i] === '^') {
      negate = true;
      i++;
    }
    const items = [];
    while (i < pattern.length && pattern[i] !== ']') {
      let ch = pattern[i];
      if (ch === '\\') {
        i++;
        ch = pattern[i];
        i++;
        items.push({ ch });
        continue;
      }
      i++;
      if (pattern[i] === '-' && i + 1 < pattern.length && pattern[i + 1] !== ']') {
        i++;
        let hi = pattern[i];
        if (hi === '\\') {
          i++;
          hi = pattern[i];
        }
        i++;
        items.push({ lo: ch, hi });
      } else {
        items.push({ ch });
      }
    }
    if (pattern[i] === ']') i++;
    return { type: 'class', negate, items };
  }

  const ast = parseAlt();

  // ---------- Matcher (continuation-passing with backtracking) ----------
  function inClass(node, ch) {
    let found = false;
    for (const it of node.items) {
      if (it.lo !== undefined) {
        if (ch >= it.lo && ch <= it.hi) {
          found = true;
          break;
        }
      } else if (ch === it.ch) {
        found = true;
        break;
      }
    }
    return node.negate ? !found : found;
  }

  function m(node, pos, k) {
    switch (node.type) {
      case 'char':
        return pos < text.length && text[pos] === node.ch && k(pos + 1);
      case 'dot':
        return pos < text.length && k(pos + 1);
      case 'class':
        return pos < text.length && inClass(node, text[pos]) && k(pos + 1);
      case 'seq': {
        const items = node.items;
        const step = (idx, p) =>
          idx === items.length ? k(p) : m(items[idx], p, (p2) => step(idx + 1, p2));
        return step(0, pos);
      }
      case 'alt': {
        for (const opt of node.options) {
          if (m(opt, pos, k)) return true;
        }
        return false;
      }
      case 'star': {
        const rep = (p) => {
          if (k(p)) return true;
          // require strict progress to avoid infinite loops on zero-width matches
          return m(node.child, p, (p2) => p2 > p && rep(p2));
        };
        return rep(pos);
      }
      case 'plus': {
        const rep = (p) => {
          if (k(p)) return true;
          return m(node.child, p, (p2) => p2 > p && rep(p2));
        };
        return m(node.child, pos, (p) => rep(p));
      }
      case 'opt': {
        if (m(node.child, pos, k)) return true;
        return k(pos);
      }
    }
    return false;
  }

  return m(ast, 0, (p) => p === text.length);
}

function match(pattern, text) {
  // ---- パーサ ----
  let i = 0;
  let parseError = false;

  function parseAlt() {
    const opts = [parseConcat()];
    while (i < pattern.length && pattern[i] === '|') {
      i++;
      opts.push(parseConcat());
    }
    return opts.length === 1 ? opts[0] : { type: 'alt', opts };
  }

  function parseConcat() {
    const parts = [];
    while (i < pattern.length && pattern[i] !== '|' && pattern[i] !== ')') {
      parts.push(parseQuant());
    }
    return { type: 'concat', parts };
  }

  function parseQuant() {
    let atom = parseAtom();
    while (i < pattern.length && (pattern[i] === '*' || pattern[i] === '+' || pattern[i] === '?')) {
      const q = pattern[i++];
      atom = { type: q === '*' ? 'star' : q === '+' ? 'plus' : 'opt', node: atom };
    }
    return atom;
  }

  function parseAtom() {
    const c = pattern[i];
    if (c === '(') {
      i++;
      const node = parseAlt();
      if (pattern[i] === ')') i++;
      else parseError = true;
      return node;
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      i++;
      const e = pattern[i++];
      if (e === undefined) {
        parseError = true;
        return { type: 'char', ch: '\\' };
      }
      if (e === 'd') return { type: 'class', neg: false, items: [{ from: '0', to: '9' }] };
      return { type: 'char', ch: e };
    }
    if (c === '.') {
      i++;
      return { type: 'any' };
    }
    i++;
    return { type: 'char', ch: c };
  }

  function parseClass() {
    i++; // '[' を消費
    let neg = false;
    if (pattern[i] === '^') {
      neg = true;
      i++;
    }
    const items = [];
    while (i < pattern.length && pattern[i] !== ']') {
      let ch = pattern[i];
      if (ch === '\\' && i + 1 < pattern.length) {
        i++;
        const e = pattern[i++];
        if (e === 'd') {
          items.push({ from: '0', to: '9' });
          continue;
        }
        ch = e;
      } else {
        i++;
      }
      if (pattern[i] === '-' && i + 1 < pattern.length && pattern[i + 1] !== ']') {
        i++; // '-'
        let hi = pattern[i];
        if (hi === '\\' && i + 1 < pattern.length) {
          i++;
          hi = pattern[i];
        }
        i++;
        items.push({ from: ch, to: hi });
      } else {
        items.push({ ch: ch });
      }
    }
    if (pattern[i] === ']') i++;
    else parseError = true;
    return { type: 'class', neg, items };
  }

  const ast = parseAlt();
  if (parseError || i < pattern.length) return false; // 不正な pattern（対応しない ')' など）

  // ---- バックトラック付きマッチャ（継続渡し）----
  function m(node, pos, k) {
    switch (node.type) {
      case 'char':
        return pos < text.length && text[pos] === node.ch && k(pos + 1);
      case 'any':
        return pos < text.length && k(pos + 1);
      case 'class': {
        if (pos >= text.length) return false;
        const c = text[pos];
        let hit = false;
        for (let j = 0; j < node.items.length; j++) {
          const it = node.items[j];
          if (it.ch !== undefined ? c === it.ch : (c >= it.from && c <= it.to)) {
            hit = true;
            break;
          }
        }
        return (hit !== node.neg) && k(pos + 1);
      }
      case 'concat': {
        const step = (idx, p) => {
          if (idx === node.parts.length) return k(p);
          return m(node.parts[idx], p, (np) => step(idx + 1, np));
        };
        return step(0, pos);
      }
      case 'alt': {
        for (let j = 0; j < node.opts.length; j++) {
          if (m(node.opts[j], pos, k)) return true;
        }
        return false;
      }
      case 'opt':
        return m(node.node, pos, k) || k(pos);
      case 'star': {
        // 前進した場合のみ繰り返す（ゼロ幅マッチの無限ループ防止）
        const rep = (p) => m(node.node, p, (np) => np > p && rep(np)) || k(p);
        return rep(pos);
      }
      case 'plus': {
        const rep = (p) => m(node.node, p, (np) => np > p && rep(np)) || k(p);
        return m(node.node, pos, (np) => rep(np));
      }
    }
    return false;
  }

  return m(ast, 0, (p) => p === text.length);
}

function match(pattern, text) {
  const n = pattern.length;
  let pos = 0;
  let depth = 0;

  function parseAlternation() {
    const branches = [parseConcat()];
    while (pos < n && pattern[pos] === '|') {
      pos++;
      branches.push(parseConcat());
    }
    return branches.length === 1 ? branches[0] : { type: 'alt', branches };
  }

  function parseConcat() {
    const items = [];
    while (pos < n && pattern[pos] !== '|' && !(depth > 0 && pattern[pos] === ')')) {
      items.push(parseRepeat());
    }
    return { type: 'concat', items };
  }

  function parseRepeat() {
    let node = parseAtom();
    while (pos < n && (pattern[pos] === '*' || pattern[pos] === '+' || pattern[pos] === '?')) {
      const q = pattern[pos++];
      node = { type: q === '*' ? 'star' : q === '+' ? 'plus' : 'opt', child: node };
    }
    return node;
  }

  function parseAtom() {
    const c = pattern[pos];
    if (c === '(') {
      pos++;
      depth++;
      const node = parseAlternation();
      depth--;
      if (pos < n && pattern[pos] === ')') pos++;
      return node;
    }
    if (c === '[') {
      pos++;
      return parseClass();
    }
    if (c === '\\') {
      pos++;
      const e = pos < n ? pattern[pos++] : '\\';
      if (e === 'd') return { type: 'pred', test: ch => ch >= '0' && ch <= '9' };
      return { type: 'pred', test: ch => ch === e };
    }
    if (c === '.') {
      pos++;
      return { type: 'pred', test: () => true };
    }
    pos++;
    return { type: 'pred', test: ch => ch === c };
  }

  function parseClass() {
    let neg = false;
    if (pos < n && pattern[pos] === '^') { neg = true; pos++; }
    const singles = new Set();
    const ranges = [];
    while (pos < n && pattern[pos] !== ']') {
      let c = pattern[pos++];
      if (c === '\\' && pos < n) {
        const e = pattern[pos++];
        if (e === 'd') { ranges.push(['0', '9']); continue; }
        c = e;
      }
      if (pos < n && pattern[pos] === '-' && pos + 1 < n && pattern[pos + 1] !== ']') {
        pos++;
        let hi = pattern[pos++];
        if (hi === '\\' && pos < n) hi = pattern[pos++];
        ranges.push([c, hi]);
      } else {
        singles.add(c);
      }
    }
    if (pos < n) pos++;
    const test = ch => {
      let m = singles.has(ch);
      if (!m) {
        for (const r of ranges) {
          if (ch >= r[0] && ch <= r[1]) { m = true; break; }
        }
      }
      return neg ? !m : m;
    };
    return { type: 'pred', test };
  }

  const ast = parseAlternation();

  const states = [];
  function newState() {
    states.push({ eps: [], trans: [] });
    return states.length - 1;
  }

  function build(node, from) {
    if (node.type === 'concat') {
      let cur = from;
      for (const it of node.items) cur = build(it, cur);
      return cur;
    }
    if (node.type === 'alt') {
      const end = newState();
      for (const b of node.branches) {
        const s = newState();
        states[from].eps.push(s);
        const e = build(b, s);
        states[e].eps.push(end);
      }
      return end;
    }
    if (node.type === 'star') {
      const s = newState();
      const end = newState();
      states[from].eps.push(s, end);
      const e = build(node.child, s);
      states[e].eps.push(s, end);
      return end;
    }
    if (node.type === 'plus') {
      const s = newState();
      states[from].eps.push(s);
      const e = build(node.child, s);
      const end = newState();
      states[e].eps.push(s, end);
      return end;
    }
    if (node.type === 'opt') {
      const e = build(node.child, from);
      const end = newState();
      states[from].eps.push(end);
      states[e].eps.push(end);
      return end;
    }
    const to = newState();
    states[from].trans.push({ test: node.test, to });
    return to;
  }

  const start = newState();
  const accept = build(ast, start);

  function closure(set) {
    const stack = Array.from(set);
    while (stack.length) {
      const s = stack.pop();
      for (const t of states[s].eps) {
        if (!set.has(t)) { set.add(t); stack.push(t); }
      }
    }
    return set;
  }

  let cur = closure(new Set([start]));
  for (let i = 0; i < text.length; i++) {
    const ch = text[i];
    const next = new Set();
    for (const s of cur) {
      for (const t of states[s].trans) {
        if (t.test(ch)) next.add(t.to);
      }
    }
    if (next.size === 0) return false;
    cur = closure(next);
  }
  return cur.has(accept);
}

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

Q1. 1
Q2. 白
Q3. インド人

この案件は一度で決めたいので深めに設定。
うまく回すには二つの基準を決めればいい。
りんかくを三分で描けば後の手順は固まる。
つまずく所は四回まで試して方針を変える。
のばす時間は五分を上限に決めて先に進む。
かける手間を六割に減らしても案外回せる。
ぎりぎりの所は七割の力を注いで臨みたい。

こまかい作業は一段軽い設定で素早く回す。
うまく二つの水準を用途に応じ切り替える。
りくつは三つあり、速さと費用と正確さだ。
つねに四つの観点から重さを決めておこう。
のんびり五分で終わる用件に深い力は不要。
かならず六割は浅い設定で足りると見よう。
ぎりぎりの判断と七転びの場では深くする。

この一手で判断の深さを決める癖をつける。
うまく二段構えで浅い試しから先に始める。
りゆうが三つ以上なら深い検討へと回そう。
つまり四半期の重い案件こそ時間をかける。
のんびり五分で済む雑務は浅い設定でいい。
かならず六割は軽い設定で回し結果を見る。
ぎりぎりまで七分の力で走らせるのが得だ。

こまかい作業は一段軽い設定で速く回そう。
うたがわしい案件は二重に検証して進める。
りかいが浅い所は三度ほど深く掘り下げる。
つねに四半期の目標と照らし深さを決める。
のこり時間が五分なら浅く素早くまとめる。
かんじんな判断は六割の力を検証に向ける。
ぎろんの末に七割の力で仕上げるのが良い。

こまかい検討は一度だけにとどめておこう。
うまく回すには二つの基準を先に用意する。
りょうが多い作業は三つに分けて任せたい。
つよい負荷は四半期ごとの見直しに向ける。
のべ五分で終わる用件に深追いは要らない。
かける時間を六倍にしても成果は伸びない。
ぎろんの七割は軽い設定のままで片がつく。

function match(pattern, text) {
  let pos = 0;

  function peek() { return pos < pattern.length ? pattern[pos] : null; }

  function parseAlt() {
    const branches = [parseConcat()];
    while (peek() === '|') { pos++; branches.push(parseConcat()); }
    return branches.length === 1 ? branches[0] : { type: 'alt', branches: branches };
  }

  function parseConcat() {
    const items = [];
    while (pos < pattern.length && peek() !== '|' && peek() !== ')') {
      items.push(parseQuant());
    }
    return { type: 'cat', items: items };
  }

  function parseQuant() {
    let atom = parseAtom();
    for (;;) {
      const c = peek();
      if (c === '*') { pos++; atom = { type: 'rep', min: 0, max: Infinity, node: atom }; }
      else if (c === '+') { pos++; atom = { type: 'rep', min: 1, max: Infinity, node: atom }; }
      else if (c === '?') { pos++; atom = { type: 'rep', min: 0, max: 1, node: atom }; }
      else break;
    }
    return atom;
  }

  function parseAtom() {
    const c = peek();
    if (c === '(') {
      pos++;
      const inner = parseAlt();
      if (peek() === ')') pos++;
      return inner;
    }
    if (c === '[') { pos++; return parseClass(); }
    if (c === '\\') {
      pos++;
      const e = pos < pattern.length ? pattern[pos++] : '\\';
      if (e === 'd') return { type: 'digit' };
      return { type: 'char', ch: e };
    }
    if (c === '.') { pos++; return { type: 'any' }; }
    pos++;
    return { type: 'char', ch: c === null ? '' : c };
  }

  function parseClass() {
    let neg = false;
    if (peek() === '^') { neg = true; pos++; }
    const items = [];
    let first = true;
    while (pos < pattern.length && (pattern[pos] !== ']' || first)) {
      first = false;
      let ch;
      if (pattern[pos] === '\\') {
        pos++;
        const e = pos < pattern.length ? pattern[pos++] : '\\';
        if (e === 'd') { items.push({ kind: 'digit' }); continue; }
        ch = e;
      } else {
        ch = pattern[pos++];
      }
      if (peek() === '-' && pos + 1 < pattern.length && pattern[pos + 1] !== ']') {
        pos++;
        let hi;
        if (pattern[pos] === '\\') { pos++; hi = pos < pattern.length ? pattern[pos++] : '\\'; }
        else hi = pattern[pos++];
        items.push({ kind: 'range', lo: ch, hi: hi });
      } else {
        items.push({ kind: 'char', ch: ch });
      }
    }
    if (peek() === ']') pos++;
    return { type: 'class', neg: neg, items: items };
  }

  const ast = parseAlt();

  const visiting = new Set();

  function m(node, i, cont) {
    switch (node.type) {
      case 'char':
        return i < text.length && text[i] === node.ch ? cont(i + 1) : false;
      case 'any':
        return i < text.length ? cont(i + 1) : false;
      case 'digit':
        return i < text.length && text[i] >= '0' && text[i] <= '9' ? cont(i + 1) : false;
      case 'class': {
        if (i >= text.length) return false;
        const ch = text[i];
        let hit = false;
        for (let k = 0; k < node.items.length; k++) {
          const it = node.items[k];
          if (it.kind === 'char') { if (ch === it.ch) { hit = true; break; } }
          else if (it.kind === 'range') { if (ch >= it.lo && ch <= it.hi) { hit = true; break; } }
          else if (it.kind === 'digit') { if (ch >= '0' && ch <= '9') { hit = true; break; } }
        }
        if (node.neg) hit = !hit;
        return hit ? cont(i + 1) : false;
      }
      case 'alt': {
        for (let k = 0; k < node.branches.length; k++) {
          if (m(node.branches[k], i, cont)) return true;
        }
        return false;
      }
      case 'cat': {
        const items = node.items;
        function step(idx, j) {
          if (idx === items.length) return cont(j);
          return m(items[idx], j, function (nj) { return step(idx + 1, nj); });
        }
        return step(0, i);
      }
      case 'rep': {
        const min = node.min, max = node.max;
        function rep(count, j) {
          if (count >= min && (max === Infinity || count <= max)) {
            if (count > 0 || min === 0) {
              // greedy: try more first, then cont
            }
          }
          let tryMore = false;
          if (count < max) {
            const key = node.id + '|' + j;
            if (!visiting.has(key)) {
              visiting.add(key);
              tryMore = m(node.node, j, function (nj) {
                if (nj === j && count >= min) return false;
                return rep(count + 1, nj);
              });
              visiting.delete(key);
            }
          }
          if (tryMore) return true;
          if (count >= min) return cont(j);
          return false;
        }
        return rep(0, i);
      }
    }
    return false;
  }

  let idc = 0;
  (function assign(n) {
    if (!n || typeof n !== 'object') return;
    if (n.type === 'rep') { n.id = idc++; assign(n.node); }
    else if (n.type === 'alt') { for (const b of n.branches) assign(b); }
    else if (n.type === 'cat') { for (const it of n.items) assign(it); }
  })(ast);

  return m(ast, 0, function (i) { return i === text.length; });
}

function match(pattern, text) {
  var pi = 0;

  function peek() { return pi < pattern.length ? pattern[pi] : null; }

  function parseAlt() {
    var opts = [parseConcat()];
    while (peek() === '|') { pi++; opts.push(parseConcat()); }
    return opts.length === 1 ? opts[0] : { t: 'alt', opts: opts };
  }

  function parseConcat() {
    var parts = [];
    while (pi < pattern.length && peek() !== '|' && peek() !== ')') {
      parts.push(parseRep());
    }
    return { t: 'cat', parts: parts };
  }

  function parseRep() {
    var node = parseAtom();
    for (;;) {
      var c = peek();
      if (c === '*') { pi++; node = { t: 'rep', node: node, min: 0, max: Infinity }; }
      else if (c === '+') { pi++; node = { t: 'rep', node: node, min: 1, max: Infinity }; }
      else if (c === '?') { pi++; node = { t: 'rep', node: node, min: 0, max: 1 }; }
      else break;
    }
    return node;
  }

  function parseAtom() {
    var c = peek();
    if (c === '(') {
      pi++;
      var inner = parseAlt();
      if (peek() === ')') pi++;
      return inner;
    }
    if (c === '[') { pi++; return parseClass(); }
    if (c === '\\') {
      pi++;
      var e = pi < pattern.length ? pattern[pi++] : '\\';
      if (e === 'd') return { t: 'digit' };
      return { t: 'char', c: e };
    }
    if (c === '.') { pi++; return { t: 'any' }; }
    pi++;
    return { t: 'char', c: c };
  }

  function parseClass() {
    var neg = false;
    if (peek() === '^') { neg = true; pi++; }
    var items = [];
    var first = true;
    while (pi < pattern.length && (pattern[pi] !== ']' || first)) {
      var ch = pattern[pi++];
      if (ch === '\\' && pi < pattern.length) {
        var e = pattern[pi++];
        if (e === 'd') { items.push({ k: 'digit' }); first = false; continue; }
        ch = e;
      }
      if (pattern[pi] === '-' && pi + 1 < pattern.length && pattern[pi + 1] !== ']') {
        pi++;
        var hi = pattern[pi++];
        if (hi === '\\' && pi < pattern.length) hi = pattern[pi++];
        items.push({ k: 'range', lo: ch, hi: hi });
      } else {
        items.push({ k: 'char', c: ch });
      }
      first = false;
    }
    if (peek() === ']') pi++;
    return { t: 'class', neg: neg, items: items };
  }

  function classMatch(node, ch) {
    var hit = false;
    for (var i = 0; i < node.items.length; i++) {
      var it = node.items[i];
      if (it.k === 'char') { if (ch === it.c) { hit = true; break; } }
      else if (it.k === 'digit') { if (ch >= '0' && ch <= '9') { hit = true; break; } }
      else { if (ch >= it.lo && ch <= it.hi) { hit = true; break; } }
    }
    return node.neg ? !hit : hit;
  }

  function m(node, pos, k) {
    switch (node.t) {
      case 'char':
        return pos < text.length && text[pos] === node.c ? k(pos + 1) : false;
      case 'any':
        return pos < text.length ? k(pos + 1) : false;
      case 'digit':
        return pos < text.length && text[pos] >= '0' && text[pos] <= '9' ? k(pos + 1) : false;
      case 'class':
        return pos < text.length && classMatch(node, text[pos]) ? k(pos + 1) : false;
      case 'cat':
        return mSeq(node.parts, 0, pos, k);
      case 'alt':
        for (var i = 0; i < node.opts.length; i++) {
          if (m(node.opts[i], pos, k)) return true;
        }
        return false;
      case 'rep':
        return mRep(node, pos, k, 0);
    }
    return false;
  }

  function mSeq(parts, idx, pos, k) {
    if (idx >= parts.length) return k(pos);
    return m(parts[idx], pos, function (p) { return mSeq(parts, idx + 1, p, k); });
  }

  function mRep(node, pos, k, count) {
    if (count < node.max) {
      var expanded = m(node.node, pos, function (p) {
        if (p === pos) return count + 1 >= node.min ? k(p) : false;
        return mRep(node, p, k, count + 1);
      });
      if (expanded) return true;
    }
    if (count >= node.min) return k(pos);
    return false;
  }

  var ast = parseAlt();
  return m(ast, 0, function (p) { return p === text.length; });
}

function match(pattern, text) {
  pattern = String(pattern);
  text = String(text);
  let i = 0;

  function parseAlt() {
    const opts = [parseSeq()];
    while (i < pattern.length && pattern[i] === '|') {
      i++;
      opts.push(parseSeq());
    }
    return opts.length === 1 ? opts[0] : { t: 'alt', opts: opts };
  }

  function parseSeq() {
    const items = [];
    while (i < pattern.length && pattern[i] !== '|' && pattern[i] !== ')') {
      items.push(parseRep());
    }
    return { t: 'seq', items: items };
  }

  function parseRep() {
    let node = parseAtom();
    while (i < pattern.length) {
      const c = pattern[i];
      if (c === '*') {
        i++;
        node = { t: 'star', node: node };
      } else if (c === '+') {
        i++;
        node = { t: 'seq', items: [node, { t: 'star', node: node }] };
      } else if (c === '?') {
        i++;
        node = { t: 'alt', opts: [node, { t: 'seq', items: [] }] };
      } else {
        break;
      }
    }
    return node;
  }

  function parseAtom() {
    const c = pattern[i];
    if (c === '(') {
      i++;
      const n = parseAlt();
      if (pattern[i] === ')') i++;
      return n;
    }
    if (c === '[') {
      i++;
      return parseClass();
    }
    if (c === '\\') {
      i++;
      if (i >= pattern.length) return { t: 'char', c: '\\' };
      const e = pattern[i++];
      if (e === 'd') return { t: 'class', neg: false, items: [{ k: 'd' }] };
      return { t: 'char', c: e };
    }
    if (c === '.') {
      i++;
      return { t: 'any' };
    }
    i++;
    return { t: 'char', c: c };
  }

  function parseClass() {
    let neg = false;
    if (pattern[i] === '^') {
      neg = true;
      i++;
    }
    const items = [];
    let first = true;
    while (i < pattern.length && (pattern[i] !== ']' || first)) {
      first = false;
      let lo;
      if (pattern[i] === '\\') {
        i++;
        if (i >= pattern.length) {
          items.push({ k: 'c', c: '\\' });
          break;
        }
        const e = pattern[i++];
        if (e === 'd') {
          items.push({ k: 'd' });
          continue;
        }
        lo = e;
      } else {
        lo = pattern[i++];
      }
      if (pattern[i] === '-' && i + 1 < pattern.length && pattern[i + 1] !== ']') {
        i++;
        let hi;
        if (pattern[i] === '\\') {
          i++;
          hi = i < pattern.length ? pattern[i++] : '\\';
        } else {
          hi = pattern[i++];
        }
        items.push({ k: 'r', a: lo, b: hi });
      } else {
        items.push({ k: 'c', c: lo });
      }
    }
    if (pattern[i] === ']') i++;
    return { t: 'class', neg: neg, items: items };
  }

  function classMatch(node, ch) {
    let hit = false;
    for (let j = 0; j < node.items.length; j++) {
      const it = node.items[j];
      if (it.k === 'c') {
        if (ch === it.c) { hit = true; break; }
      } else if (it.k === 'r') {
        if (ch >= it.a && ch <= it.b) { hit = true; break; }
      } else if (it.k === 'd') {
        if (ch >= '0' && ch <= '9') { hit = true; break; }
      }
    }
    return node.neg ? !hit : hit;
  }

  function m(node, pos, k) {
    if (node.t === 'seq') {
      const items = node.items;
      const step = function (idx, p) {
        if (idx === items.length) return k(p);
        return m(items[idx], p, function (p2) { return step(idx + 1, p2); });
      };
      return step(0, pos);
    }
    if (node.t === 'alt') {
      for (let j = 0; j < node.opts.length; j++) {
        if (m(node.opts[j], pos, k)) return true;
      }
      return false;
    }
    if (node.t === 'star') {
      const go = function (p) {
        if (m(node.node, p, function (p2) { return p2 > p ? go(p2) : false; })) return true;
        return k(p);
      };
      return go(pos);
    }
    if (node.t === 'char') {
      return pos < text.length && text[pos] === node.c && k(pos + 1);
    }
    if (node.t === 'any') {
      return pos < text.length && k(pos + 1);
    }
    if (node.t === 'class') {
      return pos < text.length && classMatch(node, text[pos]) && k(pos + 1);
    }
    return false;
  }

  const ast = parseAlt();
  return m(ast, 0, function (p) { return p === text.length; });
}

function match(pattern, text) {
  var P = Array.from(String(pattern));
  var T = Array.from(String(text));
  var pos = 0;

  function peek() {
    return pos < P.length ? P[pos] : null;
  }
  function next() {
    return P[pos++];
  }

  function parseAlt() {
    var branches = [parseSeq()];
    while (peek() === '|') {
      pos++;
      branches.push(parseSeq());
    }
    return branches.length === 1 ? branches[0] : { t: 'alt', b: branches };
  }

  function parseSeq() {
    var items = [];
    while (pos < P.length && peek() !== '|' && peek() !== ')') {
      items.push(parseRep());
    }
    return { t: 'seq', items: items };
  }

  function parseRep() {
    var a = parseAtom();
    for (;;) {
      var c = peek();
      if (c === '*') {
        pos++;
        a = { t: 'rep', min: 0, max: Infinity, node: a };
      } else if (c === '+') {
        pos++;
        a = { t: 'rep', min: 1, max: Infinity, node: a };
      } else if (c === '?') {
        pos++;
        a = { t: 'rep', min: 0, max: 1, node: a };
      } else {
        break;
      }
    }
    return a;
  }

  function parseAtom() {
    var c = next();
    if (c === '(') {
      var inner = parseAlt();
      if (peek() === ')') pos++;
      return { t: 'group', node: inner };
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      if (pos >= P.length) return { t: 'lit', c: '\\' };
      var e = next();
      if (e === 'd') return { t: 'digit' };
      return { t: 'lit', c: e };
    }
    if (c === '.') return { t: 'any' };
    return { t: 'lit', c: c };
  }

  function parseClass() {
    var neg = false;
    if (peek() === '^') {
      pos++;
      neg = true;
    }
    var items = [];
    var first = true;
    while (pos < P.length && (P[pos] !== ']' || first)) {
      first = false;
      var c = next();
      if (c === '\\' && pos < P.length) {
        var e = next();
        if (e === 'd') {
          items.push({ k: 'digit' });
          continue;
        }
        c = e;
      }
      if (peek() === '-' && pos + 1 < P.length && P[pos + 1] !== ']') {
        pos++;
        var hi = next();
        if (hi === '\\' && pos < P.length) hi = next();
        items.push({ k: 'range', lo: c, hi: hi });
      } else {
        items.push({ k: 'char', c: c });
      }
    }
    if (peek() === ']') pos++;
    return { t: 'cls', neg: neg, items: items };
  }

  function isDigit(ch) {
    return ch.length === 1 && ch >= '0' && ch <= '9';
  }

  function inClass(node, ch) {
    var hit = false;
    for (var i = 0; i < node.items.length; i++) {
      var it = node.items[i];
      if (it.k === 'char') {
        if (ch === it.c) {
          hit = true;
          break;
        }
      } else if (it.k === 'digit') {
        if (isDigit(ch)) {
          hit = true;
          break;
        }
      } else {
        var cp = ch.codePointAt(0);
        if (cp >= it.lo.codePointAt(0) && cp <= it.hi.codePointAt(0)) {
          hit = true;
          break;
        }
      }
    }
    return node.neg ? !hit : hit;
  }

  function m(node, i, k) {
    switch (node.t) {
      case 'lit':
        return i < T.length && T[i] === node.c ? k(i + 1) : false;
      case 'any':
        return i < T.length ? k(i + 1) : false;
      case 'digit':
        return i < T.length && isDigit(T[i]) ? k(i + 1) : false;
      case 'cls':
        return i < T.length && inClass(node, T[i]) ? k(i + 1) : false;
      case 'group':
        return m(node.node, i, k);
      case 'seq':
        return mSeq(node.items, 0, i, k);
      case 'alt':
        for (var x = 0; x < node.b.length; x++) {
          if (m(node.b[x], i, k)) return true;
        }
        return false;
      case 'rep':
        return mRep(node, i, 0, k, new Set());
    }
    return false;
  }

  function mSeq(items, idx, i, k) {
    if (idx === items.length) return k(i);
    return m(items[idx], i, function (j) {
      return mSeq(items, idx + 1, j, k);
    });
  }

  function mRep(node, i, count, k, seen) {
    var dedupe = node.max === Infinity && count >= node.min;
    if (dedupe) {
      if (seen.has(i)) return false;
      seen.add(i);
    }
    if (count < node.max) {
      var advanced = m(node.node, i, function (j) {
        if (j === i) return count + 1 >= node.min ? k(j) : false;
        return mRep(node, j, count + 1, k, seen);
      });
      if (advanced) return true;
    }
    if (count >= node.min) return k(i);
    return false;
  }

  var ast = parseAlt();
  return m(ast, 0, function (j) {
    return j === T.length;
  });
}

function match(pattern, text) {
  const src = String(pattern);
  const str = String(text);
  let pos = 0;

  function parseAlternation() {
    const branches = [parseSequence()];
    while (pos < src.length && src[pos] === '|') {
      pos++;
      branches.push(parseSequence());
    }
    return branches.length === 1 ? branches[0] : { type: 'alt', branches: branches };
  }

  function parseSequence() {
    const parts = [];
    while (pos < src.length && src[pos] !== '|' && src[pos] !== ')') {
      parts.push(parseQuantified());
    }
    if (parts.length === 0) return { type: 'empty' };
    if (parts.length === 1) return parts[0];
    return { type: 'seq', parts: parts };
  }

  function parseQuantified() {
    let node = parseAtom();
    while (pos < src.length) {
      const q = src[pos];
      if (q === '*') { node = { type: 'star', body: node }; pos++; }
      else if (q === '+') { node = { type: 'plus', body: node }; pos++; }
      else if (q === '?') { node = { type: 'opt', body: node }; pos++; }
      else break;
    }
    return node;
  }

  function parseAtom() {
    const c = src[pos];
    if (c === '(') {
      pos++;
      const inner = parseAlternation();
      if (src[pos] === ')') pos++;
      return inner;
    }
    if (c === '[') return parseClass();
    if (c === '\\') {
      pos++;
      if (pos >= src.length) return { type: 'lit', ch: '\\' };
      const e = src[pos++];
      if (e === 'd') return { type: 'cls', negate: false, ranges: [[48, 57]] };
      return { type: 'lit', ch: e };
    }
    if (c === '.') { pos++; return { type: 'any' }; }
    pos++;
    return { type: 'lit', ch: c };
  }

  function classChar() {
    if (src[pos] === '\\' && pos + 1 < src.length) {
      pos++;
      return src[pos++];
    }
    return src[pos++];
  }

  function parseClass() {
    pos++;
    let negate = false;
    if (src[pos] === '^') { negate = true; pos++; }
    const ranges = [];
    let first = true;
    while (pos < src.length && (src[pos] !== ']' || first)) {
      first = false;
      if (src[pos] === '\\' && src[pos + 1] === 'd') {
        pos += 2;
        ranges.push([48, 57]);
        continue;
      }
      const lo = classChar();
      if (src[pos] === '-' && pos + 1 < src.length && src[pos + 1] !== ']') {
        pos++;
        const hi = classChar();
        ranges.push([lo.charCodeAt(0), hi.charCodeAt(0)]);
      } else {
        ranges.push([lo.charCodeAt(0), lo.charCodeAt(0)]);
      }
    }
    if (src[pos] === ']') pos++;
    return { type: 'cls', negate: negate, ranges: ranges };
  }

  const states = [];
  function newState(s) {
    states.push(s);
    return states.length - 1;
  }
  function patch(list, target) {
    for (let i = 0; i < list.length; i++) {
      states[list[i][0]][list[i][1]] = target;
    }
  }

  function compile(node) {
    switch (node.type) {
      case 'empty': {
        const s = newState({ kind: 'eps', out: -1 });
        return { start: s, outs: [[s, 'out']] };
      }
      case 'lit': {
        const ch = node.ch;
        const s = newState({ kind: 'test', out: -1, test: function (c) { return c === ch; } });
        return { start: s, outs: [[s, 'out']] };
      }
      case 'any': {
        const s = newState({ kind: 'test', out: -1, test: function () { return true; } });
        return { start: s, outs: [[s, 'out']] };
      }
      case 'cls': {
        const ranges = node.ranges;
        const negate = node.negate;
        const s = newState({
          kind: 'test',
          out: -1,
          test: function (c) {
            const code = c.charCodeAt(0);
            let inside = false;
            for (let i = 0; i < ranges.length; i++) {
              if (code >= ranges[i][0] && code <= ranges[i][1]) { inside = true; break; }
            }
            return negate ? !inside : inside;
          }
        });
        return { start: s, outs: [[s, 'out']] };
      }
      case 'seq': {
        let frag = compile(node.parts[0]);
        for (let i = 1; i < node.parts.length; i++) {
          const nf = compile(node.parts[i]);
          patch(frag.outs, nf.start);
          frag = { start: frag.start, outs: nf.outs };
        }
        return frag;
      }
      case 'alt': {
        const frags = [];
        for (let i = 0; i < node.branches.length; i++) frags.push(compile(node.branches[i]));
        let curStart = frags[frags.length - 1].start;
        let outs = frags[frags.length - 1].outs.slice();
        for (let i = frags.length - 2; i >= 0; i--) {
          const sp = newState({ kind: 'split', out: frags[i].start, out2: curStart });
          outs = frags[i].outs.concat(outs);
          curStart = sp;
        }
        return { start: curStart, outs: outs };
      }
      case 'star': {
        const sp = newState({ kind: 'split', out: -1, out2: -1 });
        const f = compile(node.body);
        states[sp].out = f.start;
        patch(f.outs, sp);
        return { start: sp, outs: [[sp, 'out2']] };
      }
      case 'plus': {
        const f = compile(node.body);
        const sp = newState({ kind: 'split', out: f.start, out2: -1 });
        patch(f.outs, sp);
        return { start: f.start, outs: [[sp, 'out2']] };
      }
      case 'opt': {
        const f = compile(node.body);
        const sp = newState({ kind: 'split', out: f.start, out2: -1 });
        return { start: sp, outs: f.outs.concat([[sp, 'out2']]) };
      }
      default:
        throw new Error('unknown node');
    }
  }

  const ast = parseAlternation();
  const frag = compile(ast);
  const acceptState = newState({ kind: 'match' });
  patch(frag.outs, acceptState);

  const marks = new Array(states.length).fill(-1);
  let gen = 0;

  function addClosure(list, idx) {
    const stack = [idx];
    while (stack.length) {
      const s = stack.pop();
      if (s < 0 || marks[s] === gen) continue;
      marks[s] = gen;
      const st = states[s];
      if (st.kind === 'eps') {
        stack.push(st.out);
      } else if (st.kind === 'split') {
        stack.push(st.out2);
        stack.push(st.out);
      } else {
        list.push(s);
      }
    }
  }

  gen++;
  let current = [];
  addClosure(current, frag.start);

  for (let i = 0; i < str.length; i++) {
    const c = str[i];
    const next = [];
    gen++;
    for (let j = 0; j < current.length; j++) {
      const st = states[current[j]];
      if (st.kind === 'test' && st.test(c)) addClosure(next, st.out);
    }
    current = next;
    if (current.length === 0) return false;
  }

  for (let i = 0; i < current.length; i++) {
    if (states[current[i]].kind === 'match') return true;
  }
  return false;
}