Турнир алгоритмов: муравьи

function решить(вход) {
  const isObj = (o) => !!o && typeof o === 'object' && !Array.isArray(o);
  const fallback = () => ({
    действие: { тип: 'ждать' },
    память: {},
    общая: (вход && isObj(вход.общая)) ? вход.общая : {}
  });
  let r = null;
  try { r = core(); } catch (e) { r = null; }
  return r || fallback();

  function core() {
    if (!isObj(вход)) return null;
    const N = (вход.размер | 0) || 15, T = (вход.всего_ходов | 0) || 150, t = вход.ход | 0;
    const me = вход.я, base = вход.моя_база, eb = вход.чужая_база;
    if (!isObj(me) || !isObj(base) || !isObj(eb)) return null;
    const mem = isObj(вход.память) ? вход.память : {};
    const sh = isObj(вход.общая) ? вход.общая : {};
    const NN = N * N;
    const K = (x, y) => y * N + x;
    const KX = (k) => k % N, KY = (k) => (k - (k % N)) / N;
    const MIR = (k) => NN - 1 - k;
    const inb = (x, y) => x >= 0 && y >= 0 && x < N && y < N;
    if (!inb(me.x | 0, me.y | 0)) return null;
    me.x |= 0; me.y |= 0;
    const man = (x1, y1, x2, y2) => Math.abs(x1 - x2) + Math.abs(y1 - y2);
    const DIRS = [["С", 0, -1], ["Ю", 0, 1], ["З", -1, 0], ["В", 1, 0]];
    const myId = String(me.id);
    let hid = 7; for (let i = 0; i < myId.length; i++) hid = (hid * 31 + myId.charCodeAt(i)) & 0xffff;
    const isMB = (x, y) => x === base.x && y === base.y;
    const isEB = (x, y) => x === eb.x && y === eb.y;
    const baseK = K(base.x, base.y);
    const myHp = me.здоровье | 0;
    const myLoad = me.груз > 0 ? 1 : 0;
    const left = T - t;

    // ---- общая память
    // карта: '?' неизвестно, '.' пол (видели), '#' стена (видели), ',' пол (по симметрии), '=' стена (по симметрии)
    const map = (typeof sh.m === 'string' && sh.m.length === NN) ? sh.m.split('') : new Array(NN).fill('?');
    const seen = (k) => map[k] === '.' || map[k] === '#';
    const wall = (k) => map[k] === '#' || map[k] === '=';
    const pass = (k) => map[k] === '.' || map[k] === ',';
    const food = isObj(sh.f) ? sh.f : {};     // key -> [кол-во, ход]
    const guess = isObj(sh.g) ? sh.g : {};    // key -> [кол-во, ход] по симметрии
    const claims = isObj(sh.c) ? sh.c : {};   // id -> [key, ход]
    const pos = isObj(sh.p) ? sh.p : {};      // id -> [x, y, груз, ход]
    const resv = isObj(sh.r) ? sh.r : {};     // id -> [key, ход]
    let seenE = Array.isArray(sh.e) ? sh.e.filter(e => Array.isArray(e) && e.length >= 3 && (e[2] | 0) >= t - 3 && (e.length < 4 || e[3] > 0)) : [];
    for (const e of seenE) if (e.length < 4) e[3] = 3;   // [x, y, ход, оценка здоровья]
    let noEB = sh.ne ? 1 : 0;
    let gd = (typeof sh.gd === 'number') ? sh.gd : -999;      // последний ход угрозы у базы
    let bs = (typeof sh.bs === 'number') ? sh.bs : -1;        // последний виденный склад
    const validArr = (obj, minLen) => { for (const id in obj) { const v = obj[id]; if (!Array.isArray(v) || v.length < minLen) delete obj[id]; } };
    validArr(food, 2); validArr(guess, 2); validArr(claims, 2); validArr(pos, 4); validArr(resv, 2);
    for (const id in pos) if (pos[id][3] < t - 2) delete pos[id];
    for (const id in claims) if (claims[id][1] < t - 1) delete claims[id];
    for (const id in resv) if (resv[id][1] < t) delete resv[id];
    for (const ks in guess) if (guess[ks][1] < t - 80) delete guess[ks];

    const atEB = isEB(me.x, me.y), atBase = isMB(me.x, me.y);
    const enemies = [], friends = [];
    let hereFood = 0;
    const visible = new Uint8Array(NN);
    for (const c of (Array.isArray(вход.видно) ? вход.видно : [])) {
      if (!isObj(c)) continue;
      const cx = c.x | 0, cy = c.y | 0;
      if (!inb(cx, cy)) continue;
      const k = K(cx, cy);
      visible[k] = 1;
      const isWall = c.что === 'стена';
      map[k] = isWall ? '#' : '.';
      const mk = MIR(k);
      if (!seen(mk)) map[mk] = isWall ? '=' : ',';
      const a = c.еда | 0;
      if (c.что === 'враг') {
        enemies.push({ x: cx, y: cy });
        let best = null, bd = 9;
        for (const e of seenE) {
          const d = man(e[0], e[1], cx, cy);
          if (e[2] === t) { if (d === 0) { best = e; break; } continue; }
          if (d <= 1 && d < bd) { bd = d; best = e; }
        }
        if (best) { best[0] = cx; best[1] = cy; best[2] = t; } else seenE.push([cx, cy, t, 3]);
        if (man(cx, cy, base.x, base.y) <= 2) gd = t;
      } else if (c.что === 'свой' && !(cx === me.x && cy === me.y)) friends.push({ x: cx, y: cy });
      if (cx === me.x && cy === me.y) hereFood = a;
      const eBase = isEB(cx, cy), mBase = isMB(cx, cy);
      if (mBase) { if (bs >= 0 && a < bs) gd = t; bs = a; }
      if (a > 0 && !mBase && !(eBase && noEB)) food[k] = [a, t]; else delete food[k];
      delete guess[k];
      if (a > 0 && !mBase && !eBase) {
        const mx = N - 1 - cx, my = N - 1 - cy;
        if (!seen(mk) && !food[mk] && !isMB(mx, my) && !isEB(mx, my)) guess[mk] = [a, t];
      }
    }
    seenE = seenE.filter(e => e[2] === t || !visible[K(e[0], e[1])]);
    if (seenE.length > 8) seenE = seenE.slice(seenE.length - 8);
    if (mem.te === t - 1 && atEB && me.груз === 0 && hereFood > 0) { noEB = 1; delete food[K(me.x, me.y)]; }

    const claimCount = (k) => { let n = 0; for (const id in claims) if (id !== myId && claims[id][0] === k) n++; return n; };
    const ehpAt = (x, y) => { for (const e of seenE) if (e[2] === t && e[0] === x && e[1] === y) return e[3]; return 3; };

    // ---- ранг
    const ids = Object.keys(pos); if (!ids.includes(myId)) ids.push(myId);
    ids.sort((a, b) => (+a) - (+b) || (a < b ? -1 : 1));
    const rank = Math.max(0, ids.indexOf(myId)) % 4;
    const sx = eb.x > base.x ? 1 : -1, sy = eb.y > base.y ? 1 : -1;
    const prefAng = [0.15, 0.55, 1.0, 1.42][rank];

    // ---- BFS
    const S = K(me.x, me.y);
    function bfs(blocked) {
      const dist = new Int16Array(NN).fill(-1), prev = new Int16Array(NN).fill(-1);
      dist[S] = 0; const q = [S]; let h = 0;
      while (h < q.length) {
        const k = q[h++]; const x = KX(k), y = KY(k);
        for (const d of DIRS) {
          const nx = x + d[1], ny = y + d[2];
          if (!inb(nx, ny)) continue;
          const nk = K(nx, ny);
          if (dist[nk] >= 0 || wall(nk) || (blocked && blocked[nk])) continue;
          dist[nk] = dist[k] + 1; prev[nk] = k; q.push(nk);
        }
      }
      return { dist, prev };
    }
    function firstStep(res, target) {
      if (target == null || target === S || res.dist[target] <= 0) return null;
      let k = target, guard = 0;
      while (res.prev[k] !== S) { k = res.prev[k]; if (k < 0 || ++guard > NN) return null; }
      const x = KX(k), y = KY(k);
      for (const d of DIRS) if (me.x + d[1] === x && me.y + d[2] === y) return d[0];
      return null;
    }
    const isFriendAt = (x, y) => friends.some(f => f.x === x && f.y === y);
    const isEnemyAt = (x, y) => enemies.some(e => e.x === x && e.y === y);
    const isReserved = (k) => { for (const id in resv) if (id !== myId && resv[id][0] === k && resv[id][1] === t) return true; return false; };
    const enemyAdj = (x, y) => enemies.some(e => man(e.x, e.y, x, y) <= 1);
    const enemyNearRecent = (x, y, r) => seenE.some(e => e[2] >= t - 2 && man(e[0], e[1], x, y) <= r);

    function anyStep(mode) {
      let bestDir = null, bestSc = Infinity;
      for (let i = 0; i < 4; i++) {
        const d = DIRS[(i + hid + t) % 4];
        const nx = me.x + d[1], ny = me.y + d[2];
        if (!inb(nx, ny)) continue;
        const nk = K(nx, ny);
        if (wall(nk) || isFriendAt(nx, ny) || isEnemyAt(nx, ny) || isReserved(nk)) continue;
        let sc;
        if (mode === 'home') sc = man(nx, ny, base.x, base.y) + (enemyAdj(nx, ny) ? 3 : 0);
        else if (mode === 'flee') {
          sc = 0;
          for (const e of enemies) sc -= man(e.x, e.y, nx, ny) * 2;
          for (const e of seenE) if (e[2] >= t - 2) sc -= man(e[0], e[1], nx, ny) * 0.5;
          sc += man(nx, ny, base.x, base.y) * 0.3;
          if (enemyAdj(nx, ny)) sc += 4;
        }
        else sc = ((nk * 7 + hid + t) % 4) + (seen(nk) ? 0 : -1);
        if (sc < bestSc) { bestSc = sc; bestDir = d[0]; }
      }
      return bestDir;
    }

    const stuck = (Array.isArray(mem.p) && mem.p[0] === me.x && mem.p[1] === me.y && mem.sc != null) ? (mem.sk | 0) + 1 : 0;
    const free = bfs(null);
    const homeDist = free.dist[baseK];
    const adjEnemy = enemies.filter(e => man(e.x, e.y, me.x, me.y) === 1);
    const threat = gd >= t - 25;
    const nearHome = man(me.x, me.y, base.x, base.y) <= 2;

    let action = null, target = null;
    mem.te = null;

    // 1. сдать груз
    if (me.груз > 0 && atBase) action = { тип: 'положить' };

    // 2. бой
    if (!action && adjEnemy.length) {
      const support = friends.filter(f => man(f.x, f.y, me.x, me.y) <= 2).length;
      const hps = adjEnemy.map(e => ehpAt(e.x, e.y));
      let minH = 9, maxH = 0; for (const h of hps) { if (h < minH) minH = h; if (h > maxH) maxH = h; }
      let fight = false, flee = false;
      if (me.груз === 0) {
        if (adjEnemy.length === 1) {
          if (myHp >= minH || support >= 1 || minH <= 1 || stuck >= 1 || (nearHome && myHp >= 2)) fight = true; else flee = true;
        } else {
          if (support >= 1 || (myHp >= 3 && maxH <= 1) || (minH <= 1 && myHp >= 2) || (nearHome && myHp >= 2)) fight = true; else flee = true;
        }
      } else {
        if (homeDist >= 0 && homeDist <= 1) fight = false;
        else if (myHp >= 2 && adjEnemy.length === 1 && minH <= myHp && (stuck >= 1 || support >= 1)) fight = true;
        else if (minH <= 1 && adjEnemy.length === 1) fight = true;
      }
      if (flee) {
        const d = anyStep('flee');
        if (d) action = { тип: 'идти', куда: d }; else fight = true;
      }
      if (!action && fight) {
        let e = adjEnemy[0], bestS = Infinity;
        for (const c of adjEnemy) {
          const s = ehpAt(c.x, c.y) * 10 - friends.filter(f => man(f.x, f.y, c.x, c.y) === 1).length;
          if (s < bestS) { bestS = s; e = c; }
        }
        for (const d of DIRS) if (me.x + d[1] === e.x && me.y + d[2] === e.y) { action = { тип: 'бить', куда: d[0] }; break; }
        if (action) for (const se of seenE) if (se[2] === t && se[0] === e.x && se[1] === e.y) { se[3] = Math.max(0, se[3] - 1); break; }
      }
    }

    // 3. поднять еду
    if (!action && me.груз === 0 && hereFood > 0) {
      if (!atEB) action = { тип: 'взять' };
      else if (!noEB) { action = { тип: 'взять' }; mem.te = t; }
    }

    // 4. движение
    if (!action) {
      const blocked = new Uint8Array(NN);
      for (const e of enemies) blocked[K(e.x, e.y)] = 1;
      const bf = new Uint8Array(blocked);
      for (const f of friends) bf[K(f.x, f.y)] = 1;
      for (const id in resv) if (id !== myId && resv[id][1] === t) bf[resv[id][0]] = 1;
      if (stuck >= 2 && mem.sc != null && mem.sc !== S) bf[mem.sc] = 1;

      if (me.груз > 0) {
        target = baseK;
        if (man(me.x, me.y, base.x, base.y) === 1 && isFriendAt(base.x, base.y) && !enemyAdj(me.x, me.y)) {
          action = { тип: 'ждать' };
        } else {
          const bfe = new Uint8Array(bf);
          for (const e of enemies) for (const d of DIRS) {
            const nx = e.x + d[1], ny = e.y + d[2];
            if (inb(nx, ny) && !isMB(nx, ny)) bfe[K(nx, ny)] = 1;
          }
          for (const e of seenE) if (e[2] >= t - 2 && e[2] !== t) {
            for (const d of DIRS) { const nx = e[0] + d[1], ny = e[1] + d[2]; if (inb(nx, ny) && !isMB(nx, ny)) bfe[K(nx, ny)] = 1; }
          }
          let step = firstStep(bfs(bfe), target) || firstStep(bfs(bf), target) || firstStep(bfs(blocked), target);
          if (!step && enemies.length) step = anyStep('flee');
          if (!step && homeDist !== 0) step = anyStep('home');
          action = step ? { тип: 'идти', куда: step } : { тип: 'ждать' };
        }
      } else {
        // --- защитник базы (только при угрозе)
        let defender = false;
        if (threat && myHp >= 2 && homeDist >= 0 && homeDist <= 9 && left > 3) {
          let other = false;
          for (const id in claims) if (id !== myId && claims[id][0] === baseK) other = true;
          if (!other) {
            defender = true;
            if (mem.df !== t - 1) {
              for (const id in pos) {
                if (id === myId) continue;
                const p = pos[id];
                if (p[3] === t) continue; // уже ходил в этом ходу и не взялся
                if (!p[2] && man(p[0], p[1], base.x, base.y) < homeDist) { defender = false; break; }
              }
            }
          }
        }
        let step = null;
        if (defender) {
          claims[myId] = [baseK, t]; mem.df = t;
          let tgtE = null, bd = 99;
          for (const e of enemies) { const d = man(e.x, e.y, base.x, base.y); if (d <= 3 && d < bd) { bd = d; tgtE = e; } }
          if (tgtE) {
            target = K(tgtE.x, tgtE.y);
            const bd2 = new Uint8Array(bf); bd2[target] = 0;
            step = firstStep(bfs(bd2), target);
          } else {
            let bestSc = Infinity;
            for (const d of DIRS) {
              const nx = base.x + d[1], ny = base.y + d[2];
              if (!inb(nx, ny)) continue;
              const k = K(nx, ny);
              if (wall(k) || free.dist[k] < 0) continue;
              if (k !== S && (isFriendAt(nx, ny) || isReserved(k))) continue;
              const sc = free.dist[k] - 0.5 * ((nx - base.x) * sx + (ny - base.y) * sy) + ((k * 3 + hid) % 3) * 0.1;
              if (sc < bestSc) { bestSc = sc; target = k; }
            }
            if (target != null && target !== S) step = firstStep(bfs(bf), target);
          }
          action = step ? { тип: 'идти', куда: step } : { тип: 'ждать' };
        } else {
          if (mem.df != null) mem.df = null;
          let best = Infinity;
          const consider = (k, q, extra) => {
            if (q <= 0) return;
            const d = free.dist[k];
            if (d < 0) return;
            if (claimCount(k) >= q) return;
            const fx = KX(k), fy = KY(k);
            const back = man(fx, fy, base.x, base.y);
            let sc = d + 0.6 * back + extra;
            if (t + d + back >= T) sc += 6;
            if (t + d >= T) sc += 20;
            if (t < T * 0.55) sc += 0.15 * man(fx, fy, eb.x, eb.y);
            if (mem.tg === k) sc -= 2;
            if ((enemyAdj(fx, fy) || enemyNearRecent(fx, fy, 1)) && myHp < 2) sc += 6;
            if (sc < best) { best = sc; target = k; }
          };
          for (const ks in food) {
            const k = +ks;
            const fx = KX(k), fy = KY(k);
            if (isEB(fx, fy)) { if (!noEB && myHp >= 3 && !enemyNearRecent(fx, fy, 2)) consider(k, food[ks][0], -2); }
            else consider(k, food[ks][0], 0);
          }
          for (const ks in guess) consider(+ks, guess[ks][0], 2.5);
          // разведка
          if (t + 3 < T) for (let k = 0; k < NN; k++) {
            if (!pass(k)) continue;
            const d = free.dist[k];
            if (d <= 0) continue;
            const x = KX(k), y = KY(k);
            let fr = 0;
            for (const dd of DIRS) { const nx = x + dd[1], ny = y + dd[2]; if (inb(nx, ny) && !seen(K(nx, ny))) fr++; }
            if (!fr) continue;
            let near = false;
            for (const id in claims) { if (id === myId) continue; const ck = claims[id][0]; if (man(x, y, KX(ck), KY(ck)) <= 3) { near = true; break; } }
            if (near) continue;
            const dx = (x - base.x) * sx, dy = (y - base.y) * sy;
            const ang = Math.atan2(Math.max(0, dy) + 0.01, Math.max(0, dx) + 0.01);
            const w = t < 50 ? 4 : 1.5;
            let sc = d + 3 - fr * 0.4 + Math.abs(ang - prefAng) * w + ((k * 13 + hid) % 5) * 0.3;
            if (t + d + man(x, y, base.x, base.y) >= T) sc += 8;
            if (mem.tg === k) sc -= 1;
            if (sc < best) { best = sc; target = k; }
          }
          // нечего делать — дежурить у чужой базы
          let raid = false;
          if (target == null && myHp >= 3 && left > 20 && !threat) {
            let bd = Infinity;
            for (const d of DIRS) {
              const nx = eb.x + d[1], ny = eb.y + d[2];
              if (!inb(nx, ny)) continue;
              const k = K(nx, ny);
              if (wall(k) || free.dist[k] < 0) continue;
              if (claimCount(k) >= 1) continue;
              const dd = free.dist[k] + ((k * 5 + hid) % 3) * 0.1;
              if (dd < bd) { bd = dd; target = k; }
            }
            if (target != null) raid = true;
          }
          if (target != null) claims[myId] = [target, t]; else delete claims[myId];

          step = target != null ? firstStep(bfs(bf), target) : null;
          if (!step && target != null && target !== S) {
            const step2 = firstStep(bfs(blocked), target);
            if (step2) {
              const d = DIRS.find(d => d[0] === step2);
              const nx = me.x + d[1], ny = me.y + d[2];
              if (isFriendAt(nx, ny) && stuck >= 1) {
                let fLoad = 0;
                for (const id in pos) { const p = pos[id]; if (p[0] === nx && p[1] === ny) { fLoad = p[2] ? 1 : 0; break; } }
                const iYield = fLoad ? true : (((me.x + me.y) & 1) === 1);
                step = iYield ? anyStep('wander') : step2;
              } else if (!isFriendAt(nx, ny)) step = step2;
            }
          }
          if (raid && target === S) step = null;
          else if (!step && (target == null || target === S || stuck >= 3)) step = anyStep('wander');
          action = step ? { тип: 'идти', куда: step } : { тип: 'ждать' };
        }
      }
    }

    if (!action || typeof action.тип !== 'string') action = { тип: 'ждать' };

    // ---- личная память
    mem.p = [me.x, me.y];
    mem.sk = stuck;
    if (action.тип === 'идти') {
      const d = DIRS.find(d => d[0] === action.куда);
      if (d && inb(me.x + d[1], me.y + d[2])) {
        const nk = K(me.x + d[1], me.y + d[2]);
        mem.sc = nk; resv[myId] = [nk, t];
      } else { action = { тип: 'ждать' }; mem.sc = null; resv[myId] = [S, t]; }
    } else { mem.sc = null; resv[myId] = [S, t]; }
    mem.tg = (me.груз === 0 && target != null && target !== baseK) ? target : null;

    // ---- общая память
    pos[myId] = [me.x, me.y, myLoad, t];
    const trim = (obj, lim) => {
      const keys = Object.keys(obj);
      if (keys.length > lim) {
        keys.sort((a, b) => obj[a][1] - obj[b][1]);
        for (let i = 0; i < keys.length - lim; i++) delete obj[keys[i]];
      }
    };
    trim(food, 40); trim(guess, 20);

    let out = { m: map.join(''), f: food, g: guess, c: claims, p: pos, r: resv, e: seenE };
    if (noEB) out.ne = 1;
    if (gd > -999) out.gd = gd;
    if (bs >= 0) out.bs = bs;
    let s = JSON.stringify(out);
    if (s.length > 3700) {
      trim(food, 20); trim(guess, 8); out.e = seenE.slice(-4);
      s = JSON.stringify(out);
      if (s.length > 3900) out = { m: out.m, f: {}, g: {}, c: {}, p: {}, r: {}, e: [] };
    }
    return { действие: action, память: mem, общая: out };
  }
}

