In a 1 million by 1 million grid, the coordinates of each grid square are (x, y) with 0 <= x, y < 10^6.
We start at the source square and want to reach the target square.  Each move, we can walk to a 4-directionally adjacent square in the grid that isn't in the given list of blocked squares.
Return true if and only if it is possible to reach the target square through a sequence of moves.
 
Example 1:
Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
Output: false
Explanation: 
The target square is inaccessible starting from the source square, because we can't walk outside the grid.

Example 2:
Input: blocked = [], source = [0,0], target = [999999,999999]
Output: true
Explanation: 
Because there are no blocked cells, it's possible to reach the target square.

 
Note:

0 <= blocked.length <= 200
blocked[i].length == 2
0 <= blocked[i][j] < 10^6
source.length == target.length == 2
0 <= source[i][j], target[i][j] < 10^6
source != target

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "'''\nUsing BFS\n\nIdea and Facts\n\nAnother Reference:\nhttps://leetcode.com/problems/escape-a-large-maze/discuss/282870/python-solution-with-picture-show-my-thoughts\nhttps://assets.leetcode.com/users/2017111303/image_1556424333.png\n\nFAQ\nQuestion I think the maximum area is 10000?\nAnswer\nThe maximum area is NOT 10000. Even it's accepted with bound 10000, it's WRONG.\nThe same, the bfs with just block.size steps, is also wrong.\n\nIn the following case, the area is 19900.\nThe sum of the area available equals 1+2+3+4+5+...+198+199=(1+199)*199/2=19900 (trapezoid sum) --> Area = B*(B-1)/2\nX -> blocking points\n\n0th      _________________________\n         |O O O O O O O X\n         |O O O O O O X\n         |O O O O O X\n         |O O O O X\n         .O O O X\n         .O O X\n         .O X\n200th    |X\n\nQuestion I think the maximum area is area of a sector.\nAnswer\nAll cells are discrete, so there is nothing to do with pi.\n\n\nQuestion What is the maximum area?\nAnswer\nIt maximum blocked is achieved when the blocked squares,\nsurrounding one of the corners as a 45-degree straight line.\n\nAnd it's easily proved.\n\nIf two cells are connected horizontally,\nwe can slide one part vertically to get bigger area.\n\nIf two cells are connected vertically,\nwe can slide one part horizontally to get bigger area.\n\n\nQuestion Can we apply a BFS?\nAnswer\nYes, it works.\nBFS in 4 directions need block.length * 2 as step bounds,\nBFS in 8 directions need block.length as step bounds.\n\nIt needs to be noticed that,\nThe top voted BFS solution is WRONG with bound,\nthough it's accpected by Leetcode.\n\nBut compared with the complexity:\nSearching with limited area is O(0.5B*B).\nBFS with steps can be O(2B^B).\n\n\nIntuition\nSimple search will get TLE, because the big search space.\nAnyway, we don't need to go further to know if we are blocked or not.\nBecause the maximum area blocked are 19900.\n\n\nExplanation\nSearch from source to target,\nif find, return true;\nif not find, return false;\nif reach 20000 steps, return true.\n\nThen we do the same thing searching from target to source.\n\nComplexity\nTime complexity depends on the size of blocked\nThe maximum area blocked are B * (B - 1) / 2.\nAs a result, time and space complexity are both O(B^2)\nIn my solution I used a fixed upper bound 20000.\n'''\nclass Solution:\n    def isEscapePossible(self, blocked: List[List[int]], source: List[int], target: List[int]) -> bool:\n        \n        blocked = set(map(tuple, blocked))\n        dirs = [(0,1), (1,0), (0,-1), (-1,0)]\n        \n        def bfs(s, t):\n            bfsQ = [tuple(s)]\n            visited = {tuple(s)}\n            areaSum = 0\n            \n            for x, y in bfsQ:\n                for i,j in dirs:\n                    r = x+i\n                    c = y+j\n                    \n                    if 0 <= r < 10**6 and 0 <= c < 10**6 and (r,c) not in visited and (r,c) not in blocked:\n                        if (r,c) == tuple(t):\n                            return True\n                        bfsQ.append((r,c))\n                        visited.add((r,c))\n                        \n                if len(bfsQ) >= 20000: # max block area upper bound\n                    return True\n            \n            return False\n    \n        return bfs(source, target) and bfs(target, source)"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'isEscapePossible'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 6796