function решить(вход) {
  try {
    const { ход, всего_ходов, размер, я, видно, моя_база, чужая_база } = вход;
    const N = размер || 15;
    const TOTAL_CELLS = N * N;
    const turnsLeft = (всего_ходов || 150) - ход;

    let память = вход.память || {};
    let общая = вход.общая || {};

    const DIRS = [
      { dx: 0, dy: -1, k: 'С' },
      { dx: 0, dy: 1, k: 'Ю' },
      { dx: -1, dy: 0, k: 'З' },
      { dx: 1, dy: 0, k: 'В' }
    ];

    const myIdx = я.y * N + я.x;
    const baseIdx = моя_база.y * N + моя_база.x;
    const enemyBaseIdx = чужая_база.y * N + чужая_база.x;

    // 1. Инициализация общей памяти
    if (!общая.map || typeof общая.map !== 'string' || общая.map.length !== TOTAL_CELLS) {
      общая.map = '?'.repeat(TOTAL_CELLS);
      общая.food = {}; // idx -> count
      общая.targets = {}; // antId -> target_idx
      общая.turn = -1;
      общая.occupied = {}; // idx -> 'свой' | 'враг'
      общая.reserved = {}; // idx -> antId
      общая.symInit = false;
    }

    // Сброс пошаговых броней при смене хода
    if (общая.turn !== ход) {
      общая.turn = ход;
      общая.occupied = {};
      общая.reserved = {};
      // Очистка мертвых / отсутствующих муравьев из targets
      const currentAnts = {};
      currentAnts[я.id] = true;
      for (const id in общая.targets) {
        // Оставим, но подчистим неактуальные цели
        if (!общая.food[общая.targets[id]] && общая.targets[id] !== baseIdx) {
          delete общая.targets[id];
        }
      }
    }

    // 2. Парсинг видимости и учет 180° симметрии карты
    let mapArr = общая.map.split('');
    const viewMap = {};
    const visibleEnemies = [];

    for (let i = 0; i < видно.length; i++) {
      const c = видно[i];
      const idx = c.y * N + c.x;
      viewMap[idx] = c;

      const symX = N - 1 - c.x;
      const symY = N - 1 - c.y;
      const sIdx = symY * N + symX;

      if (c.что === 'стена') {
        mapArr[idx] = '#';
        if (mapArr[sIdx] === '?') mapArr[sIdx] = '#';
      } else {
        if (mapArr[idx] === '?') mapArr[idx] = '.';
        if (mapArr[sIdx] === '?') mapArr[sIdx] = '.';
      }

      if (c.что === 'враг') {
        общая.occupied[idx] = 'враг';
        visibleEnemies.push(c);
      } else if (c.что === 'свой') {
        общая.occupied[idx] = 'свой';
      }

      // Обновление информации о еде в видимой зоне
      if (c.еда > 0) {
        общая.food[idx] = c.еда;
        // Симметричная подсказка в начале игры
        if (!общая.symInit && ход <= 5 && mapArr[sIdx] !== '#' && sIdx !== baseIdx && sIdx !== enemyBaseIdx) {
          if (общая.food[sIdx] === undefined) {
            общая.food[sIdx] = c.еда;
          }
        }
      } else {
        delete общая.food[idx];
      }
    }

    if (ход > 5) общая.symInit = true;
    общая.map = mapArr.join('');
    общая.occupied[myIdx] = 'свой';
    общая.reserved[myIdx] = я.id;

    // 3. Действия на базе
    // Если пришли с грузом на базу — выгружаем
    if (myIdx === baseIdx && я.груз > 0) {
      delete общая.targets[я.id];
      return { действие: { тип: 'положить' }, память, общая };
    }

    // 4. Взятие еды под собой
    const cellHere = viewMap[myIdx];
    if (я.груз === 0 && cellHere && cellHere.еда > 0 && myIdx !== baseIdx) {
      delete общая.targets[я.id];
      if (cellHere.еда <= 1) {
        delete общая.food[myIdx];
      } else {
        общая.food[myIdx] = cellHere.еда - 1;
      }
      return { действие: { тип: 'взять' }, память, общая };
    }

    // 5. Очистка базы: муравей без груза на базе обязан немедленно уступить дорогу
    if (myIdx === baseIdx && я.груз === 0) {
      delete общая.targets[я.id];
      let bestExit = null;
      let minCost = 999;
      for (let i = 0; i < DIRS.length; i++) {
        const nx = я.x + DIRS[i].dx;
        const ny = я.y + DIRS[i].dy;
        if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
        const nIdx = ny * N + nx;
        if (mapArr[nIdx] === '#') continue;
        if (общая.occupied[nIdx]) continue; // Клетка занята в начале хода!
        if (общая.reserved[nIdx] !== undefined) continue;

        const distCenter = Math.abs(nx - 7) + Math.abs(ny - 7);
        if (distCenter < minCost) {
          minCost = distCenter;
          bestExit = DIRS[i].k;
        }
      }
      if (bestExit) {
        const dObj = DIRS.find(d => d.k === bestExit);
        общая.reserved[(я.y + dObj.dy) * N + (я.x + dObj.dx)] = я.id;
        return { действие: { тип: 'идти', куда: bestExit }, память, общая };
      }
    }

    // 6. Тактический бой с соседними врагами
    let adjacentEnemyDir = null;
    let adjacentEnemyWeight = -1;

    for (let i = 0; i < DIRS.length; i++) {
      const nx = я.x + DIRS[i].dx;
      const ny = я.y + DIRS[i].dy;
      if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
      const nIdx = ny * N + nx;
      const c = viewMap[nIdx];
      if (c && c.что === 'враг') {
        let weight = 10;
        if (c.еда > 0) weight += 30; // Враг стоит на еде или выронил
        if (я.груз === 0) weight += 15;
        if (я.здоровье >= 2) weight += 10;
        if (weight > adjacentEnemyWeight) {
          adjacentEnemyWeight = weight;
          adjacentEnemyDir = DIRS[i].k;
        }
      }
    }

    // Атакуем, если нет груза и есть непосредственная угроза/выгода
    if (adjacentEnemyDir && я.груз === 0 && adjacentEnemyWeight >= 25) {
      delete общая.targets[я.id];
      return { действие: { тип: 'бить', куда: adjacentEnemyDir }, память, общая };
    }

    // 7. BFS поиск путей с учетом строгих правил занятости клеток
    function runBFS(avoidStrict) {
      const dist = new Int16Array(TOTAL_CELLS).fill(-1);
      const firstDir = new Array(TOTAL_CELLS);
      const queue = [myIdx];
      dist[myIdx] = 0;

      let head = 0;
      while (head < queue.length) {
        const cur = queue[head++];
        const cx = cur % N;
        const cy = Math.floor(cur / N);
        const d = dist[cur];

        for (let i = 0; i < DIRS.length; i++) {
          const nx = cx + DIRS[i].dx;
          const ny = cy + DIRS[i].dy;
          if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
          const nextIdx = ny * N + nx;

          if (dist[nextIdx] !== -1) continue;
          if (mapArr[nextIdx] === '#') continue;

          // Первым шагом нельзя входить в клетки, занятые в начале хода кем-либо!
          if (d === 0) {
            if (общая.occupied[nextIdx]) continue;
            if (avoidStrict && общая.reserved[nextIdx] !== undefined && общая.reserved[nextIdx] !== я.id) continue;
          }

          dist[nextIdx] = d + 1;
          firstDir[nextIdx] = firstDir[cur] || DIRS[i].k;
          queue.push(nextIdx);
        }
      }
      return { dist, firstDir };
    }

    let { dist, firstDir } = runBFS(true);
    // Если жесткий BFS не нашел выхода, пробуем более мягкий
    let softBFS = null;
    function getSoft() {
      if (!softBFS) softBFS = runBFS(false);
      return softBFS;
    }

    let chosenDir = null;

    // 8. Логика для муравья С ГРУЗОМ
    if (я.груз > 0) {
      delete общая.targets[я.id];

      // Если стоим в шаге от базы, но база сейчас занята другим муравьем
      if ((Math.abs(я.x - моя_база.x) + Math.abs(я.y - моя_база.y)) === 1) {
        if (общая.occupied[baseIdx]) {
          // База занята, нужно переждать 1 ход, пока муравей на ней уйдет или разгрузится
          return { действие: { тип: 'ждать' }, память, общая };
        } else {
          // База свободна — шагаем прямо туда!
          for (let i = 0; i < DIRS.length; i++) {
            if (я.x + DIRS[i].dx === моя_база.x && я.y + DIRS[i].dy === моя_база.y) {
              общая.reserved[baseIdx] = я.id;
              return { действие: { тип: 'идти', куда: DIRS[i].k }, память, общая };
            }
          }
        }
      }

      if (dist[baseIdx] > 0) {
        chosenDir = firstDir[baseIdx];
      } else {
        const s = getSoft();
        if (s.dist[baseIdx] > 0) chosenDir = s.firstDir[baseIdx];
      }
    } else {
      // 9. Логика для муравья БЕЗ ГРУЗА: целеполагание и координация
      const targetClaims = {};
      for (const aId in общая.targets) {
        if (String(aId) !== String(я.id)) {
          const tIdx = общая.targets[aId];
          targetClaims[tIdx] = (targetClaims[tIdx] || 0) + 1;
        }
      }

      let bestTarget = -1;
      let bestScore = 999999;

      // 9.1. Поиск известной еды
      for (const sIdx in общая.food) {
        const fIdx = Number(sIdx);
        const count = общая.food[fIdx] || 1;
        const claimed = targetClaims[fIdx] || 0;

        if (claimed >= count) continue;

        const dToFood = dist[fIdx] > 0 ? dist[fIdx] : (getSoft().dist[fIdx] > 0 ? getSoft().dist[fIdx] : -1);
        if (dToFood <= 0) continue;

        const fx = fIdx % N;
        const fy = Math.floor(fIdx / N);
        const dToBase = Math.abs(fx - моя_база.x) + Math.abs(fy - моя_база.y);

        // Успеем ли принести до конца партии?
        // Если нет времени на доставку, но успеваем взять — берем (очки за еду в руках)
        if (dToFood + dToBase + 1 > turnsLeft && dToFood > turnsLeft) {
          continue; // Не успеем даже взять
        }

        const enemyBaseDist = Math.abs(fx - чужая_база.x) + Math.abs(fy - чужая_база.y);
        // Штраф за дальность и близость к базе противника
        let score = dToFood * 3 + dToBase * 1.5;
        if (enemyBaseDist <= 3) score += 8;

        if (score < bestScore) {
          bestScore = score;
          bestTarget = fIdx;
        }
      }

      // 9.2. Разведка тумана войны ('?'), если нет доступной еды
      if (bestTarget === -1) {
        for (let idx = 0; idx < TOTAL_CELLS; idx++) {
          if (mapArr[idx] !== '?') continue;
          const dToUnknown = dist[idx] > 0 ? dist[idx] : -1;
          if (dToUnknown <= 0) continue;
          if (targetClaims[idx]) continue;

          const cx = idx % N;
          const cy = Math.floor(idx / N);
          const centerDist = Math.abs(cx - 7) + Math.abs(cy - 7);
          const score = dToUnknown * 2 + centerDist;

          if (score < bestScore) {
            bestScore = score;
            bestTarget = idx;
          }
        }
      }

      // 9.3. Патрулирование центра / подступов к чужой базе
      if (bestTarget === -1) {
        const centerIdx = 7 * N + 7;
        if (dist[centerIdx] > 0) bestTarget = centerIdx;
        else if (dist[enemyBaseIdx] > 0) bestTarget = enemyBaseIdx;
      }

      if (bestTarget !== -1) {
        общая.targets[я.id] = bestTarget;
        if (dist[bestTarget] > 0) {
          chosenDir = firstDir[bestTarget];
        } else {
          const s = getSoft();
          if (s.dist[bestTarget] > 0) chosenDir = s.firstDir[bestTarget];
        }
      }
    }

    // 10. Валидация выбранного шага
    if (chosenDir) {
      const dObj = DIRS.find(d => d.k === chosenDir);
      if (dObj) {
        const nextX = я.x + dObj.dx;
        const nextY = я.y + dObj.dy;
        const nextIdx = nextY * N + nextX;

        // Нельзя шагать в занятую клетку (на начало хода) или забронированную
        const isFree = !общая.occupied[nextIdx];
        const isNotReserved = (общая.reserved[nextIdx] === undefined || общая.reserved[nextIdx] === я.id);

        if (isFree && isNotReserved) {
          общая.reserved[nextIdx] = я.id;
          return { действие: { тип: 'идти', куда: chosenDir }, память, общая };
        }
      }
    }

    // 11. Запасной безопасный шаг: любой свободный сосед
    for (let i = 0; i < DIRS.length; i++) {
      const nx = я.x + DIRS[i].dx;
      const ny = я.y + DIRS[i].dy;
      if (nx >= 0 && nx < N && ny >= 0 && ny < N) {
        const nIdx = ny * N + nx;
        if (mapArr[nIdx] !== '#' && !общая.occupied[nIdx]) {
          if (общая.reserved[nIdx] === undefined || общая.reserved[nIdx] === я.id) {
            общая.reserved[nIdx] = я.id;
            return { действие: { тип: 'идти', куда: DIRS[i].k }, память, общая };
          }
        }
      }
    }

    return { действие: { тип: 'ждать' }, память, общая };
  } catch (e) {
    return { действие: { тип: 'ждать' }, память: вход.память || {}, общая: вход.общая || {} };
  }
}

function решить(в) {
  try {
    const ход = в.ход | 0;
    const всего = (в.всего_ходов | 0) > 0 ? (в.всего_ходов | 0) : 150;
    const N = в.размер || 15;
    const я = в.я;
    const видно = в.видно || [];
    const МБ = в.моя_база;
    const ЧБ = в.чужая_база;
    const память = в.память && typeof в.память === "object" ? в.память : {};
    const O = в.общая && typeof в.общая === "object" ? в.общая : {};
    const DX = [0, 0, -1, 1];
    const DY = [-1, 1, 0, 0];
    const DK = ["С", "Ю", "З", "В"];
    const осталось = всего - ход;
    const груз = я.груз ? 1 : 0;
    const hp = я.здоровье | 0;
    const наБазе = я.x === МБ.x && я.y === МБ.y;
    const idStr = String(я.id);
    let idn = 0;
    for (let i = 0; i < idStr.length; i++) idn = (idn * 31 + idStr.charCodeAt(i)) | 0;
    if (idn < 0) idn = -idn;
    const homeTL = МБ.x + МБ.y < 14;

    if (!O.n || O.n.length !== N) {
      O.n = [];
      O.w = [];
      for (let i = 0; i < N; i++) {
        O.n[i] = 0;
        O.w[i] = 0;
      }
      for (let i = 0; i < N; i++) {
        O.n[0] |= 1 << i;
        O.n[N - 1] |= 1 << i;
        O.n[i] |= 1 | (1 << (N - 1));
      }
    }
    if (!O.f || typeof O.f !== "object") O.f = {};
    if (!O.tg || typeof O.tg !== "object") O.tg = {};
    if (!O.cl || typeof O.cl !== "object") O.cl = {};
    O.le = O.le || null;
    O.sc = O.sc | 0;

    function isW(x, y) {
      if (x <= 0 || x >= N - 1 || y <= 0 || y >= N - 1) return 1;
      return (O.w[y] >>> x) & 1;
    }
    function setW(x, y) {
      if (x <= 0 || x >= N - 1 || y <= 0 || y >= N - 1) return;
      O.w[y] |= 1 << x;
      const ox = N - 1 - x, oy = N - 1 - y;
      if (ox > 0 && ox < N - 1 && oy > 0 && oy < N - 1) O.w[oy] |= 1 << ox;
    }
    function markS(x, y) {
      if (x < 0 || y < 0 || x >= N || y >= N) return;
      O.n[y] |= 1 << x;
    }
    function isS(x, y) {
      if (x < 0 || y < 0 || x >= N || y >= N) return 1;
      return (O.n[y] >>> x) & 1;
    }
    function манх(x1, y1, x2, y2) {
      const ax = x1 > x2 ? x1 - x2 : x2 - x1;
      const ay = y1 > y2 ? y1 - y2 : y2 - y1;
      return ax + ay;
    }
    function key(x, y) { return (x << 4) + y; }

    const vis = {};
    const враги = [];
    const своиВид = [];
    for (let i = 0; i < видно.length; i++) {
      const c = видно[i];
      const k = key(c.x, c.y);
      vis[k] = c;
      markS(c.x, c.y);
      if (c.что === "стена") setW(c.x, c.y);
      const е = c.еда | 0;
      if (е > 0) {
        O.f[k] = [е, ход, 0];
        const ox = N - 1 - c.x, oy = N - 1 - c.y;
        const ok = key(ox, oy);
        if (!isS(ox, oy) && !isW(ox, oy)) {
          const prev = O.f[ok];
          if (!prev || prev[2]) O.f[ok] = [е, ход, 1];
        }
      } else if (O.f[k]) {
        delete O.f[k];
      }
      if (c.x === я.x && c.y === я.y) continue;
      if (c.что === "враг") {
        враги.push(c);
        O.le = { x: c.x, y: c.y, t: ход };
      } else if (c.что === "свой") своиВид.push(c);
    }

    if ((ход & 7) === (idn & 7)) {
      for (const k in O.f) {
        const inf = O.f[k];
        const age = ход - (inf[1] | 0);
        if (inf[2]) {
          if (age > 70) delete O.f[k];
        } else if (age > 200) delete O.f[k];
      }
      for (const k in O.cl) {
        if ((O.cl[k].t | 0) < ход - 2) delete O.cl[k];
      }
    }

    const stuck = (память.x === я.x && память.y === я.y) ? ((память.st | 0) + 1) : 0;
    память.st = stuck;
    память.x = я.x;
    память.y = я.y;
    if (stuck >= 3) {
      память.ex = undefined;
      память.tx = undefined;
    }

    for (const id in O.tg) {
      if (!O.tg[id] || (O.tg[id].t | 0) < ход - 2) delete O.tg[id];
    }
    O.tg[idStr] = { x: я.x, y: я.y, g: груз, t: ход, hp: hp };

    const ids = [];
    for (const id in O.tg) ids.push(id);
    if (ids.indexOf(idStr) < 0) ids.push(idStr);
    ids.sort();
    let myRank = 0;
    for (let i = 0; i < ids.length; i++) if (ids[i] === idStr) myRank = i;
    const живых = ids.length;

    function nearEnemy(x, y) {
      for (let i = 0; i < враги.length; i++) {
        if (манх(враги[i].x, враги[i].y, x, y) === 1) return 1;
      }
      return 0;
    }

    function occNow(x, y) {
      const c = vis[key(x, y)];
      if (!c) return 0;
      if (c.что === "враг" || c.что === "свой" || c.что === "стена") return 1;
      return 0;
    }

    function bfs(sx, sy, avoidTh) {
      const cap = N * N;
      const dist = new Array(cap);
      const first = new Array(cap);
      for (let i = 0; i < cap; i++) { dist[i] = 999; first[i] = 0; }
      const q = new Array(cap);
      let qh = 0, qt = 0;
      const si = sy * N + sx;
      dist[si] = 0;
      q[qt++] = si;
      while (qh < qt) {
        const idx = q[qh++];
        const x = idx % N;
        const y = (idx / N) | 0;
        const cd = dist[idx];
        for (let i = 0; i < 4; i++) {
          const nx = x + DX[i];
          const ny = y + DY[i];
          if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;
          const ni = ny * N + nx;
          if (dist[ni] <= cd + 1) continue;
          if (isW(nx, ny)) continue;
          if (avoidTh && nearEnemy(nx, ny) && !(nx === МБ.x && ny === МБ.y)) continue;
          dist[ni] = cd + 1;
          first[ni] = first[idx] || (i + 1);
          q[qt++] = ni;
        }
      }
      return { dist: dist, first: first };
    }

    const avoidTh = груз && враги.length > 0 && stuck < 3;
    let D = bfs(я.x, я.y, avoidTh);
    let D2 = null;
    let DH = null;
    function dAt(x, y) {
      let d = D.dist[y * N + x];
      if (d >= 999) {
        if (!D2) D2 = bfs(я.x, я.y, 0);
        d = D2.dist[y * N + x];
      }
      return d;
    }
    function firstTo(x, y) {
      let f = D.first[y * N + x];
      if (!f || D.dist[y * N + x] >= 999) {
        if (!D2) D2 = bfs(я.x, я.y, 0);
        f = D2.first[y * N + x];
      }
      return f ? DK[f - 1] : null;
    }
    function hAt(x, y) {
      if (!DH) DH = bfs(МБ.x, МБ.y, 0);
      const d = DH.dist[y * N + x];
      return d < 999 ? d : манх(x, y, МБ.x, МБ.y);
    }

    function клеткаОк(nx, ny, allowEB) {
      if (nx < 0 || ny < 0 || nx >= N || ny >= N) return 0;
      if (isW(nx, ny)) return 0;
      if (nx === ЧБ.x && ny === ЧБ.y && (груз || !allowEB)) return 0;
      if (occNow(nx, ny)) return 0;
      if (stuck < 2) {
        for (const id in O.tg) {
          if (id === idStr) continue;
          const t = O.tg[id];
          if ((t.t | 0) === ход && t.px === nx && t.py === ny) return 0;
        }
      }
      return 1;
    }

    function идти(dir, allowEB) {
      let di = -1;
      for (let i = 0; i < 4; i++) if (DK[i] === dir) di = i;
      if (di < 0) return { тип: "ждать" };
      const nx = я.x + DX[di];
      const ny = я.y + DY[di];
      if (!клеткаОк(nx, ny, allowEB)) return null;
      return { тип: "идти", куда: dir };
    }

    function кЦели(tx, ty, allowEB) {
      if (я.x === tx && я.y === ty) return { тип: "ждать" };
      const dir = firstTo(tx, ty);
      if (dir) {
        const a = идти(dir, allowEB);
        if (a) {
          const nx = я.x + (dir === "З" ? -1 : dir === "В" ? 1 : 0);
          const ny = я.y + (dir === "С" ? -1 : dir === "Ю" ? 1 : 0);
          if (!(груз && nearEnemy(nx, ny) && stuck < 2 && манх(я.x, я.y, МБ.x, МБ.y) > 2)) return a;
        }
      }
      let best = null;
      let bestS = 1e9;
      const start = (idn + ход) & 3;
      for (let k = 0; k < 4; k++) {
        const i = (start + k) & 3;
        const nx = я.x + DX[i];
        const ny = я.y + DY[i];
        if (!клеткаОк(nx, ny, allowEB)) continue;
        let s = манх(nx, ny, tx, ty) * 12;
        const dd = dAt(tx, ty);
        s += dd < 999 ? dd : 40;
        if (груз && nearEnemy(nx, ny)) s += 28;
        if (!груз && vis[key(nx, ny)] && (vis[key(nx, ny)].еда | 0) > 0) s -= 40;
        if (s < bestS) {
          bestS = s;
          best = DK[i];
        }
      }
      if (best) return { тип: "идти", куда: best };
      for (let k = 0; k < 4; k++) {
        const a = идти(DK[(start + k) & 3], allowEB);
        if (a) return a;
      }
      return { тип: "ждать" };
    }

    function claimN(fx, fy) {
      const c = O.cl[key(fx, fy)];
      return (c && (c.t | 0) === ход) ? (c.n | 0) : 0;
    }
    function markClaim(fx, fy) {
      const k = key(fx, fy);
      const c = O.cl[k];
      if (!c || (c.t | 0) !== ход) O.cl[k] = { t: ход, n: 1 };
      else c.n = (c.n | 0) + 1;
    }

    function closerCount(fx, fy, myd) {
      let n = 0;
      for (const id in O.tg) {
        if (id === idStr) continue;
        const t = O.tg[id];
        if (t.g) continue;
        if ((t.t | 0) < ход - 2) continue;
        const d = манх(t.x, t.y, fx, fy);
        if (t.x === fx && t.y === fy) n++;
        else if (d < myd || (d === myd && id < idStr)) n++;
      }
      return n;
    }

    function out(act) {
      if (!act || !act.тип) act = { тип: "ждать" };
      память.a = act.тип;
      O.tg[idStr].a = act.тип;
      if (act.тип === "идти" && act.куда) {
        let di = -1;
        for (let i = 0; i < 4; i++) if (DK[i] === act.куда) di = i;
        if (di >= 0) {
          O.tg[idStr].px = я.x + DX[di];
          O.tg[idStr].py = я.y + DY[di];
        }
      }
      if (память.tx !== undefined) {
        O.tg[idStr].tx = память.tx;
        O.tg[idStr].ty = память.ty;
      }
      if (act.тип === "положить" && наБазе && груз) O.sc = (O.sc | 0) + 1;
      return { действие: act, память: память, общая: O };
    }

    const dHomeP = dAt(МБ.x, МБ.y);
    const dHome = dHomeP < 999 ? dHomeP : манх(я.x, я.y, МБ.x, МБ.y);

    if (груз && наБазе) return out({ тип: "положить" });

    const здесь = vis[key(я.x, я.y)];
    const едаЗдесь = здесь ? (здесь.еда | 0) : 0;
    if (!груз && едаЗдесь > 0) return out({ тип: "взять" });

    let битьКуда = null;
    let битьПриор = -1;
    let foesAdj = 0;
    for (let i = 0; i < 4; i++) {
      const nx = я.x + DX[i];
      const ny = я.y + DY[i];
      const c = vis[key(nx, ny)];
      if (!c || c.что !== "враг") continue;
      foesAdj++;
      const eHome = манх(nx, ny, МБ.x, МБ.y);
      const eFood = (c.еда | 0) > 0;
      let allies = 1;
      for (let j = 0; j < своиВид.length; j++) {
        if (манх(своиВид[j].x, своиВид[j].y, nx, ny) === 1) allies++;
      }
      for (const id in O.tg) {
        if (id === idStr) continue;
        const t = O.tg[id];
        if (манх(t.x, t.y, nx, ny) === 1) allies++;
      }
      if (allies > 4) allies = 4;
      let pr = 0;
      if (наБазе || dHome <= 1 || eHome <= 1) pr = 10;
      else if (eFood) pr = 8;
      else if (едаЗдесь > 0) pr = 8;
      else if (allies >= 2 && allies > foesAdj) pr = 7;
      else if (dHome <= 2) pr = 7;
      else if (!груз && hp >= 3 && foesAdj === 1 && eHome <= 5 && allies >= 1) pr = 4;
      if (груз) {
        if (eHome <= 2 || наБазе) pr = 9;
        else if (hp <= 2) pr = 0;
        else if (pr < 8) pr = 0;
      }
      if (hp <= 1 && pr < 8 && !наБазе) pr = 0;
      if (pr > битьПриор) {
        битьПриор = pr;
        битьКуда = DK[i];
      }
    }
    if (битьКуда && битьПриор >= 8) return out({ тип: "бить", куда: битьКуда });

    if (!груз) {
      let adjFood = null;
      let adjSc = -1e9;
      for (let i = 0; i < 4; i++) {
        const nx = я.x + DX[i];
        const ny = я.y + DY[i];
        if (!клеткаОк(nx, ny, 0)) continue;
        const c = vis[key(nx, ny)];
        if (!c || (c.еда | 0) <= 0) continue;
        const amt = c.еда | 0;
        if (claimN(nx, ny) >= amt) continue;
        if (closerCount(nx, ny, 1) >= amt) continue;
        const home = hAt(nx, ny);
        const sc = amt * 20 - home;
        if (sc > adjSc) {
          adjSc = sc;
          adjFood = DK[i];
          память.tx = nx;
          память.ty = ny;
        }
      }
      if (adjFood) {
        markClaim(память.tx, память.ty);
        return out({ тип: "идти", куда: adjFood });
      }
    }

    if (наБазе && !груз) {
      const start = myRank & 3;
      const order = homeTL ? [3, 1, 2, 0] : [2, 0, 3, 1];
      for (let k = 0; k < 4; k++) {
        const a = идти(DK[order[(start + k) & 3]], 0);
        if (a) return out(a);
      }
    }

    if (груз) {
      память.tx = МБ.x;
      память.ty = МБ.y;
      O.tg[idStr].tx = МБ.x;
      O.tg[idStr].ty = МБ.y;
      if (битьКуда && битьПриор >= 7 && dHome <= 4) return out({ тип: "бить", куда: битьКуда });
      if (hp <= 1 && foesAdj > 0) {
        const fl = кЦели(МБ.x, МБ.y, 0);
        if (fl && fl.тип === "идти") return out(fl);
      }
      return out(кЦели(МБ.x, МБ.y, 0));
    }

    if (битьКуда && битьПриор >= 7) return out({ тип: "бить", куда: битьКуда });

    if (hp <= 1 && foesAdj > 0 && !наБазе) {
      let bestD = null;
      let bestS = -1e9;
      const start = (idn + ход) & 3;
      for (let k = 0; k < 4; k++) {
        const i = (start + k) & 3;
        const nx = я.x + DX[i];
        const ny = я.y + DY[i];
        if (!клеткаОк(nx, ny, 0)) continue;
        let s = 0;
        if (nearEnemy(nx, ny)) s -= 30;
        if (враги.length) s += манх(nx, ny, враги[0].x, враги[0].y) * 8;
        s -= манх(nx, ny, МБ.x, МБ.y);
        if (s > bestS) {
          bestS = s;
          bestD = DK[i];
        }
      }
      if (bestD) return out({ тип: "идти", куда: bestD });
      return out(кЦели(МБ.x, МБ.y, 0));
    }

    const foods = [];
    for (const k in O.f) {
      const info = O.f[k];
      const amt = info[0] | 0;
      if (amt <= 0) continue;
      const fx = (k | 0) >> 4;
      const fy = (k | 0) & 15;
      if (fx < 1 || fy < 1 || fx > 13 || fy > 13) continue;
      if (isW(fx, fy)) continue;
      const mydM = манх(я.x, я.y, fx, fy);
      const already = claimN(fx, fy);
      if (already >= amt) continue;
      const cc = closerCount(fx, fy, mydM);
      if (cc + already >= amt) continue;
      const d = dAt(fx, fy);
      if (d >= 999) continue;
      const home = hAt(fx, fy);
      const eh = манх(fx, fy, ЧБ.x, ЧБ.y);
      const inferred = info[2] ? 1 : 0;
      const visF = vis[key(fx, fy)];
      const realVis = visF && (visF.еда | 0) > 0;
      let sc = amt * 48 - d * 9 - home * 4;
      if (realVis) sc += 40;
      if (!inferred && home <= eh + 1) sc += 10;
      if (inferred) sc += ход < 45 ? 6 : -18;
      if (d <= 2) sc += 24;
      else if (d <= 4) sc += 12;
      else if (d <= 7) sc += 5;
      if (home < eh) sc += 4;
      const canDel = d + home + 1 <= осталось;
      if (!canDel && осталось > 12) continue;
      if (!canDel) sc -= 20;
      foods.push({ x: fx, y: fy, a: amt, d: d, home: home, sc: sc, inf: inferred });
    }

    const ants = [];
    for (const id in O.tg) {
      const t = O.tg[id];
      if (t.g) continue;
      if ((t.t | 0) < ход - 2) continue;
      ants.push({ id: id, x: t.x, y: t.y });
    }
    ants.sort(function (a, b) { return a.id < b.id ? -1 : a.id > b.id ? 1 : 0; });

    const usedA = {};
    const usedF = {};
    let myFood = null;
    for (let round = 0; round < ants.length; round++) {
      let bestSc = -1e9;
      let bi = -1;
      let bj = -1;
      for (let i = 0; i < ants.length; i++) {
        if (usedA[ants[i].id]) continue;
        for (let j = 0; j < foods.length; j++) {
          const f = foods[j];
          const fk = key(f.x, f.y);
          if ((usedF[fk] | 0) >= f.a) continue;
          const d = манх(ants[i].x, ants[i].y, f.x, f.y);
          let sc = f.sc - d * 6;
          if (ants[i].id === idStr) sc += (f.d <= 4 ? 8 : 0);
          if (sc > bestSc) {
            bestSc = sc;
            bi = i;
            bj = j;
          }
        }
      }
      if (bi < 0) break;
      const f = foods[bj];
      const fk = key(f.x, f.y);
      usedA[ants[bi].id] = 1;
      usedF[fk] = (usedF[fk] | 0) + 1;
      if (ants[bi].id === idStr) myFood = f;
    }

    if (myFood) {
      память.tx = myFood.x;
      память.ty = myFood.y;
      markClaim(myFood.x, myFood.y);
      if (битьКуда && битьПриор >= 4 && myFood.d > 6) return out({ тип: "бить", куда: битьКуда });
      return out(кЦели(myFood.x, myFood.y, 0));
    }

    if (битьКуда && битьПриор >= 4) return out({ тип: "бить", куда: битьКуда });

    const late = осталось <= 16;
    if (late && hp >= 2 && O.le && ход - (O.le.t | 0) <= 10) {
      память.tx = O.le.x;
      память.ty = O.le.y;
      return out(кЦели(O.le.x, O.le.y, 1));
    }
    if (late && hp >= 2 && dAt(ЧБ.x, ЧБ.y) + 1 <= осталось) {
      память.tx = ЧБ.x;
      память.ty = ЧБ.y;
      return out(кЦели(ЧБ.x, ЧБ.y, 1));
    }

    let seenCnt = 0;
    for (let y = 0; y < N; y++) {
      let v = O.n[y];
      while (v) { seenCnt += v & 1; v >>>= 1; }
    }

    if (осталось > 10) {
      const sectors = homeTL
        ? [[4, 4], [10, 4], [4, 10], [10, 10], [7, 3], [3, 7], [11, 7], [7, 11], [7, 7], [12, 6], [6, 12], [9, 9]]
        : [[10, 10], [4, 10], [10, 4], [4, 4], [7, 11], [11, 7], [3, 7], [7, 3], [7, 7], [2, 8], [8, 2], [5, 5]];
      const se = sectors[(myRank + ((ход / 12) | 0) * 2) % sectors.length];
      let uBest = null;
      let uBestD = 99999;
      if (память.ex !== undefined && !isS(память.ex, память.ey) && !isW(память.ex, память.ey)) {
        const ed = dAt(память.ex, память.ey);
        if (ed < 999 && ed > 0) {
          uBest = { x: память.ex, y: память.ey };
          uBestD = ed * 9;
        }
      }
      for (let y = 1; y <= 13; y++) {
        for (let x = 1; x <= 13; x++) {
          if (isS(x, y) || isW(x, y)) continue;
          let skip = 0;
          for (const id in O.tg) {
            if (id === idStr) continue;
            const t = O.tg[id];
            if (t.g) continue;
            const df = манх(t.x, t.y, x, y);
            const dm = манх(я.x, я.y, x, y);
            if (df < dm - 1 || (df === dm && id < idStr)) { skip = 1; break; }
            if (t.tx === x && t.ty === y && id < idStr) { skip = 1; break; }
          }
          if (skip) continue;
          const d = dAt(x, y);
          if (d >= 999) continue;
          const ax = x > se[0] ? x - se[0] : se[0] - x;
          const ay = y > se[1] ? y - se[1] : se[1] - y;
          const frontier = (isS(x + 1, y) || isS(x - 1, y) || isS(x, y + 1) || isS(x, y - 1)) ? 0 : 14;
          const adj = d * 8 + ax * 4 + ay * 4 + frontier;
          if (adj < uBestD) {
            uBestD = adj;
            uBest = { x: x, y: y };
          }
        }
      }
      if (uBest) {
        память.tx = uBest.x;
        память.ty = uBest.y;
        память.ex = uBest.x;
        память.ey = uBest.y;
        return out(кЦели(uBest.x, uBest.y, 0));
      }
    }

    if (hp >= 2 && осталось > 20 && myRank === живых - 1 && seenCnt > 70) {
      const hx = homeTL ? 11 : 3;
      const hy = homeTL ? 11 : 3;
      память.tx = hx;
      память.ty = hy;
      return out(кЦели(hx, hy, 1));
    }

    if (stuck >= 2) {
      const start = (idn + ход) & 3;
      for (let k = 0; k < 4; k++) {
        const i = (start + k) & 3;
        const nx = я.x + DX[i];
        const ny = я.y + DY[i];
        if (nx < 1 || ny < 1 || nx > 13 || ny > 13) continue;
        if (isW(nx, ny)) continue;
        const c = vis[key(nx, ny)];
        if (c && (c.что === "стена" || c.что === "враг")) continue;
        if (c && c.что === "свой" && stuck < 4) continue;
        return out({ тип: "идти", куда: DK[i] });
      }
    }

    const патруль = homeTL
      ? [[4, 4], [7, 3], [10, 4], [3, 7], [7, 7], [11, 7], [4, 10], [7, 11], [10, 10], [6, 5], [9, 8], [5, 9], [12, 8], [8, 12]]
      : [[10, 10], [7, 11], [4, 10], [11, 7], [7, 7], [3, 7], [10, 4], [7, 3], [4, 4], [8, 9], [5, 6], [9, 5], [2, 6], [6, 2]];
    const pi = (idn + myRank * 3 + ((ход / 9) | 0)) % патруль.length;
    const pt = патруль[pi];
    if (осталось > манх(я.x, я.y, pt[0], pt[1]) + 4) {
      память.tx = pt[0];
      память.ty = pt[1];
      return out(кЦели(pt[0], pt[1], 0));
    }

    if (dHome > 0 && осталось < 6) return out(кЦели(МБ.x, МБ.y, 0));
    return out({ тип: "ждать" });
  } catch (e) {
    return { действие: { тип: "ждать" }, память: в.память || {}, общая: в.общая || {} };
  }
}

function решить(в) {
  const N = Number(в.размер) || 15;
  const T = Number(в.ход) || 0;
  const LIM = Number(в.всего_ходов) || 150;
  const me = в.я;
  const base = в.моя_база;
  const enemyBase = в.чужая_база;
  const mem = Object.assign({}, в.память || {});
  const team = Object.assign({}, в.общая || {});
  const sight = Array.isArray(в.видно) ? в.видно : [];

  const D = [
    { x: 0, y: -1, n: "С" },
    { x: 1, y: 0, n: "В" },
    { x: 0, y: 1, n: "Ю" },
    { x: -1, y: 0, n: "З" }
  ];

  function hash(s) {
    s = String(s);
    let h = 2166136261;
    for (let i = 0; i < s.length; i++) {
      h ^= s.charCodeAt(i);
      h = Math.imul(h, 16777619);
    }
    return h >>> 0;
  }

  const H = hash(me.id);
  const slot = typeof me.id === "number"
    ? ((me.id % 4) + 4) % 4
    : H & 3;
  const index = (x, y) => y * N + x;
  const key = (x, y) => x + "," + y;
  const inside = (x, y) => x >= 0 && y >= 0 && x < N && y < N;
  const md = (x, y, p) => Math.abs(x - p.x) + Math.abs(y - p.y);

  let map = typeof team.m === "string" && team.m.length === N * N
    ? team.m.split("")
    : new Array(N * N).fill("?");

  const visible = Object.create(null);
  const enemies = [];
  for (let i = 0; i < sight.length; i++) {
    const c = sight[i];
    if (!inside(c.x, c.y)) continue;
    visible[key(c.x, c.y)] = c;
    map[index(c.x, c.y)] = c.что === "стена" ? "#" : ".";
    if (c.что === "враг") enemies.push(c);
  }
  map[index(me.x, me.y)] = ".";

  let foods = Array.isArray(team.f) ? team.f.slice(0, 64) : [];

  function foodAt(x, y) {
    for (let i = 0; i < foods.length; i++) {
      if (foods[i][0] === x && foods[i][1] === y) return i;
    }
    return -1;
  }

  for (let i = 0; i < sight.length; i++) {
    const c = sight[i];
    if (c.что === "стена") continue;
    const amount = Math.max(0, Number(c.еда) || 0);
    const j = foodAt(c.x, c.y);
    if (amount > 0) {
      const rec = [c.x, c.y, Math.min(9, amount), T];
      if (j < 0) foods.push(rec);
      else foods[j] = rec;
    } else if (j >= 0) {
      foods.splice(j, 1);
    }
  }

  foods = foods.filter(function (f) {
    return inside(f[0], f[1]) && T - (Number(f[3]) || 0) <= 90;
  });
  if (foods.length > 64) {
    foods.sort(function (a, b) {
      return b[3] - a[3];
    });
    foods.length = 64;
  }

  let claims = Array.isArray(team.c) ? team.c.slice(0, 12) : [];
  claims = claims.filter(function (c) {
    return c && c.length >= 4 && T - Number(c[3]) <= 3;
  });

  let intents = Array.isArray(team.i) ? team.i.slice(0, 8) : [];
  intents = intents.filter(function (r) {
    return r && r.length >= 4 && T - Number(r[3]) <= 1;
  });

  function clearMine(list) {
    return list.filter(function (r) {
      return r[2] !== slot;
    });
  }

  function claim(x, y) {
    claims = clearMine(claims);
    claims.push([x, y, slot, T]);
  }

  function reserve(x, y) {
    intents = clearMine(intents);
    intents.push([x, y, slot, T]);
  }

  function finish(action) {
    team.m = map.join("");
    team.f = foods;
    team.c = claims;
    team.i = intents;
    mem.t = T;
    return { действие: action, память: mem, общая: team };
  }

  const carrying = Number(me.груз) > 0;
  const here = visible[key(me.x, me.y)];
  const atBase = me.x === base.x && me.y === base.y;
  const remaining = LIM - T + 1;

  if (carrying && atBase) {
    claims = clearMine(claims);
    intents = clearMine(intents);
    mem.g = null;
    mem.e = null;
    return finish({ тип: "положить" });
  }

  const adjacent = [];
  for (let k = 0; k < 4; k++) {
    const d = D[k];
    const c = visible[key(me.x + d.x, me.y + d.y)];
    if (c && c.что === "враг") {
      adjacent.push({
        k: k,
        food: Number(c.еда) || 0,
        home: md(c.x, c.y, base),
        eh: md(c.x, c.y, enemyBase)
      });
    }
  }

  if (adjacent.length) {
    adjacent.sort(function (a, b) {
      return b.food - a.food ||
        a.home - b.home ||
        a.eh - b.eh ||
        (((a.k - slot - T) & 3) - ((b.k - slot - T) & 3));
    });
    return finish({ тип: "бить", куда: D[adjacent[0].k].n });
  }

  if (!carrying && here && Number(here.еда) > 0) {
    const j = foodAt(me.x, me.y);
    if (j >= 0) {
      foods[j] = foods[j].slice();
      foods[j][2]--;
      foods[j][3] = T;
      if (foods[j][2] <= 0) foods.splice(j, 1);
    }
    claims = clearMine(claims);
    intents = clearMine(intents);
    mem.g = null;
    return finish({ тип: "взять" });
  }

  function occupiedFirst(x, y) {
    const c = visible[key(x, y)];
    if (c && (c.что === "стена" || c.что === "свой" || c.что === "враг")) {
      return true;
    }
    for (let i = 0; i < intents.length; i++) {
      if (intents[i][0] === x && intents[i][1] === y &&
          intents[i][2] !== slot && intents[i][3] === T) {
        return true;
      }
    }
    return false;
  }

  function bfs(sx, sy, unknownAllowed) {
    const dist = new Int16Array(N * N);
    dist.fill(-1);
    const q = new Int16Array(N * N);
    let head = 0, tail = 0;
    const start = index(sx, sy);
    dist[start] = 0;
    q[tail++] = start;

    while (head < tail) {
      const p = q[head++];
      const x = p % N;
      const y = (p / N) | 0;
      for (let k = 0; k < 4; k++) {
        const nx = x + D[k].x;
        const ny = y + D[k].y;
        if (!inside(nx, ny)) continue;
        const ni = index(nx, ny);
        if (dist[ni] >= 0 || map[ni] === "#") continue;
        if (!unknownAllowed && map[ni] === "?") continue;
        dist[ni] = dist[p] + 1;
        q[tail++] = ni;
      }
    }
    return dist;
  }

  function moveTo(tx, ty, mode) {
    if (!inside(tx, ty) || (tx === me.x && ty === me.y)) return null;

    const seen = new Uint8Array(N * N);
    const first = new Int8Array(N * N);
    const q = new Int16Array(N * N);
    const start = index(me.x, me.y);
    let head = 0, tail = 0, found = -1;
    q[tail++] = start;
    seen[start] = 1;

    let rot = (slot * 3 + T + (mode || 0)) & 3;
    if (carrying) rot = (slot + (T >> 1)) & 3;

    while (head < tail) {
      const p = q[head++];
      const x = p % N;
      const y = (p / N) | 0;
      if (x === tx && y === ty) {
        found = p;
        break;
      }

      for (let z = 0; z < 4; z++) {
        const dk = (z + rot) & 3;
        const nx = x + D[dk].x;
        const ny = y + D[dk].y;
        if (!inside(nx, ny)) continue;
        const ni = index(nx, ny);
        if (seen[ni] || map[ni] === "#") continue;
        if (p === start && occupiedFirst(nx, ny)) continue;
        seen[ni] = 1;
        first[ni] = p === start ? dk : first[p];
        q[tail++] = ni;
      }
    }

    if (found < 0) return null;
    const d = D[first[found]];
    reserve(me.x + d.x, me.y + d.y);
    mem.p = [me.x, me.y];
    return { тип: "идти", куда: d.n };
  }

  if (carrying) {
    claims = clearMine(claims);
    mem.g = null;

    const known = bfs(me.x, me.y, false);
    let homeDist = known[index(base.x, base.y)];
    if (homeDist < 0) {
      const all = bfs(me.x, me.y, true);
      homeDist = all[index(base.x, base.y)];
    }

    if (homeDist >= 0 && homeDist + 1 <= remaining) {
      const action = moveTo(base.x, base.y, 0);
      if (action) return finish(action);
    }

    if (remaining <= 2) {
      intents = clearMine(intents);
      return finish({ тип: "ждать" });
    }

    const action = moveTo(base.x, base.y, 1);
    return finish(action || { тип: "ждать" });
  }

  const fromMe = bfs(me.x, me.y, true);
  const fromBase = bfs(base.x, base.y, true);
  let chosen = null;
  let best = -1e9;

  for (let i = 0; i < foods.length; i++) {
    const f = foods[i];
    const fi = index(f[0], f[1]);
    const go = fromMe[fi];
    const back = fromBase[fi];
    if (go < 0 || back < 0) continue;

    let assigned = 0;
    for (let j = 0; j < claims.length; j++) {
      const c = claims[j];
      if (c[0] === f[0] && c[1] === f[1] && c[2] !== slot) assigned++;
    }

    const sticky = Array.isArray(mem.g) &&
      mem.g[0] === f[0] && mem.g[1] === f[1];
    const amount = Math.max(1, Number(f[2]) || 1);
    if (assigned >= amount && !sticky) continue;

    const deliverable = go + back + 2 <= remaining;
    if (!deliverable && go + 1 > remaining) continue;

    const age = T - Number(f[3]);
    const enemySide = md(f[0], f[1], enemyBase) < md(f[0], f[1], base);
    const endValue = deliverable ? 100 : (remaining <= 12 ? 75 : -100);

    let score =
      endValue +
      amount * 12 -
      go * 9 -
      (deliverable ? back * 3 : 0) -
      assigned * 35 -
      Math.min(age, 25) * 1.2 +
      (sticky ? 24 : 0) -
      (enemySide ? 5 : 0) -
      ((f[0] * 17 + f[1] * 11 + slot * 7) & 5);

    if (score > best) {
      best = score;
      chosen = { x: f[0], y: f[1] };
    }
  }

  if (chosen) {
    mem.g = [chosen.x, chosen.y];
    claim(chosen.x, chosen.y);
    const action = moveTo(chosen.x, chosen.y, 2);
    if (action) return finish(action);

    if (chosen.x === me.x && chosen.y === me.y) {
      const j = foodAt(chosen.x, chosen.y);
      if (j >= 0) foods.splice(j, 1);
    }
    mem.g = null;
    claims = clearMine(claims);
  } else {
    mem.g = null;
    claims = clearMine(claims);
  }

  let frontier = null;
  let frontierScore = 1e9;
  const sector = [
    [N - 2, 1],
    [1, N - 2],
    [N - 2, N - 2],
    [(N / 2) | 0, (N / 2) | 0]
  ][slot];

  for (let y = 0; y < N; y++) {
    for (let x = 0; x < N; x++) {
      if (map[index(x, y)] !== ".") continue;
      const d = fromMe[index(x, y)];
      if (d < 0) continue;

      let gain = 0;
      for (let yy = Math.max(0, y - 2); yy <= Math.min(N - 1, y + 2); yy++) {
        for (let xx = Math.max(0, x - 2); xx <= Math.min(N - 1, x + 2); xx++) {
          if (map[index(xx, yy)] === "?") gain++;
        }
      }
      if (!gain) continue;

      const sectorBias = Math.abs(x - sector[0]) + Math.abs(y - sector[1]);
      const previous = Array.isArray(mem.e) &&
        mem.e[0] === x && mem.e[1] === y ? -18 : 0;
      const score =
        d * 13 +
        sectorBias * 2 -
        gain * 5 +
        previous +
        ((x * 19 + y * 23 + H) & 7);

      if (score < frontierScore) {
        frontierScore = score;
        frontier = { x: x, y: y };
      }
    }
  }

  if (frontier) {
    mem.e = [frontier.x, frontier.y];
    const action = moveTo(frontier.x, frontier.y, 3);
    if (action) return finish(action);
  }

  const patrol = base.x < enemyBase.x
    ? [
        [4, 4], [7, 3], [10, 4], [11, 7],
        [10, 10], [7, 11], [4, 10], [3, 7], [7, 7]
      ]
    : [
        [10, 10], [7, 11], [4, 10], [3, 7],
        [4, 4], [7, 3], [10, 4], [11, 7], [7, 7]
      ];

  let phase = Math.max(0, Number(mem.r) || 0);
  if (Array.isArray(mem.q) && mem.q[0] === me.x && mem.q[1] === me.y) phase++;
  mem.q = [me.x, me.y];

  for (let z = 0; z < patrol.length; z++) {
    const p = patrol[(phase + slot * 2) % patrol.length];
    if (map[index(p[0], p[1])] === "#") {
      phase++;
      continue;
    }
    if (Math.abs(me.x - p[0]) + Math.abs(me.y - p[1]) <= 1) {
      phase++;
      continue;
    }
    const action = moveTo(p[0], p[1], z);
    if (action) {
      mem.r = phase;
      return finish(action);
    }
    phase++;
  }

  const previous = Array.isArray(mem.p) ? mem.p : null;
  for (let z = 0; z < 4; z++) {
    const k = (z + slot + T) & 3;
    const nx = me.x + D[k].x;
    const ny = me.y + D[k].y;
    if (!inside(nx, ny) || map[index(nx, ny)] === "#" || occupiedFirst(nx, ny)) continue;
    if (previous && nx === previous[0] && ny === previous[1] && z < 3) continue;
    reserve(nx, ny);
    mem.p = [me.x, me.y];
    return finish({ тип: "идти", куда: D[k].n });
  }

  intents = clearMine(intents);
  return finish({ тип: "ждать" });
}

function решить(вход) {
  var пам = (вход && вход.память && typeof вход.память === "object") ? вход.память : {};
  var общ = (вход && вход.общая && typeof вход.общая === "object") ? вход.общая : {};
  var действие = null;
  try {
    var N = (вход.размер | 0) || 15;
    if (N < 5 || N > 60) N = 15;
    var ХОД = вход.ход | 0;
    var ВСЕГО = (вход.всего_ходов | 0) || 150;
    if (ВСЕГО < 1) ВСЕГО = 150;
    var эХод = ХОД;
    if (эХод > ВСЕГО) эХод = ((ХОД - 1) % ВСЕГО) + 1; // страховка при сквозной нумерации ходов
    var ост = ВСЕГО - эХод;

    var я = вход.я || {};
    var X = я.x | 0, Y = я.y | 0, ИД = я.id | 0;
    var HP = (я.здоровье === undefined) ? 3 : (я.здоровье | 0);
    if (HP < 1) HP = 1;
    var ГРУЗ = я.груз ? 1 : 0;
    var БАЗА = (вход.моя_база && typeof вход.моя_база === "object") ? вход.моя_база : { x: 1, y: 1 };
    var ВБАЗА = (вход.чужая_база && typeof вход.чужая_база === "object") ? вход.чужая_база : { x: N - 2, y: N - 2 };

    var i, d, cx, cy, nx, ny, ni;
    var ИН = function (x, y) { return y * N + x; };
    var КЛЮЧ = function (x, y) { return x + "," + y; };
    var Д = [[0, -1], [0, 1], [-1, 0], [1, 0]]; // С Ю З В
    var НАПР = function (k) { return k === 0 ? "С" : k === 1 ? "Ю" : k === 2 ? "З" : "В"; };
    var сдв = ((ИД % 4) + 4) % 4;

    // ---------- общая память ----------
    if (!общ.к || typeof общ.к !== "string" || общ.к.length !== N * N) {
      var s = "";
      for (var yy = 0; yy < N; yy++) for (var xx = 0; xx < N; xx++)
        s += (xx === 0 || yy === 0 || xx === N - 1 || yy === N - 1) ? "#" : "?";
      общ.к = s;
    }
    if (!общ.е || typeof общ.е !== "object") общ.е = {};
    if (!общ.п || typeof общ.п !== "object") общ.п = {};
    if (!общ.з || typeof общ.з !== "object") общ.з = {};
    if (!общ.поз || typeof общ.поз !== "object") общ.поз = {};
    if (общ.мх !== ХОД || !общ.м || typeof общ.м !== "object") { общ.м = {}; общ.мх = ХОД; }
    общ.поз[ИД] = [X, Y, ГРУЗ, ХОД];

    var карта = общ.к.split("");
    var би = ИН(БАЗА.x, БАЗА.y);
    var вби = ИН(ВБАЗА.x, ВБАЗА.y);
    var старт = ИН(X, Y);

    // ---------- личная память ----------
    if (!Array.isArray(пам.сл)) пам.сл = [];
    if (пам.сл.length === 0 || пам.сл[пам.сл.length - 1] !== старт) {
      пам.сл.push(старт);
      if (пам.сл.length > 5) пам.сл.shift();
    }
    if (!пам.тс || typeof пам.тс !== "object") пам.тс = {};
    for (var tk in пам.тс) if ((пам.тс[tk] | 0) <= ХОД) delete пам.тс[tk];

    // детектор застревания
    if (пам.движ === 1) {
      if (пам.пх === X && пам.пу === Y) пам.стоп = (пам.стоп | 0) + 1; else пам.стоп = 0;
    } else if (пам.движ === 2) {
      пам.стоп = (пам.стоп | 0) + 1; // вынужденное стояние тоже считаем
    }
    пам.движ = 0; пам.пх = X; пам.пу = Y;

    // ---------- восприятие ----------
    var занято = {}, враги = [], едаВидно = [], видимо = {};
    var едаЗдесь = 0;
    var вид = вход.видно || [];
    for (i = 0; i < вид.length; i++) {
      var к = вид[i]; if (!к) continue;
      var kx = к.x | 0, ky = к.y | 0;
      if (kx < 0 || ky < 0 || kx >= N || ky >= N) continue;
      var ин = ИН(kx, ky);
      видимо[ин] = 1;
      var что = к.что;
      карта[ин] = (что === "стена") ? "#" : ".";
      var ключ = КЛЮЧ(kx, ky);
      var ед = к.еда | 0;
      if (ед > 0) {
        едаВидно.push({ x: kx, y: ky, е: ед });
        if (ин === старт) едаЗдесь = ед;
        общ.е[ключ] = [ед, ХОД];
        общ.п[ключ] = 1;
      } else if (общ.е[ключ]) delete общ.е[ключ];
      if ((что === "свой" || что === "враг") && ин !== старт) {
        занято[ин] = (что === "враг") ? 2 : 1;
        if (что === "враг") {
          var ddx = kx - X, ddy = ky - Y;
          враги.push({
            x: kx, y: ky, ин: ин, д: Math.abs(ddx) + Math.abs(ddy),
            н: ddy === -1 ? "С" : ddy === 1 ? "Ю" : ddx === -1 ? "З" : "В"
          });
          общ.в = [kx, ky, ХОД];
        }
      } else if (что === "база" && ин === вби) {
        занято[ин] = 2;
      }
    }
    // свои из общ.поз: флаги груза и свежие позиции
    var грузИд = {}, носит = {};
    for (var pid in общ.поз) {
      var pz = общ.поз[pid];
      if (!pz || !Array.isArray(pz)) continue;
      var px3 = pz[0] | 0, py3 = pz[1] | 0;
      if (px3 < 0 || py3 < 0 || px3 >= N || py3 >= N) continue;
      if (ХОД - (pz[3] | 0) > 1) continue;
      грузИд[pid | 0] = pz[2] | 0;
      if ((pid | 0) === ИД) continue;
      var пи = ИН(px3, py3);
      if (!занято[пи]) занято[пи] = 1;
      if ((pz[2] | 0) > 0) носит[пи] = 1;
    }
    карта[би] = ".";
    карта[вби] = "#";
    if (!занято[вби]) занято[вби] = 2;
    общ.к = карта.join("");

    // ---------- гигиена общей памяти ----------
    for (var zk in общ.з) {
      var zz = общ.з[zk];
      if (!zz || typeof zz !== "object" || !Array.isArray(zz.а) || (zz.х | 0) < ХОД - 10) delete общ.з[zk];
    }
    var колЕ = 0, старК = null, старХ = 1e15, колП = 0;
    for (var ek in общ.е) {
      var ez = общ.е[ek];
      if (!ez || !Array.isArray(ez) || (ez[0] | 0) <= 0) { delete общ.е[ek]; continue; }
      колЕ++;
      if ((ez[1] | 0) < старХ) { старХ = ez[1] | 0; старК = ek; }
    }
    if (колЕ > 45 && старК) delete общ.е[старК];
    for (var pk in общ.п) { колП++; if (колП > 42) delete общ.п[pk]; }

    var врБыли = (пам.вр && typeof пам.вр === "object") ? пам.вр : {};
    пам.вр = {};
    var врагСч = 0;
    for (i = 0; i < враги.length; i++) { пам.вр[враги[i].ин] = 1; if (враги[i].д === 1) врагСч++; }

    // ---------- BFS ----------
    var БФС = function (стартИн, блок) {
      var d2 = new Array(N * N);
      for (var i2 = 0; i2 < N * N; i2++) d2[i2] = -1;
      d2[стартИн] = 0;
      var q = [стартИн], h = 0;
      while (h < q.length) {
        var cur = q[h++]; cx = cur % N; cy = (cur / N) | 0;
        for (d = 0; d < 4; d++) {
          nx = cx + Д[d][0]; ny = cy + Д[d][1];
          if (nx < 0 || ny < 0 || nx >= N || ny >= N) continue;
          ni = ИН(nx, ny);
          if (d2[ni] >= 0 || карта[ni] === "#") continue;
          if (блок && пам.тс[ni] !== undefined && ni !== стартИн) continue;
          d2[ni] = d2[cur] + 1; q.push(ni);
        }
      }
      return d2;
    };
    var dist = БФС(старт, false);
    var dB = БФС(би, false);

    // ---------- помощники ----------
    var минВраг = function (px, py) {
      var м = 99;
      for (var i2 = 0; i2 < враги.length; i2++) {
        var dd = Math.abs(враги[i2].x - px) + Math.abs(враги[i2].y - py);
        if (dd < м) м = dd;
      }
      return м;
    };
    var рядомНоситель = function () {
      for (var d3 = 0; d3 < 4; d3++) {
        var wx2 = X + Д[d3][0], wy2 = Y + Д[d3][1];
        if (wx2 < 0 || wy2 < 0 || wx2 >= N || wy2 >= N) continue;
        if (носит[ИН(wx2, wy2)]) return true;
      }
      return false;
    };
    var ИДТИ = function (nap, кудаИн) {
      пам.движ = 1; пам.цел = кудаИн;
      общ.м[КЛЮЧ(кудаИн % N, (кудаИн / N) | 0)] = ИД;
      return { тип: "идти", куда: nap };
    };
    // шаг по полю расстояний; пустые уступают клетки с носителями
    var шагПоД = function (dT, весВраг, яНошу) {
      var лучш = null, лучшС = 1e15;
      for (var d2 = 0; d2 < 4; d2++) {
        var di2 = (d2 + сдв) % 4;
        var wx = X + Д[di2][0], wy = Y + Д[di2][1];
        if (wx < 0 || wy < 0 || wx >= N || wy >= N) continue;
        var wi = ИН(wx, wy);
        if (карта[wi] === "#" || пам.тс[wi] !== undefined) continue;
        if (dT[wi] < 0) continue;
        var зн = занято[wi] || 0;
        if (зн === 2) continue;
        if (зн === 1 && !яНошу && носит[wi]) continue; // уступаем носителю дорогу
        var ск = dT[wi] * 100 + di2;
        if (зн === 1) ск += 5000;
        var мк = общ.м[КЛЮЧ(wx, wy)];
        if (мк !== undefined) ск += (грузИд[мк | 0] > 0 ? 4000 : 250);
        if (весВраг > 0 && минВраг(wx, wy) <= 1) ск += весВраг;
        if (ск < лучшС) { лучшС = ск; лучш = { н: НАПР(di2), ин: wi, з: зн, дд: dT[wi] }; }
      }
      return лучш;
    };
    var идтиКЦели = function (цель, весВраг, яНошу) {
      var dT = БФС(цель, true);
      var ш = шагПоД(dT, весВраг, яНошу);
      if (!ш) { пам.движ = 2; return { тип: "ждать" }; }
      return ИДТИ(ш.н, ш.ин);
    };
    var побег = function () {
      var лучш = null, лучшС = 1e15;
      for (var d2 = 0; d2 < 4; d2++) {
        var di2 = (d2 + сдв) % 4;
        var wx = X + Д[di2][0], wy = Y + Д[di2][1];
        if (wx < 0 || wy < 0 || wx >= N || wy >= N) continue;
        var wi = ИН(wx, wy);
        if (карта[wi] === "#" || занято[wi] || пам.тс[wi] !== undefined) continue;
        var мв = минВраг(wx, wy);
        var ск = -мв * 1000 + (dB[wi] >= 0 ? dB[wi] : 60) * 10 + di2;
        if (ск < лучшС) { лучшС = ск; лучш = { н: НАПР(di2), ин: wi, м: мв }; }
      }
      return лучш;
    };
    // уступка с откатом по собственному следу (разруливает коридоры)
    var уступить = function () {
      var пов = ((ИД + ХОД) % 4 + 4) % 4;
      var cand = [], wx, wy, wi, di2, d2;
      for (d2 = 0; d2 < 4; d2++) {
        di2 = (d2 + пов) % 4;
        wx = X + Д[di2][0]; wy = Y + Д[di2][1];
        if (wx < 0 || wy < 0 || wx >= N || wy >= N) continue;
        wi = ИН(wx, wy);
        if (карта[wi] === "#" || занято[wi]) continue;
        if (пам.цел !== undefined && wi === пам.цел) continue;
        if (минВраг(wx, wy) <= 1 && (ГРУЗ > 0 || HP <= 2)) continue;
        if (ГРУЗ === 0 && wi === би) continue; // не перекрываем базу
        cand.push({ н: НАПР(di2), ин: wi });
      }
      if (cand.length === 0) {
        for (d2 = 0; d2 < 4; d2++) {
          di2 = (d2 + пов) % 4;
          wx = X + Д[di2][0]; wy = Y + Д[di2][1];
          if (wx < 0 || wy < 0 || wx >= N || wy >= N) continue;
          wi = ИН(wx, wy);
          if (карта[wi] === "#" || занято[wi]) continue;
          if (минВраг(wx, wy) <= 1 && (ГРУЗ > 0 || HP <= 2)) continue;
          cand.push({ н: НАПР(di2), ин: wi });
        }
      }
      if (cand.length === 0) return { тип: "ждать" };
      var t, c2;
      for (t = пам.сл.length - 2; t >= 0; t--) {
        for (c2 = 0; c2 < cand.length; c2++) {
          if (cand[c2].ин === пам.сл[t]) return ИДТИ(cand[c2].н, cand[c2].ин);
        }
      }
      return ИДТИ(cand[0].н, cand[0].ин);
    };
    var выбратьУдар = function () {
      var лучш = null, лучшС = -1e15;
      for (var i2 = 0; i2 < враги.length; i2++) {
        var вр = враги[i2]; if (вр.д !== 1) continue;
        var ск = 0;
        if (общ.е[КЛЮЧ(вр.x, вр.y)]) ск += 6;
        if (врБыли[вр.ин]) ск += 3;
        if (dB[вр.ин] >= 0 && dB[вр.ин] <= 3) ск += 2;
        ск -= (вр.ин % 7) * 0.001;
        if (ск > лучшС) { лучшС = ск; лучш = вр; }
      }
      return лучш;
    };
    var занятоЛи = function (ключ, cap) {
      var з = общ.з[ключ];
      if (!з || !Array.isArray(з.а)) return false;
      for (var q4 = 0; q4 < з.а.length; q4++) if (з.а[q4] === ИД) return false;
      return з.а.length >= cap;
    };
    var заявка = function (ключ, cap) {
      var з = общ.з[ключ];
      if (!з || typeof з !== "object" || !Array.isArray(з.а)) з = { а: [], х: ХОД };
      var имеем = false;
      for (var q4 = 0; q4 < з.а.length; q4++) if (з.а[q4] === ИД) имеем = true;
      if (!имеем) {
        if (з.а.length >= cap) return false;
        з.а.push(ИД);
      }
      з.х = ХОД; общ.з[ключ] = з;
      return true;
    };
    var снять = function (ключ) {
      var з = общ.з[ключ];
      if (з && Array.isArray(з.а)) {
        var н2 = [];
        for (var q4 = 0; q4 < з.а.length; q4++) if (з.а[q4] !== ИД) н2.push(з.а[q4]);
        з.а = н2; общ.з[ключ] = з;
      }
    };

    var наБазе = (старт === би);
    if (ГРУЗ > 0) {
      пам.уступка = 0;
      if (пам.це !== undefined) { снять(пам.це); delete пам.це; }
    }

    // А. доставка на базу
    if (ГРУЗ > 0 && наБазе) действие = { тип: "положить" };

    // Б. бой/побег с пустыми руками
    if (!действие && ГРУЗ === 0 && врагСч > 0) {
      var уБазы = false;
      for (i = 0; i < враги.length; i++)
        if (враги[i].д === 1 && dB[враги[i].ин] >= 0 && dB[враги[i].ин] <= 2) уБазы = true;
      var цу = null;
      if (HP > врагСч || уБазы) цу = выбратьУдар();
      if (цу) действие = { тип: "бить", куда: цу.н };
      else {
        var шп = побег();
        if (шп && шп.м > минВраг(X, Y)) действие = ИДТИ(шп.н, шп.ин);
        else { цу = выбратьУдар(); действие = цу ? { тип: "бить", куда: цу.н } : { тип: "ждать" }; }
      }
    }

    // Д. поднять еду под собой
    if (!действие && ГРУЗ === 0 && едаЗдесь > 0) действие = { тип: "взять" };

    // В. рассасывание пробок (только без груза)
    if (!действие && ГРУЗ === 0) {
      if ((пам.уступка | 0) > 0) { пам.уступка = (пам.уступка | 0) - 1; действие = уступить(); }
      else if ((пам.стоп | 0) >= 2) {
        пам.стоп = 0; пам.уступка = 1;
        if (пам.цел !== undefined && пам.цел !== би) пам.тс[пам.цел] = ХОД + 10;
        действие = уступить();
      }
    }

    // Г. несём груз домой
    if (!действие && ГРУЗ > 0) {
      var бн = БАЗА.y === Y - 1 ? "С" : БАЗА.y === Y + 1 ? "Ю" : БАЗА.x === X - 1 ? "З" : "В";
      if (dB[старт] === 1) {
        var знБ = занято[би] || 0;
        if (знБ === 2) {
          действие = { тип: "бить", куда: бн }; // враг сидит на нашей базе
        } else if (знБ === 1) {
          // свой на базе: пробуем войти в освобождаемую клетку, без штрафа за неудачу;
          // если долго не пускают — отступаем, чтобы разрушить пробку у базы
          пам.жб = (пам.жб | 0) + 1;
          if (пам.жб >= 3) { пам.жб = 0; действие = уступить(); }
          else { действие = ИДТИ(бн, би); пам.движ = 0; }
        } else { пам.жб = 0; действие = ИДТИ(бн, би); }
      } else {
        пам.жб = 0;
        var успеваем = dB[старт] >= 0 && dB[старт] <= ост;
        if (!успеваем) {
          // недоносимый груз держим в руках (тай-брейк), сторонимся врагов
          if (врагСч > 0) {
            var шп2 = побег();
            if (шп2 && шп2.м > минВраг(X, Y)) действие = ИДТИ(шп2.н, шп2.ин);
            else { var цу4 = выбратьУдар(); действие = цу4 ? { тип: "бить", куда: цу4.н } : { тип: "ждать" }; }
          } else if (dB[старт] > 3) {
            var шд0 = шагПоД(dB, 250, true);
            if (шд0 && шд0.дд < dB[старт]) действие = ИДТИ(шд0.н, шд0.ин);
            else действие = { тип: "ждать" };
          } else действие = { тип: "ждать" };
        } else if ((пам.стоп | 0) >= 2 + (ИД & 1)) {
          // коридорный тупик носитель-носитель: кто-то должен отступить (асимметрия по id)
          пам.стоп = 0;
          if (пам.цел !== undefined && пам.цел !== би) пам.тс[пам.цел] = ХОД + 10;
          действие = уступить();
        } else {
          var шд = шагПоД(dB, 250, true);
          if (!шд) { пам.движ = 2; действие = { тип: "ждать" }; }
          else if (шд.дд < dB[старт] || врагСч === 0 || HP < 2) действие = ИДТИ(шд.н, шд.ин);
          else {
            var цу2 = выбратьУдар();
            действие = цу2 ? { тип: "бить", куда: цу2.н } : ИДТИ(шд.н, шд.ин);
          }
        }
      }
    }

    // Е. цель-еда: видимая или запомненная
    if (!действие && ГРУЗ === 0) {
      var лучш = -1, лучшСч = 1e15, держ = -1, держСч = 1e15;
      var рассм = function (px, py, е) {
        var ти = ИН(px, py);
        if (ти === старт) return;
        var dd = dist[ти];
        if (dd <= 0) return;
        if ((занято[ти] || 0) !== 0 && dd <= 2) return;
        var ключ2 = КЛЮЧ(px, py);
        var db = dB[ти]; if (db < 0) return;
        if (занятоЛи(ключ2, е < 2 ? 1 : 2)) return;
        if (dd + db <= ост) {
          var ск = (dd + db) * 3 + dd - (е < 3 ? е : 3) * 4;
          if (ключ2 === пам.це) ск -= 8; // инерция цели
          if (ск < лучшСч) { лучшСч = ск; лучш = ти; }
        } else if (dd <= ост && dd < держСч) {
          держСч = dd; держ = ти; // успеем хотя бы взять в руки
        }
      };
      for (i = 0; i < едаВидно.length; i++) рассм(едаВидно[i].x, едаВидно[i].y, едаВидно[i].е);
      for (var fk in общ.е) {
        var fz = общ.е[fk];
        if (!fz || !Array.isArray(fz)) continue;
        var fе = fz[0] | 0; if (fе <= 0) continue;
        if (ХОД - (fz[1] | 0) > 100) continue;
        var pp = fk.split(",");
        рассм(+pp[0], +pp[1], fе);
      }
      var цельЕ = лучш >= 0 ? лучш : держ;
      if (цельЕ >= 0) {
        var ключЦ = КЛЮЧ(цельЕ % N, (цельЕ / N) | 0);
        if (пам.це !== ключЦ) { if (пам.це !== undefined) снять(пам.це); пам.це = ключЦ; }
        заявка(ключЦ, 2);
        действие = идтиКЦели(цельЕ, 40, false);
      } else if (пам.це !== undefined) { снять(пам.це); delete пам.це; }
    }

    // Ё. защита базы: прогнать врага, подошедшего вплотную
    if (!действие && ГРУЗ === 0 && HP >= 2 && ост > 8) {
      var цельД = -1, цельДд = 1e15;
      for (i = 0; i < враги.length; i++) {
        var вр2 = враги[i];
        if (вр2.д < 2) continue;
        var db2 = dB[вр2.ин];
        if (db2 < 0 || db2 > 3) continue;
        var dd2 = dist[вр2.ин];
        if (dd2 <= 0 || dd2 > 6) continue;
        if (занятоЛи("д" + вр2.ин, 1)) continue;
        if (dd2 < цельДд) { цельДд = dd2; цельД = вр2.ин; }
      }
      if (цельД >= 0) { заявка("д" + цельД, 1); действие = идтиКЦели(цельД, 0, false); }
    }

    // Ж. разведка неизвестных клеток (с раскаткой по направлениям)
    if (!действие && ГРУЗ === 0 && ост > 15) {
      var сx = ВБАЗА.x > БАЗА.x ? 1 : -1, сy = ВБАЗА.y > БАЗА.y ? 1 : -1;
      var вект = [[3, 2], [2, 3], [3, 1], [1, 3]][сдв];
      var цельР = -1, цельРд = 1e15;
      for (i = 0; i < N * N; i++) {
        if (карта[i] !== "?" || dist[i] <= 0) continue;
        if (занятоЛи("р" + i, 1)) continue;
        var скР = dist[i] * 30 - (((i % N) - БАЗА.x) * сx * вект[0] + (((i / N) | 0) - БАЗА.y) * сy * вект[1]);
        if (скР < цельРд) { цельРд = скР; цельР = i; }
      }
      if (цельР >= 0) { заявка("р" + цельР, 1); действие = идтиКЦели(цельР, 40, false); }
    }

    // П. свободное время: раненые/поздние — домой; затем парковка у известных куч (сторожим появление еды)
    if (!действие && ГРУЗ === 0) {
      var свежВраг = общ.в && Array.isArray(общ.в) && (ХОД - (общ.в[2] | 0) <= 10);
      if (HP <= 2 && свежВраг && dB[старт] > 2) {
        var шр = шагПоД(dB, 250, false);
        if (шр && шр.дд < dB[старт]) действие = ИДТИ(шр.н, шр.ин);
      }
      if (!действие && ост <= 10 && dB[старт] > 3) {
        var шр2 = шагПоД(dB, 250, false);
        if (шр2 && шр2.дд < dB[старт]) действие = ИДТИ(шр2.н, шр2.ин);
      }
      if (!действие && ост > 10) {
        if (общ.п[КЛЮЧ(X, Y)] && едаЗдесь === 0) {
          if (рядомНоситель()) действие = уступить(); // освобождаем проход носителю
          else действие = { тип: "ждать" };
        } else {
          var цельГ = -1, цельГд = 1e15;
          for (var pk2 in общ.п) {
            if (общ.е[pk2]) continue;
            var pp2 = pk2.split(",");
            var tx2 = +pp2[0], ty2 = +pp2[1];
            if (!(tx2 >= 0 && ty2 >= 0 && tx2 < N && ty2 < N)) continue;
            var ti2 = ИН(tx2, ty2);
            if (ti2 === старт || видимо[ti2]) continue;
            var dd3 = dist[ti2];
            if (dd3 <= 0) continue;
            if (занято[ti2]) continue;
            if (занятоЛи("г" + ti2, 1)) continue;
            var db3 = dB[ti2]; if (db3 < 0) db3 = 50;
            var ск3 = dd3 * 4 + db3;
            if (ск3 < цельГд) { цельГд = ск3; цельГ = ti2; }
          }
          if (цельГ >= 0) { заявка("г" + цельГ, 1); действие = идтиКЦели(цельГ, 40, false); }
        }
      }
    }

    // И. не стоим столбом на своей базе
    if (!действие && наБазе && ГРУЗ === 0) {
      var лучшИ = null, лучшИс = 1e15;
      for (d = 0; d < 4; d++) {
        var di3 = (d + сдв) % 4;
        nx = X + Д[di3][0]; ny = Y + Д[di3][1];
        if (nx < 0 || ny < 0 || nx >= N || ny >= N) continue;
        ni = ИН(nx, ny);
        if (карта[ni] === "#" || занято[ni]) continue;
        var скИ = di3;
        if (общ.м[КЛЮЧ(nx, ny)] !== undefined) скИ += 100;
        if (минВраг(nx, ny) <= 1) скИ += 500;
        if (скИ < лучшИс) { лучшИс = скИ; лучшИ = { н: НАПР(di3), ин: ni }; }
      }
      if (лучшИ) действие = ИДТИ(лучшИ.н, лучшИ.ин);
    }

    // Й. пустой без дела рядом с носителем — освобождает дорогу
    if (!действие && ГРУЗ === 0 && рядомНоситель()) действие = уступить();

    if (!действие) действие = { тип: "ждать" };
  } catch (e) {
    if (!действие) действие = { тип: "ждать" };
  }
  return { действие: действие, память: пам, общая: общ };
}

function решить(в) {
  try {
    const inp = (в && typeof в === 'object') ? в : {};
    const S = 15;
    const N = S * S;

    let T = (typeof inp.ход === 'number' && isFinite(inp.ход)) ? (inp.ход | 0) : 0;
    let TOTAL = (typeof inp.всего_ходов === 'number' && isFinite(inp.всего_ходов)) ? (inp.всего_ходов | 0) : 150;
    if (TOTAL <= 0) TOTAL = 150;
    const rem = Math.max(0, TOTAL - T);

    function abs(a) { return a < 0 ? -a : a; }
    function idx(xx, yy) { return yy * S + xx; }
    function inb(xx, yy) { return xx >= 0 && xx < S && yy >= 0 && yy < S; }
    function num(v, d) { return (typeof v === 'number' && isFinite(v)) ? v : d; }
    function clampC(v) {
      v |= 0;
      if (v < 0) v = 0;
      if (v >= S) v = S - 1;
      return v;
    }

    const DIRS = [
      { n: 'С', dx: 0, dy: -1 },
      { n: 'Ю', dx: 0, dy: 1 },
      { n: 'З', dx: -1, dy: 0 },
      { n: 'В', dx: 1, dy: 0 }
    ];

    const me = (inp.я && typeof inp.я === 'object') ? inp.я : {};
    const x = clampC(num(me.x, 1));
    const y = clampC(num(me.y, 1));
    let hp = num(me.здоровье, 3) | 0;
    if (hp < 1 || hp > 3) hp = 3;
    const carry = me.груз ? 1 : 0;

    const myBase = (inp.моя_база && typeof inp.моя_база === 'object') ? inp.моя_база : { x: 1, y: 1 };
    const enemyBase = (inp.чужая_база && typeof inp.чужая_база === 'object') ? inp.чужая_база : { x: 13, y: 13 };

    const bx = clampC(num(myBase.x, 1));
    const by = clampC(num(myBase.y, 1));
    const exb = clampC(num(enemyBase.x, 13));
    const eyb = clampC(num(enemyBase.y, 13));

    const myIdx = idx(x, y);
    const baseIdx = idx(bx, by);
    const enemyBaseIdx = idx(exb, eyb);
    const onBase = myIdx === baseIdx;

    const sxDir = (exb > bx) ? 1 : (exb < bx ? -1 : 1);
    const syDir = (eyb > by) ? 1 : (eyb < by ? -1 : 1);

    let idNum;
    if (typeof me.id === 'number' && isFinite(me.id)) {
      idNum = me.id | 0;
    } else {
      const s = String((me.id === undefined || me.id === null) ? '0' : me.id);
      idNum = parseInt(s, 10);
      if (!isFinite(idNum)) {
        let hh = 7;
        for (let i = 0; i < s.length; i++) {
          hh = (hh * 31 + s.charCodeAt(i)) >>> 0;
        }
        idNum = hh % 1000000;
      }
    }
    if (idNum < 0) idNum = -idNum;

    const idHash = ((idNum * 2654435761) >>> 0) % 1000000;
    const role = ((idNum % 4) + 4) % 4;

    const memIn = (inp.память && typeof inp.память === 'object' && !Array.isArray(inp.память)) ? inp.память : {};
    function memNum(v, d) {
      return (typeof v === 'number' && isFinite(v)) ? (v | 0) : d;
    }

    const mem = {
      target: memNum(memIn.t, -1),
      targetT: memNum(memIn.tt, -9999),
      mode: memNum(memIn.m, 0),
      wp: memNum(memIn.w, 0),
      stuck: memNum(memIn.s, 0),
      lastAct: typeof memIn.la === 'string' ? memIn.la : '',
      lastDir: typeof memIn.ld === 'string' ? memIn.ld : '',
      px: memNum(memIn.px, -1),
      py: memNum(memIn.py, -1),
      prevHp: memNum(memIn.hp, hp),
      lastHitT: memNum(memIn.ht, -9999)
    };

    const VERSION = 10;
    const comIn = (inp.общая && typeof inp.общая === 'object' && !Array.isArray(inp.общая)) ? inp.общая : {};
    const useCommon = comIn.v === VERSION;

    const walls = new Array(N).fill(false);
    const seen = new Array(N).fill(false);
    const foodAmt = new Array(N).fill(-1);
    const foodTime = new Array(N).fill(-9999);
    const enemyTime = new Array(N).fill(-9999);
    const enemyVis = new Array(N).fill(false);
    const allyVis = new Array(N).fill(false);
    const danger = new Array(N).fill(false);

    if (useCommon) {
      if (Array.isArray(comIn.wb)) {
        for (let k = 0; k < 8; k++) {
          const bits = comIn.wb[k] | 0;
          for (let b = 0; b < 32; b++) {
            const ii = k * 32 + b;
            if (ii < N && ((bits >>> b) & 1) !== 0) walls[ii] = true;
          }
        }
      }

      if (Array.isArray(comIn.sm)) {
        for (let k = 0; k < 8; k++) {
          const bits = comIn.sm[k] | 0;
          for (let b = 0; b < 32; b++) {
            const ii = k * 32 + b;
            if (ii < N && ((bits >>> b) & 1) !== 0) seen[ii] = true;
          }
        }
      }

      if (Array.isArray(comIn.f)) {
        for (let i = 0; i < comIn.f.length; i++) {
          const e = comIn.f[i];
          if (!Array.isArray(e) || e.length < 3) continue;
          const fi = e[0] | 0;
          if (fi < 0 || fi >= N) continue;
          let a = e[1] | 0;
          let tt = e[2] | 0;
          if (a < 0) a = 0;
          if (a > 4) a = 4;
          if (tt < 0) tt = 0;
          if (tt > T) tt = T;
          if (T - tt > 150) continue;
          foodAmt[fi] = a;
          foodTime[fi] = tt;
        }
      }

      if (Array.isArray(comIn.e)) {
        for (let i = 0; i < comIn.e.length; i++) {
          const e = comIn.e[i];
          if (!Array.isArray(e) || e.length < 2) continue;
          const ei = e[0] | 0;
          let et = e[1] | 0;
          if (ei < 0 || ei >= N || et < 0) continue;
          if (et > T) et = T;
          if (T - et <= 40) enemyTime[ei] = et;
        }
      }
    }

    for (let i = 0; i < S; i++) {
      walls[idx(i, 0)] = true;
      walls[idx(i, S - 1)] = true;
      walls[idx(0, i)] = true;
      walls[idx(S - 1, i)] = true;
      seen[idx(i, 0)] = true;
      seen[idx(i, S - 1)] = true;
      seen[idx(0, i)] = true;
      seen[idx(S - 1, i)] = true;
    }

    const claimCount = new Array(N).fill(0);
    let claims = [];

    if (useCommon && Array.isArray(comIn.c)) {
      for (let i = 0; i < comIn.c.length && claims.length < 12; i++) {
        const e = comIn.c[i];
        if (!Array.isArray(e) || e.length < 3) continue;
        const cid = e[0] | 0;
        const ct = e[1] | 0;
        const tt = e[2] | 0;
        if (ct < 0 || ct >= N) continue;
        const age = T - tt;
        if (age < 0 || age > 10) continue;
        claims.push([cid, ct, tt]);
        if (cid !== idHash) claimCount[ct]++;
      }
    }

    let threatT = useCommon ? memNum(comIn.thT, -9999) : -9999;
    let threatI = useCommon ? memNum(comIn.thI, -1) : -1;
    if (threatI < 0 || threatI >= N || T - threatT > 10) {
      threatT = -9999;
      threatI = -1;
    }

    const visible = Array.isArray(inp.видно) ? inp.видно : [];
    const visibleEnemies = [];
    let currentFood = 0;
    let enemyNearBaseVisible = false;

    for (let vi = 0; vi < visible.length; vi++) {
      const c = visible[vi];
      if (!c || typeof c !== 'object') continue;

      const cx = num(c.x, -1) | 0;
      const cy = num(c.y, -1) | 0;
      if (!inb(cx, cy)) continue;

      const ii = idx(cx, cy);
      const what = typeof c.что === 'string' ? c.что : '';
      const food = c.еда | 0;
      const sym = idx(S - 1 - cx, S - 1 - cy);

      seen[ii] = true;

      if (what === 'стена') {
        walls[ii] = true;
        if (sym !== baseIdx && sym !== enemyBaseIdx) walls[sym] = true;
        continue;
      }

      walls[ii] = false;
      if (sym !== baseIdx && sym !== enemyBaseIdx) walls[sym] = false;

      if (ii === myIdx) currentFood = food > 0 ? food : 0;

      if (what === 'враг') {
        if (ii !== myIdx) {
          enemyVis[ii] = true;
          enemyTime[ii] = T;
          visibleEnemies.push({ x: cx, y: cy, i: ii });
          if (abs(cx - bx) + abs(cy - by) <= 6) enemyNearBaseVisible = true;
        }
      } else if (what === 'свой') {
        if (ii !== myIdx) allyVis[ii] = true;
      }

      if (ii !== baseIdx && ii !== enemyBaseIdx) {
        if (food > 0) {
          foodAmt[ii] = food > 4 ? 4 : food;
          foodTime[ii] = T;
        } else if (food === 0) {
          foodAmt[ii] = 0;
          foodTime[ii] = T;
        }
      }
    }

    for (let i = 0; i < S; i++) {
      walls[idx(i, 0)] = true;
      walls[idx(i, S - 1)] = true;
      walls[idx(0, i)] = true;
      walls[idx(S - 1, i)] = true;
      seen[idx(i, 0)] = true;
      seen[idx(i, S - 1)] = true;
      seen[idx(0, i)] = true;
      seen[idx(S - 1, i)] = true;
    }

    walls[baseIdx] = false;
    walls[enemyBaseIdx] = false;
    walls[myIdx] = false;
    seen[baseIdx] = true;
    seen[enemyBaseIdx] = true;
    seen[myIdx] = true;

    for (let ei = 0; ei < visibleEnemies.length; ei++) {
      const e = visibleEnemies[ei];
      danger[e.i] = true;
      for (let di = 0; di < DIRS.length; di++) {
        const nx = e.x + DIRS[di].dx;
        const ny = e.y + DIRS[di].dy;
        if (inb(nx, ny)) danger[idx(nx, ny)] = true;
      }
    }

    if (threatI >= 0 && T - threatT <= 2) {
      danger[threatI] = true;
      const tx = threatI % S;
      const ty = (threatI / S) | 0;
      for (let di = 0; di < DIRS.length; di++) {
        const nx = tx + DIRS[di].dx;
        const ny = ty + DIRS[di].dy;
        if (inb(nx, ny)) danger[idx(nx, ny)] = true;
      }
    }

    const expFood = new Array(N).fill(0);
    let knownFoodTotal = 0;

    for (let ii = 0; ii < N; ii++) {
      if (walls[ii] || ii === baseIdx || ii === enemyBaseIdx) continue;
      const a = foodAmt[ii];
      if (a <= 0) continue;
      const age = T - foodTime[ii];
      if (age < 0 || age > 150) continue;

      let dec = 0;
      if (age >= 90) dec = 2;
      else if (age >= 45) dec = 1;

      let e = a - dec;
      if (e < 1 && age < 90) e = 1;
      if (e > 4) e = 4;

      if (e > 0) {
        expFood[ii] = e;
        knownFoodTotal += e;
      }
    }

    function bfs(start) {
      const dist = new Array(N).fill(-1);
      if (start < 0 || start >= N || walls[start]) return dist;

      const q = new Array(N);
      let head = 0;
      let tail = 0;
      dist[start] = 0;
      q[tail++] = start;

      while (head < tail) {
        const ci = q[head++];
        const cx = ci % S;
        const cy = (ci / S) | 0;
        const nd = dist[ci] + 1;

        if (cx > 0) {
          const ni = ci - 1;
          if (dist[ni] < 0 && !walls[ni]) {
            dist[ni] = nd;
            q[tail++] = ni;
          }
        }
        if (cx < S - 1) {
          const ni = ci + 1;
          if (dist[ni] < 0 && !walls[ni]) {
            dist[ni] = nd;
            q[tail++] = ni;
          }
        }
        if (cy > 0) {
          const ni = ci - S;
          if (dist[ni] < 0 && !walls[ni]) {
            dist[ni] = nd;
            q[tail++] = ni;
          }
        }
        if (cy < S - 1) {
          const ni = ci + S;
          if (dist[ni] < 0 && !walls[ni]) {
            dist[ni] = nd;
            q[tail++] = ni;
          }
        }
      }

      return dist;
    }

    const distMe = bfs(myIdx);
    const distBase = bfs(baseIdx);
    const dHome = distBase[myIdx] >= 0 ? distBase[myIdx] : abs(x - bx) + abs(y - by);

    const distCache = {};
    distCache['b' + baseIdx] = distBase;

    function getDist(t) {
      if (t === baseIdx) return distBase;
      const k = 'b' + t;
      if (!distCache[k]) distCache[k] = bfs(t);
      return distCache[k];
    }

    const OFFSETS = [
      [2, 1], [1, 2], [3, 2], [2, 3], [4, 1], [1, 4], [5, 3], [3, 5],
      [6, 2], [2, 6], [7, 4], [4, 7], [6, 6], [8, 3], [3, 8], [9, 5],
      [5, 9], [8, 8], [10, 4], [4, 10], [10, 8], [8, 10], [11, 6], [6, 11],
      [11, 11], [12, 9], [9, 12], [11, 10], [10, 11], [12, 6], [6, 12]
    ];

    const WAYPOINTS = [];
    const wpSeen = {};

    function addWp(ax, ay) {
      ax = clampC(ax);
      ay = clampC(ay);
      if (ax <= 0 || ax >= S - 1 || ay <= 0 || ay >= S - 1) return;
      const ii = idx(ax, ay);
      if (ii === baseIdx || ii === enemyBaseIdx) return;
      if (!wpSeen[ii]) {
        wpSeen[ii] = 1;
        WAYPOINTS.push({ x: ax, y: ay, i: ii });
      }
    }

    for (let oi = 0; oi < OFFSETS.length; oi++) {
      addWp(bx + sxDir * OFFSETS[oi][0], by + syDir * OFFSETS[oi][1]);
    }
    addWp(7, 7);

    if (!WAYPOINTS.length) addWp(bx + sxDir * 2, by + syDir * 2);
    if (!WAYPOINTS.length) addWp(7, 7);

    if (mem.wp < 0 || mem.wp >= WAYPOINTS.length) {
      mem.wp = (idHash + role) % WAYPOINTS.length;
    }

    function noise(a, b, c) {
      let v = (idHash * 131 + T * 97 + (a | 0) * 31 + (b | 0) * 17 + (c | 0) * 5) >>> 0;
      v = (v ^ (v >>> 11)) >>> 0;
      return v & 7;
    }

    if (mem.lastAct === 'идти' && mem.px === x && mem.py === y) {
      mem.stuck++;
    } else {
      mem.stuck = 0;
    }

    if (mem.prevHp > hp) mem.lastHitT = T;

    if (mem.stuck > 8) {
      mem.target = -1;
      mem.mode = 0;
      mem.wp = (mem.wp + 1) % WAYPOINTS.length;
      mem.stuck = 3;
    }

    if (carry) {
      mem.target = -1;
      mem.mode = 0;
    }

    if (!carry && mem.mode === 1) {
      if (mem.target < 0 || mem.target >= N || walls[mem.target] || expFood[mem.target] <= 0) {
        mem.target = -1;
        mem.mode = 0;
      } else if (distMe[mem.target] === 0) {
        mem.target = -1;
        mem.mode = 0;
      }
    }

    if (!carry && mem.mode === 2) {
      if (mem.target < 0 || mem.target >= N || walls[mem.target]) {
        mem.target = -1;
        mem.mode = 0;
      } else if (distMe[mem.target] === 0) {
        mem.target = -1;
        mem.mode = 0;
        mem.wp = (mem.wp + 1) % WAYPOINTS.length;
      }
    }

    if (mem.stuck > 5 && mem.mode !== 0) {
      mem.target = -1;
      mem.mode = 0;
      mem.wp = (mem.wp + 1) % WAYPOINTS.length;
      mem.stuck = 3;
    }

    function roleBonus(rx, ry) {
      if (rx < 0 || ry < 0) return 0;
      let b = 0;
      if (role === 0) {
        if (rx > ry) b -= 7;
        if (rx + ry <= 6) b -= 4;
      } else if (role === 1) {
        if (ry > rx) b -= 7;
        if (rx + ry <= 6) b -= 4;
      } else if (role === 2) {
        if (abs(rx - ry) <= 2) b -= 7;
        if (rx + ry >= 3 && rx + ry <= 9) b -= 3;
      } else {
        if (rx + ry >= 8) b -= 7;
        if (abs(rx - ry) <= 3) b -= 3;
      }
      return b;
    }

    function chooseAttackTarget() {
      let best = null;

      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (!inb(nx, ny)) continue;

        const ni = idx(nx, ny);
        if (!enemyVis[ni]) continue;

        const db = abs(nx - bx) + abs(ny - by);
        let score = 0;

        if (db <= 6) score -= 35;
        if (carry) score += 50;
        if (hp <= 1) score += 25;
        if (mem.lastHitT >= T - 1) score -= 15;
        if (foodAmt[ni] > 0) score -= 6;

        score += noise(ni, di, 11);

        if (!best || score < best.score) {
          best = { dir: d.n, i: ni, db: db };
        }
      }

      return best;
    }

    const atkInfo = chooseAttackTarget();

    function shouldAttack() {
      if (!atkInfo) return null;

      if (carry) {
        if (onBase) return null;
        if (hp >= 3 && enemyNearBaseVisible && dHome <= 1) return atkInfo.dir;
        return null;
      }

      if (hp <= 1) {
        if (enemyNearBaseVisible && dHome <= 2) return atkInfo.dir;
        return null;
      }

      if (mem.lastHitT >= T - 1 && hp >= 2) return atkInfo.dir;

      if (enemyNearBaseVisible) {
        if (dHome <= 3) return atkInfo.dir;
        if (role === 0 && dHome <= 6 && hp >= 2) return atkInfo.dir;
      }

      if (hp === 3 && visibleEnemies.length === 1 && dHome <= 6 && knownFoodTotal < 10 && rem > 20) {
        return atkInfo.dir;
      }

      return null;
    }

    function stepToward(target, opts) {
      opts = opts || {};
      if (target < 0 || target >= N || target === myIdx) return null;
      if (walls[target] && target !== baseIdx && target !== enemyBaseIdx) return null;

      const distT = getDist(target);
      const tx = target % S;
      const ty = (target / S) | 0;
      let best = null;

      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (!inb(nx, ny)) continue;

        const ni = idx(nx, ny);
        if (walls[ni]) continue;
        if (enemyVis[ni]) continue;
        if (allyVis[ni]) continue;
        if (ni === enemyBaseIdx && target !== enemyBaseIdx) continue;

        const nd = distT[ni];
        let score;
        if (nd >= 0) score = nd * 10;
        else score = (abs(nx - tx) + abs(ny - ty)) * 10 + 6;

        if (danger[ni]) score += opts.avoidDanger ? 70 : 25;
        if (enemyTime[ni] >= T - 8) score += 10;
        if (ni === baseIdx && target !== baseIdx) score += 20;
        if (opts.toBase && ni === baseIdx) score -= 30;
        if (ni === enemyBaseIdx) score += 40;
        if (mem.stuck > 0 && mem.lastDir === d.n) score += 18 + mem.stuck * 6;

        score += noise(ni, di, opts.seed || 0);

        if (!best || score < best.score) {
          best = { score: score, dir: d.n };
        }
      }

      return best ? best.dir : null;
    }

    function retreatStep() {
      let best = null;

      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (!inb(nx, ny)) continue;

        const ni = idx(nx, ny);
        if (walls[ni]) continue;
        if (enemyVis[ni]) continue;
        if (allyVis[ni]) continue;
        if (ni === enemyBaseIdx) continue;

        let minE = 99;
        for (let ve = 0; ve < visibleEnemies.length; ve++) {
          const e = visibleEnemies[ve];
          const ed = abs(nx - e.x) + abs(ny - e.y);
          if (ed < minE) minE = ed;
        }
        if (visibleEnemies.length === 0) minE = 10;

        const baseD = distBase[ni] >= 0 ? distBase[ni] : abs(nx - bx) + abs(ny - by);
        let score;

        if (visibleEnemies.length === 0) {
          score = baseD * (carry ? 3 : 1);
        } else {
          score = baseD * (carry ? 4 : 1) - Math.min(minE, 8) * (carry ? 12 : 18);
        }

        if (danger[ni]) score += carry ? 40 : 25;
        if (enemyTime[ni] >= T - 8) score += 8;
        if (ni === baseIdx && !carry) score += 12;
        if (ni === enemyBaseIdx) score += 50;
        if (mem.stuck > 0 && mem.lastDir === d.n) score += 18 + mem.stuck * 5;

        score += noise(ni, di, 4);

        if (!best || score < best.score) {
          best = { score: score, dir: d.n };
        }
      }

      return best ? best.dir : null;
    }

    function moveOffBase() {
      let best = null;

      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (!inb(nx, ny)) continue;

        const ni = idx(nx, ny);
        if (ni === baseIdx) continue;
        if (walls[ni]) continue;
        if (enemyVis[ni]) continue;
        if (allyVis[ni]) continue;
        if (ni === enemyBaseIdx) continue;

        const rx = (nx - bx) * sxDir;
        const ry = (ny - by) * syDir;
        const progress = rx + ry;

        let score = -progress * 15;
        if (progress <= 0) score += 30;

        if (role === 0 && rx === 1 && ry === 0) score -= 12;
        if (role === 1 && rx === 0 && ry === 1) score -= 12;
        if (role === 2 && rx === 1 && ry === 0) score -= 6;
        if (role === 3 && rx === 0 && ry === 1) score -= 6;

        if (danger[ni]) score += 50;
        if (enemyTime[ni] >= T - 8) score += 8;
        if (mem.stuck > 0 && mem.lastDir === d.n) score += 18 + mem.stuck * 5;

        score += noise(ni, di, 7);

        if (!best || score < best.score) {
          best = { score: score, dir: d.n };
        }
      }

      return best ? best.dir : null;
    }

    function wanderStep() {
      let best = null;

      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (!inb(nx, ny)) continue;

        const ni = idx(nx, ny);
        if (walls[ni]) continue;
        if (enemyVis[ni]) continue;
        if (allyVis[ni]) continue;
        if (ni === enemyBaseIdx) continue;

        let score = (abs(nx - 7) + abs(ny - 7)) * 4;
        if (ni === baseIdx) score += 25;
        if (danger[ni]) score += 40;
        if (enemyTime[ni] >= T - 8) score += 8;
        if (mem.stuck > 0 && mem.lastDir === d.n) score += 18 + mem.stuck * 5;

        score += noise(ni, di, 9);

        if (!best || score < best.score) {
          best = { score: score, dir: d.n };
        }
      }

      return best ? best.dir : null;
    }

    function dirToAdjacent(ii) {
      for (let di = 0; di < DIRS.length; di++) {
        const d = DIRS[di];
        const nx = x + d.dx;
        const ny = y + d.dy;
        if (inb(nx, ny) && idx(nx, ny) === ii && enemyVis[ii]) return d.n;
      }
      return null;
    }

    function chooseFoodTarget() {
      let best = -1;
      let bestScore = 1e9;

      for (let ii = 0; ii < N; ii++) {
        if (ii === baseIdx || ii === enemyBaseIdx || ii === myIdx) continue;
        if (walls[ii]) continue;
        if (enemyVis[ii] || allyVis[ii]) continue;

        const ef = expFood[ii];
        if (ef <= 0) continue;

        const dGo = distMe[ii];
        if (dGo < 0) continue;

        const dBack = distBase[ii];
        if (dBack < 0) continue;

        const round = dGo + dBack + 2;
        if (round > rem) {
          if (!(rem <= 8 && dGo + 1 <= rem)) continue;
        }

        let score = round * 4 + dGo - ef * 14;

        const oc = claimCount[ii];
        if (oc > 0) {
          if (oc >= ef) score += 45 + (oc - ef + 1) * 25;
          else score += oc * 10;
        }

        const fx = ii % S;
        const fy = (ii / S) | 0;

        for (let ve = 0; ve < visibleEnemies.length; ve++) {
          const e = visibleEnemies[ve];
          const fd = abs(fx - e.x) + abs(fy - e.y);
          if (fd <= 1) score += hp <= 1 ? 80 : 35;
          else if (fd <= 3) score += hp <= 1 ? 30 : 12;
        }

        if (danger[ii]) score += hp <= 1 ? 50 : 20;
        if (enemyTime[ii] >= T - 8) score += 12;

        const rx = (fx - bx) * sxDir;
        const ry = (fy - by) * syDir;
        score += roleBonus(rx, ry);

        if (mem.target === ii && mem.mode === 1 && T - mem.targetT < 12) score -= 14;
        if (mem.stuck > 2 && mem.target === ii) score += 30;
        if (round > rem) score += 80;

        score += noise(ii, 5, role);

        if (score < bestScore) {
          bestScore = score;
          best = ii;
        }
      }

      return best;
    }

    function chooseExploreTarget() {
      let best = -1;
      let bestScore = 1e9;

      for (let ii = 0; ii < N; ii++) {
        if (ii === baseIdx || ii === enemyBaseIdx || ii === myIdx) continue;
        if (walls[ii] || seen[ii]) continue;
        if (enemyVis[ii] || allyVis[ii]) continue;

        const d = distMe[ii];
        if (d < 0) continue;

        const db = distBase[ii];
        if (db < 0) continue;

        if (rem <= 30 && d + db + 2 > rem) continue;

        let score = d * 2 + 12 - Math.min(db, 12);

        const fx = ii % S;
        const fy = (ii / S) | 0;
        const rx = (fx - bx) * sxDir;
        const ry = (fy - by) * syDir;
        score += roleBonus(rx, ry);

        if (danger[ii]) score += 30;
        if (enemyTime[ii] >= T - 10) score += 10;
        if (mem.target === ii && mem.mode === 2 && T - mem.targetT < 8) score -= 10;
        if (mem.stuck > 2 && mem.target === ii) score += 25;

        score += noise(ii, 6, role);

        if (score < bestScore) {
          bestScore = score;
          best = ii;
        }
      }

      if (best >= 0) return best;

      let bestWi = -1;
      const len = WAYPOINTS.length;
      if (!len) return -1;

      const start = ((mem.wp | 0) + role * 3) % len;

      for (let k = 0; k < len; k++) {
        const wi = (start + k) % len;
        const w = WAYPOINTS[wi];
        const ii = w.i;

        if (ii === myIdx || ii === baseIdx || ii === enemyBaseIdx) continue;
        if (walls[ii] || enemyVis[ii] || allyVis[ii]) continue;

        const d = distMe[ii];
        if (d < 0) continue;

        const db = distBase[ii];
        if (db < 0) continue;

        if (rem <= 30 && d + db + 2 > rem) continue;

        let score = d * 2 + Math.min(db, 14);

        const rx = (w.x - bx) * sxDir;
        const ry = (w.y - by) * syDir;
        score += roleBonus(rx, ry);

        if (wi === mem.wp) score -= 6;
        if (claimCount[ii]) score += claimCount[ii] * 8;
        if (danger[ii]) score += 25;
        if (mem.target === ii && mem.mode === 2 && T - mem.targetT < 8) score -= 8;

        score += noise(wi, 7, role);

        if (score < bestScore) {
          bestScore = score;
          best = ii;
          bestWi = wi;
        }
      }

      if (bestWi >= 0) mem.wp = bestWi;
      return best;
    }

    let threatNearBase = enemyNearBaseVisible;
    if (!threatNearBase && threatI >= 0 && T - threatT <= 5) {
      const tx = threatI % S;
      const ty = (threatI / S) | 0;
      if (abs(tx - bx) + abs(ty - by) <= 7) threatNearBase = true;
    }

    let action = null;
    let clearTarget = false;
    let setTarget = -1;
    let setMode = 0;

    if (carry && onBase) {
      action = { тип: 'положить' };
    }

    if (!action && hp <= 1 && visibleEnemies.length > 0) {
      let minE = 99;
      for (let ve = 0; ve < visibleEnemies.length; ve++) {
        const e = visibleEnemies[ve];
        const ed = abs(x - e.x) + abs(y - e.y);
        if (ed < minE) minE = ed;
      }

      if (minE <= 2) {
        const st = retreatStep();
        if (st) {
          action = { тип: 'идти', куда: st };
          clearTarget = true;
        } else if (atkInfo && enemyNearBaseVisible && dHome <= 2) {
          action = { тип: 'бить', куда: atkInfo.dir };
          clearTarget = true;
        }
      }
    }

    if (!action && !carry && currentFood > 0) {
      const adj = atkInfo !== null;
      if (!adj || hp >= 2 || rem <= 6 || onBase) {
        action = { тип: 'взять' };
      }
    }

    if (!action) {
      const atk = shouldAttack();
      if (atk) {
        action = { тип: 'бить', куда: atk };
        clearTarget = true;
      }
    }

    if (!action && carry) {
      if (!onBase) {
        const dToBase = distBase[myIdx] >= 0 ? distBase[myIdx] : 99;

        if (dToBase === 1 && enemyVis[baseIdx]) {
          const adir = dirToAdjacent(baseIdx);
          if (adir && hp >= 2) {
            action = { тип: 'бить', куда: adir };
            clearTarget = true;
          }
        }

        if (!action && dToBase === 1 && allyVis[baseIdx]) {
          if (mem.stuck < 2 && ((idHash + T) % 4) !== 0) {
            action = { тип: 'ждать' };
          } else {
            const st = moveOffBase();
            if (st) action = { тип: 'идти', куда: st };
            else action = { тип: 'ждать' };
          }
        }

        if (!action) {
          let st = null;
          if (mem.stuck > 4) st = retreatStep();
          if (!st) st = stepToward(baseIdx, { avoidDanger: hp <= 2 || visibleEnemies.length > 0, toBase: true, seed: 5 });
          if (!st) st = retreatStep();

          if (st) {
            action = { тип: 'идти', куда: st };
          } else if (atkInfo && hp >= 2 && (enemyNearBaseVisible || mem.stuck > 2)) {
            action = { тип: 'бить', куда: atkInfo.dir };
            clearTarget = true;
          } else {
            action = { тип: 'ждать' };
          }
        }
      }
    }

    if (!action && !carry && hp >= 2 && threatNearBase) {
      let respond = false;
      if (role === 0) respond = true;
      else if (role === 1 && dHome <= 6) respond = true;
      else if (dHome <= 3) respond = true;

      if (respond) {
        let bestE = null;

        for (let ve = 0; ve < visibleEnemies.length; ve++) {
          const e = visibleEnemies[ve];
          const db = abs(e.x - bx) + abs(e.y - by);
          if (db <= 7) {
            const dme = distMe[e.i] >= 0 ? distMe[e.i] : 99;
            if (dme <= 7 && (!bestE || db < bestE.db || (db === bestE.db && dme < bestE.dme))) {
              bestE = { i: e.i, db: db, dme: dme };
            }
          }
        }

        if (!bestE && threatI >= 0) {
          const tx = threatI % S;
          const ty = (threatI / S) | 0;
          const db = abs(tx - bx) + abs(ty - by);
          const dme = distMe[threatI] >= 0 ? distMe[threatI] : 99;
          if (db <= 7 && dme <= 8) bestE = { i: threatI, db: db, dme: dme };
        }

        if (bestE) {
          const adir = dirToAdjacent(bestE.i);
          if (adir) {
            action = { тип: 'бить', куда: adir };
            clearTarget = true;
          } else {
            const st = stepToward(bestE.i, { avoidDanger: hp <= 2, seed: 6 });
            if (st) {
              action = { тип: 'идти', куда: st };
              clearTarget = true;
            }
          }
        }
      }
    }

    if (!action && !carry) {
      let target = chooseFoodTarget();
      if (target >= 0) {
        setTarget = target;
        setMode = 1;
      } else {
        target = chooseExploreTarget();
        if (target >= 0) {
          setTarget = target;
          setMode = 2;
        }
      }

      if (target >= 0 && target !== myIdx) {
        const avoid = hp <= 1 || visibleEnemies.length > 0;
        let st = stepToward(target, { avoidDanger: avoid, seed: 8 });
        if (!st) st = wanderStep();
        if (st) action = { тип: 'идти', куда: st };
      } else if (target === myIdx) {
        if (currentFood > 0) action = { тип: 'взять' };
        else clearTarget = true;
      }
    }

    if (!action && !carry && currentFood > 0) {
      action = { тип: 'взять' };
    }

    if (!action) {
      if (rem <= 10 && !carry && !onBase) {
        const st = stepToward(baseIdx, { avoidDanger: false, toBase: true, seed: 12 });
        if (st) {
          action = { тип: 'идти', куда: st };
          if (setTarget < 0) clearTarget = true;
        }
      }

      if (!action) {
        const st = onBase ? moveOffBase() : wanderStep();
        if (st) {
          action = { тип: 'идти', куда: st };
          if (setTarget < 0) clearTarget = true;
        } else {
          action = { тип: 'ждать' };
        }
      }
    }

    const DIR_NAMES = ['С', 'Ю', 'З', 'В'];
    if (!action || typeof action !== 'object') action = { тип: 'ждать' };
    if (action.тип === 'идти' && DIR_NAMES.indexOf(action.куда) < 0) action = { тип: 'ждать' };
    if (action.тип === 'бить' && DIR_NAMES.indexOf(action.куда) < 0) action = { тип: 'ждать' };
    if (
      action.тип !== 'идти' &&
      action.тип !== 'бить' &&
      action.тип !== 'взять' &&
      action.тип !== 'положить' &&
      action.тип !== 'ждать'
    ) {
      action = { тип: 'ждать' };
    }

    if (action.тип === 'взять') {
      if (currentFood > 0) {
        foodAmt[myIdx] = Math.max(0, currentFood - 1);
        foodTime[myIdx] = T;
      }
      clearTarget = true;
      setTarget = -1;
    }

    if (action.тип === 'положить' || action.тип === 'бить') {
      clearTarget = true;
      setTarget = -1;
    }

    let finalTarget = -1;
    let finalMode = 0;

    if (clearTarget) {
      finalTarget = -1;
      finalMode = 0;
    } else if (setTarget >= 0 && action.тип === 'идти') {
      finalTarget = setTarget;
      finalMode = setMode;
    } else if (!carry && mem.target >= 0 && mem.target < N && !walls[mem.target]) {
      if ((mem.mode === 1 && expFood[mem.target] > 0) || mem.mode === 2) {
        finalTarget = mem.target;
        finalMode = mem.mode;
      }
    }

    mem.target = finalTarget;
    mem.mode = finalMode;
    if (finalTarget >= 0 && setTarget >= 0) mem.targetT = T;

    const wb = [0, 0, 0, 0, 0, 0, 0, 0];
    const sm = [0, 0, 0, 0, 0, 0, 0, 0];

    for (let ii = 0; ii < N; ii++) {
      if (walls[ii]) wb[ii >> 5] = (wb[ii >> 5] | (1 << (ii & 31))) >>> 0;
      if (seen[ii]) sm[ii >> 5] = (sm[ii >> 5] | (1 << (ii & 31))) >>> 0;
    }

    const outF = [];
    for (let ii = 0; ii < N; ii++) {
      if (ii === baseIdx || ii === enemyBaseIdx) continue;
      const a = foodAmt[ii];
      const tt = foodTime[ii];
      if (a > 0 && T - tt <= 150) {
        outF.push([ii, a, tt]);
      } else if (a === 0 && T - tt <= 3) {
        outF.push([ii, 0, tt]);
      }
    }

    outF.sort(function (A, B) {
      if (A[1] !== B[1]) return B[1] - A[1];
      return B[2] - A[2];
    });

    if (outF.length > 45) outF.length = 45;

    const outE = [];
    for (let ii = 0; ii < N; ii++) {
      if (enemyTime[ii] >= T - 25) outE.push([ii, enemyTime[ii]]);
    }

    outE.sort(function (A, B) {
      return B[1] - A[1];
    });

    if (outE.length > 16) outE.length = 16;

    claims = claims.filter(function (cl) {
      const age = T - cl[2];
      return cl[0] !== idHash && age >= 0 && age <= 10;
    });

    if (!carry && finalMode === 1 && finalTarget >= 0 && finalTarget < N && !walls[finalTarget] && expFood[finalTarget] > 0) {
      claims.push([idHash, finalTarget, T]);
    }

    if (claims.length > 10) claims = claims.slice(claims.length - 10);

    let outThT = threatT;
    let outThI = threatI;

    if (enemyNearBaseVisible) {
      let best = null;
      for (let ve = 0; ve < visibleEnemies.length; ve++) {
        const e = visibleEnemies[ve];
        const db = abs(e.x - bx) + abs(e.y - by);
        if (!best || db < best.db) best = { i: e.i, db: db };
      }
      if (best) {
        outThT = T;
        outThI = best.i;
      }
    } else if (T - outThT > 8) {
      outThT = -9999;
      outThI = -1;
    }

    const outCommon = {
      v: VERSION,
      wb: wb,
      sm: sm,
      f: outF,
      e: outE,
      c: claims,
      thT: outThT,
      thI: outThI
    };

    const outMem = {
      t: mem.target,
      tt: mem.targetT,
      m: mem.mode,
      w: mem.wp,
      s: mem.stuck,
      la: action.тип,
      ld: action.тип === 'идти' ? action.куда : '',
      px: x,
      py: y,
      hp: hp,
      ht: mem.lastHitT
    };

    return {
      действие: action,
      память: outMem,
      общая: outCommon
    };
  } catch (err) {
    return {
      действие: { тип: 'ждать' },
      память: {},
      общая: { v: 10 }
    };
  }
}

function решить(в) {
  const SIZE = 15;
  const total = в.всего_ходов || 150;
  const turn = в.ход;
  const me = в.я;
  const myBase = в.моя_база;
  const enemyBase = в.чужая_база;
  const myIdx = me.y * SIZE + me.x;
  const baseIdx = myBase.y * SIZE + myBase.x;
  const enemyBaseIdx = enemyBase.y * SIZE + enemyBase.x;

  function hash(s) {
    const str = String(s);
    let h = 0;
    for (let i = 0; i < str.length; i++) {
      h = (h * 31 + str.charCodeAt(i)) % 100000;
    }
    return h;
  }
  const idHash = Math.abs(hash(me.id));
  const rank = idHash % 4;

  const commonIn = (в.общая && typeof в.общая === 'object') ? в.общая : {};
  const common = {};
  for (const k of Object.keys(commonIn)) common[k] = commonIn[k];

  const seen = new Set();
  const walls = new Set();
  const food = {};
  const foodSeen = {};
  let ants = {};

  if (Array.isArray(common.v)) {
    for (const v of common.v) {
      const n = Number(v);
      if (Number.isFinite(n)) seen.add(n);
    }
  }
  if (Array.isArray(common.w)) {
    for (const v of common.w) {
      const n = Number(v);
      if (Number.isFinite(n)) walls.add(n);
    }
  }
  if (common.f && typeof common.f === 'object') {
    for (const k of Object.keys(common.f)) {
      const idx = Number(k);
      const val = Number(common.f[k]);
      if (Number.isFinite(idx) && Number.isFinite(val) && val > 0) food[idx] = val;
    }
  }
  if (common.fs && typeof common.fs === 'object') {
    for (const k of Object.keys(common.fs)) {
      const idx = Number(k);
      const val = Number(common.fs[k]);
      if (Number.isFinite(idx) && Number.isFinite(val)) foodSeen[idx] = val;
    }
  }
  if (common.ants && typeof common.ants === 'object') {
    for (const k of Object.keys(common.ants)) {
      if (common.ants[k] && typeof common.ants[k] === 'object') ants[k] = common.ants[k];
    }
  }

  const visibleEnemies = [];
  const enemySet = new Set();
  const visibleOwnPos = new Set();

  for (const cell of в.видно) {
    const idx = cell.y * SIZE + cell.x;
    if (idx < 0 || idx >= SIZE * SIZE) continue;
    seen.add(idx);

    if (cell.что === 'стена') {
      walls.add(idx);
      delete food[idx];
      delete foodSeen[idx];
    } else {
      walls.delete(idx);
      if (typeof cell.еда === 'number') {
        if (cell.еда > 0) {
          food[idx] = cell.еда;
          foodSeen[idx] = turn;
        } else {
          delete food[idx];
          delete foodSeen[idx];
        }
      }
      if (cell.что === 'враг') {
        visibleEnemies.push(cell);
        enemySet.add(idx);
      }
      if (cell.что === 'свой') {
        if (idx !== myIdx) visibleOwnPos.add(idx);
      }
    }
  }

  const ownBlock = new Set();
  for (const pos of visibleOwnPos) ownBlock.add(pos);

  for (const id of Object.keys(ants)) {
    if (id === me.id) continue;
    const o = ants[id];
    if (!o || !Number.isFinite(Number(o.x)) || !Number.isFinite(Number(o.y))) continue;
    const ts = Number(o.ts);
    if (ts && ts < turn - 12) continue;
    const idx = Number(o.y) * SIZE + Number(o.x);
    if (idx >= 0 && idx < SIZE * SIZE && !walls.has(idx)) ownBlock.add(idx);
  }
  ownBlock.delete(myIdx);

  function getNeighbors(idx) {
    const x = idx % SIZE;
    const y = Math.floor(idx / SIZE);
    const arr = [];
    if (y > 0) arr.push(idx - SIZE);
    if (y < SIZE - 1) arr.push(idx + SIZE);
    if (x > 0) arr.push(idx - 1);
    if (x < SIZE - 1) arr.push(idx + 1);
    return arr;
  }

  function bfs(start, extraBlock) {
    const dist = new Array(SIZE * SIZE).fill(-1);
    dist[start] = 0;
    const q = [];
    q.push(start);
    for (let head = 0; head < q.length; head++) {
      const cur = q[head];
      for (const n of getNeighbors(cur)) {
        if (walls.has(n)) continue;
        if (extraBlock && extraBlock.has(n)) continue;
        if (dist[n] === -1) {
          dist[n] = dist[cur] + 1;
          q.push(n);
        }
      }
    }
    return dist;
  }

  function manhattan(a, b) {
    const ax = a % SIZE;
    const ay = Math.floor(a / SIZE);
    const bx = b % SIZE;
    const by = Math.floor(b / SIZE);
    return Math.abs(ax - bx) + Math.abs(ay - by);
  }

  function directionBetween(a, b) {
    const ax = a % SIZE;
    const ay = Math.floor(a / SIZE);
    const bx = b % SIZE;
    const by = Math.floor(b / SIZE);
    if (by < ay) return 'С';
    if (by > ay) return 'Ю';
    if (bx < ax) return 'З';
    if (bx > ax) return 'В';
    return null;
  }

  function getDir(start, target, extraBlock) {
    if (start === target) return null;
    const dist = bfs(start, extraBlock);
    if (dist[target] <= 0) return null;
    let cur = target;
    let prev = null;
    while (cur !== start) {
      let found = false;
      for (const n of getNeighbors(cur)) {
        if (dist[n] === dist[cur] - 1) {
          prev = cur;
          cur = n;
          found = true;
          break;
        }
      }
      if (!found) return null;
    }
    return directionBetween(start, prev);
  }

  const distMeAll = bfs(myIdx, null);
  const distBaseAll = bfs(baseIdx, null);
  const distEnemyAll = bfs(enemyBaseIdx, null);

  const curVis = в.видно.find(c => c.x === me.x && c.y === me.y);
  const groundHere = (curVis && typeof curVis.еда === 'number') ? curVis.еда : 0;

  function getAdjEnemies() {
    const res = [];
    for (const e of visibleEnemies) {
      const eIdx = e.y * SIZE + e.x;
      if (manhattan(myIdx, eIdx) === 1) res.push(e);
    }
    return res;
  }

  function enemyCellHasFood(e) {
    return (typeof e.еда === 'number' && e.еда > 0);
  }

  function chooseEnemyForAttack(enemies) {
    let best = null;
    let bestScore = -Infinity;
    for (const e of enemies) {
      const eIdx = e.y * SIZE + e.x;
      const dBase = distBaseAll[eIdx] >= 0 ? distBaseAll[eIdx] : manhattan(eIdx, baseIdx);
      const dEnemy = distEnemyAll[eIdx] >= 0 ? distEnemyAll[eIdx] : manhattan(eIdx, enemyBaseIdx);
      let score = -dBase * 10;
      if (enemyCellHasFood(e)) score += 20;
      if (dBase < dEnemy) score += 15;
      if (score > bestScore) {
        bestScore = score;
        best = e;
      }
    }
    return best;
  }

  function countOwnNear(eIdx, radius) {
    let cnt = 1;
    for (const pos of ownBlock) {
      if (manhattan(pos, eIdx) <= radius) cnt++;
    }
    return cnt;
  }

  function shouldAttackAdjacent(e) {
    if (me.здоровье <= 1) return false;
    const eIdx = e.y * SIZE + e.x;
    const dBaseCurrent = distBaseAll[myIdx] >= 0 ? distBaseAll[myIdx] : manhattan(myIdx, baseIdx);
    const dBaseEnemy = distBaseAll[eIdx] >= 0 ? distBaseAll[eIdx] : manhattan(eIdx, baseIdx);
    const inOurHalf = distBaseAll[eIdx] >= 0 && distEnemyAll[eIdx] >= 0 && distBaseAll[eIdx] < distEnemyAll[eIdx];
    const enemyNearBase = dBaseEnemy <= 6;
    const meNearBase = dBaseCurrent <= 4;
    if (meNearBase || enemyNearBase) return true;
    if (enemyCellHasFood(e) && inOurHalf) return true;
    if (inOurHalf && me.здоровье >= 3 && countOwnNear(eIdx, 2) >= 2) return true;
    if (turn > total * 0.75 && inOurHalf) return true;
    return false;
  }

  function moveBlock(full) {
    const block = new Set(enemySet);
    if (me.здоровье <= 1) {
      for (const e of visibleEnemies) {
        const eIdx = e.y * SIZE + e.x;
        for (const n of getNeighbors(eIdx)) block.add(n);
      }
    }
    if (full) {
      for (const pos of ownBlock) block.add(pos);
    }
    return block;
  }

  const centers = [
    { x: 7, y: 7 },
    { x: 3, y: 3 },
    { x: 3, y: 8 },
    { x: 8, y: 3 }
  ];
  const myCenter = centers[rank];

  function isOtherTarget(idx) {
    for (const id of Object.keys(ants)) {
      if (id === me.id) continue;
      const o = ants[id];
      if (!o) continue;
      const ts = Number(o.ts);
      if (ts && ts < turn - 12) continue;
      if (Number(o.t) === idx) return true;
    }
    return false;
  }

  function isOwnOccupied(idx) {
    return ownBlock.has(idx);
  }

  function chooseFoodTarget() {
    const timeLeft = total - turn;
    const candidates = [];

    for (const k of Object.keys(food)) {
      const idx = Number(k);
      const amount = Number(food[k]);
      if (!Number.isFinite(amount) || amount <= 0) continue;
      if (walls.has(idx)) continue;
      if (enemySet.has(idx)) continue;
      if (isOwnOccupied(idx)) continue;

      const dMe = distMeAll[idx];
      if (dMe < 0) continue;
      const dBase = distBaseAll[idx];
      const dEnemy = distEnemyAll[idx] >= 0 ? distEnemyAll[idx] : manhattan(idx, enemyBaseIdx);
      if (dBase < 0) continue;

      const trip = dMe + dBase;
      const rel = dEnemy - dBase;
      let score = amount * 45 - trip * 15;

      if (rel < 0) {
        score -= 20 + (-rel) * 5;
      } else {
        score += Math.min(15, rel * 3);
      }

      const zx = idx % SIZE;
      const zy = Math.floor(idx / SIZE);
      score -= (Math.abs(zx - myCenter.x) + Math.abs(zy - myCenter.y)) * 1.5;

      if (foodSeen[idx] && turn - foodSeen[idx] > 25) score -= 35;
      if (isOtherTarget(idx)) score -= 50;

      for (const e of visibleEnemies) {
        const eIdx = e.y * SIZE + e.x;
        const md = manhattan(idx, eIdx);
        if (md <= 2) score -= (3 - md) * 20;
      }

      if (timeLeft < trip + 3) {
        if (timeLeft < dMe + 3) {
          score -= 250;
        } else {
          score = amount * 20 - dMe * 8 + Math.min(10, rel * 2);
        }
      }

      candidates.push({ idx, dMe, amount, score });
    }

    if (!candidates.length) return null;
    candidates.sort((a, b) => (b.score - a.score) || (a.dMe - b.dMe) || (a.idx - b.idx));
    const pick = Math.abs(idHash) % Math.min(3, candidates.length);
    return candidates[pick].idx;
  }

  function chooseExploreTarget() {
    const candidates = [];

    for (let idx = 0; idx < SIZE * SIZE; idx++) {
      if (seen.has(idx) || walls.has(idx)) continue;
      if (distMeAll[idx] < 0) continue;
      if (enemySet.has(idx) || isOwnOccupied(idx)) continue;
      if (isOtherTarget(idx)) continue;

      const d = distMeAll[idx];
      const zx = idx % SIZE;
      const zy = Math.floor(idx / SIZE);
      const dBase = distBaseAll[idx] >= 0 ? distBaseAll[idx] : manhattan(idx, baseIdx);
      const dEnemy = distEnemyAll[idx] >= 0 ? distEnemyAll[idx] : manhattan(idx, enemyBaseIdx);
      const inOurHalfPenalty = dBase <= dEnemy ? 0 : 25;

      let danger = 0;
      for (const e of visibleEnemies) {
        const eIdx = e.y * SIZE + e.x;
        const md = manhattan(idx, eIdx);
        if (md <= 2) danger += (3 - md) * 15;
      }

      const zoneDist = Math.abs(zx - myCenter.x) + Math.abs(zy - myCenter.y);
      const score = d * 7 + zoneDist * 3 + inOurHalfPenalty + danger + (Math.abs(idHash + idx) % 17);
      candidates.push({ idx, d, score });
    }

    if (!candidates.length) return null;
    candidates.sort((a, b) => a.score - b.score || a.d - b.d || a.idx - b.idx);
    const pick = Math.abs(idHash) % Math.min(4, candidates.length);
    return candidates[pick].idx;
  }

  function attackEnemy(e) {
    const eIdx = e.y * SIZE + e.x;
    const dir = directionBetween(myIdx, eIdx);
    return dir ? { тип: 'бить', куда: dir } : null;
  }

  let action = null;
  let target = null;

  if (me.груз > 0 && myIdx === baseIdx) {
    action = { тип: 'положить' };
    target = null;
    common.score = (Number(common.score) || 0) + 1;
  }

  if (!action && me.груз > 0) {
    const adjEnemies = getAdjEnemies();
    if (adjEnemies.length > 0 && me.здоровье >= 2) {
      const e = chooseEnemyForAttack(adjEnemies);
      if (e) {
        const eIdx = e.y * SIZE + e.x;
        const enemyNearBase = (distBaseAll[eIdx] >= 0 ? distBaseAll[eIdx] : manhattan(eIdx, baseIdx)) <= 5;
        const meNearBase = (distBaseAll[myIdx] >= 0 ? distBaseAll[myIdx] : manhattan(myIdx, baseIdx)) <= 3;
        if (enemyNearBase || meNearBase) {
          const att = attackEnemy(e);
          if (att) {
            action = att;
            target = null;
          }
        }
      }
    }

    if (!action) {
      let dir = getDir(myIdx, baseIdx, moveBlock(true));
      if (!dir) dir = getDir(myIdx, baseIdx, moveBlock(false));
      if (!dir) dir = getDir(myIdx, baseIdx, new Set(enemySet));
      if (!dir) dir = getDir(myIdx, baseIdx, new Set());
      action = dir ? { тип: 'идти', куда: dir } : { тип: 'ждать' };
    }
  }

  if (!action && me.груз === 0) {
    const adjEnemies = getAdjEnemies();

    if (groundHere > 0) {
      if (!(adjEnemies.length > 0 && me.здоровье === 1)) {
        action = { тип: 'взять' };
        target = null;
      }
    }

    if (!action && me.здоровье === 1 && adjEnemies.length > 0) {
      let dir = getDir(myIdx, baseIdx, moveBlock(true));
      if (!dir) dir = getDir(myIdx, baseIdx, moveBlock(false));
      if (dir) {
        action = { тип: 'идти', куда: dir };
        target = null;
      }
    }

    if (!action && adjEnemies.length > 0) {
      const e = chooseEnemyForAttack(adjEnemies);
      if (e && shouldAttackAdjacent(e)) {
        const att = attackEnemy(e);
        if (att) {
          action = att;
          target = null;
        }
      }
    }

    if (!action && rank === 0 && me.здоровье >= 3 && turn < total - 30) {
      let bestEnemy = null;
      let bestScore = -Infinity;

      for (const e of visibleEnemies) {
        const eIdx = e.y * SIZE + e.x;
        const md = manhattan(myIdx, eIdx);
        if (md < 2 || md > 3) continue;

        const dBaseE = distBaseAll[eIdx] >= 0 ? distBaseAll[eIdx] : manhattan(eIdx, baseIdx);
        const dEnemyE = distEnemyAll[eIdx] >= 0 ? distEnemyAll[eIdx] : manhattan(eIdx, enemyBaseIdx);
        const inOurHalf = dBaseE < dEnemyE || dBaseE <= 6;
        if (!inOurHalf) continue;

        const sc = -md * 12 + (enemyCellHasFood(e) ? 15 : 0) - dBaseE * 2;
        if (sc > bestScore) {
          bestScore = sc;
          bestEnemy = e;
        }
      }

      if (bestEnemy) {
        const eIdx = bestEnemy.y * SIZE + bestEnemy.x;
        let adjTarget = null;
        let adjDist = Infinity;

        for (const n of getNeighbors(eIdx)) {
          if (walls.has(n) || enemySet.has(n) || ownBlock.has(n)) continue;
          const nd = distMeAll[n];
          if (nd >= 0 && nd < adjDist) {
            adjDist = nd;
            adjTarget = n;
          }
        }

        if (adjTarget !== null) {
          const dir = getDir(myIdx, adjTarget, moveBlock(true));
          if (dir) {
            target = adjTarget;
            action = { тип: 'идти', куда: dir };
          }
        }
      }
    }

    if (!action) {
      const foodTarget = chooseFoodTarget();
      if (foodTarget !== null) {
        let dir = getDir(myIdx, foodTarget, moveBlock(true));
        if (!dir) dir = getDir(myIdx, foodTarget, moveBlock(false));
        if (!dir) dir = getDir(myIdx, foodTarget, new Set(enemySet));
        if (dir) {
          target = foodTarget;
          action = { тип: 'идти', куда: dir };
        }
      }
    }

    if (!action) {
      const exploreTarget = chooseExploreTarget();
      if (exploreTarget !== null) {
        let dir = getDir(myIdx, exploreTarget, moveBlock(true));
        if (!dir) dir = getDir(myIdx, exploreTarget, moveBlock(false));
        if (!dir) dir = getDir(myIdx, exploreTarget, new Set(enemySet));
        if (dir) {
          target = exploreTarget;
          action = { тип: 'идти', куда: dir };
        }
      }
    }

    if (!action) {
      let dir = getDir(myIdx, baseIdx, moveBlock(true));
      if (!dir) dir = getDir(myIdx, baseIdx, moveBlock(false));
      if (!dir) dir = getDir(myIdx, baseIdx, new Set());
      action = dir ? { тип: 'идти', куда: dir } : { тип: 'ждать' };
    }
  }

  if (!action) {
    action = { тип: 'ждать' };
  }

  ants[me.id] = {
    x: me.x,
    y: me.y,
    h: me.здоровье,
    c: me.груз,
    t: target,
    ts: turn
  };

  const shared = {
    v: Array.from(seen).slice(0, 400),
    w: Array.from(walls).slice(0, 400),
    f: food,
    fs: foodSeen,
    ants: ants,
    score: (Number(common.score) || 0)
  };

  return {
    действие: action,
    память: в.память || {},
    общая: shared
  };
}