#종료 조건
def Check():
    global N
    for y in range(N):
        for x in range(N):
            # visited 배열에 -1이 아닌 값이 있는경우는 False 반환
            if visited[y][x] != -1: return False
    #visited 배열이 전부 -1인경우, True 반환
    return True

def IsSafe(y,x):
    return 0<=y<N and 0<=x<N


def BFS(init_y, init_x):
    global L, R

    Q = []
    #연합을 넣을 배열 선언
    union_sub_lst = []
    visited[init_y][init_x] = 1
    Q.append([init_y, init_x])
    union_sub_lst.append([init_y, init_x])

    while Q:
        y, x = Q.pop(0)
        for dir in range(4):
            n_y = y + dy[dir]
            n_x = x + dx[dir]
            #맵을 벗어나지않고, 연합 조건을 만족시키며, 방문하지 않은 칸인 경우
            if IsSafe(n_y, n_x) and L <= abs(MyMap[y][x] - MyMap[n_y][n_x]) <= R and visited[n_y][n_x] <= 0:
                visited[n_y][n_x] = 1
                Q.append([n_y, n_x]) #Queue에 append
                union_sub_lst.append([n_y, n_x]) #연합 배열에 추가

    # 연합 배열의 길이가 1 => 어디로도 이동하지 못한 경우
    if len(union_sub_lst) == 1:
        visited[init_y][init_x] = -1 #visited를 -1으로 선언
        return
    #그렇지 않은 경우는 전체 연합 배열에 현재의 연합배열을 append
    union_lst.append(union_sub_lst)


N, L, R = map(int, input().split())
MyMap = [list(map(int, input().split())) for _ in range(N)]

#상, 하, 좌, 우
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]


cnt = 0
while True:
    visited = [[0] * N for _ in range(N)]
    #연합 "들(복수형)" 을 넣을 배열 선언
    union_lst = []
    for y in range(N):
        for x in range(N):
            if visited[y][x] <= 0:
                BFS(y, x)

    #완탐이 끝난 이후, MyMap 값 업데이트. union_lst 내에는 각 하위 연합에 대한 배열이 존재함
    if union_lst:
        #하위 연합 배열에 대한 반복문
        for i in range(len(union_lst)):
            #하위 연합 길이
            MyLen = len(union_lst[i])
            #하위 연합의 총 합 계산
            MySum = 0
            for j in union_lst[i]:
                MySum += MyMap[j[0]][j[1]]
                visited[j[0]][j[1]] = 1

            #하위 연합별 평균값을 구한 후, MyMap내 값 업데이트
            avg = int(MySum // MyLen)
            for j in union_lst[i]:
                MyMap[j[0]][j[1]] = avg

    #반복문 종료 조건. visited 배열이 전부 -1 인 경우(더이상 연합 생성 불가) while문 종료
    if Check():
        break
    cnt += 1

print(cnt)

# 종료 조건
def Check(y,x):
    # 맵 밖을 벗어나거나, 자기자신의 몸과 부딪히는 경우
    if y < 0  or y >= N or x < 0 or x >= N or MyMap[y][x] == 1:
        return True
    return False

N = int(input())
K = int(input())
MyMap = [[0]*N for _ in range(N)]

for i in range(K):
    y,x = map(int, input().split())
    MyMap[y-1][x-1] = 2
MyMap[0][0] = 1

L = int(input())
Time_Table = [-1] * 10000
for _ in range(L):
    idx, turn = input().split()
    idx = int(idx)
    if turn == 'L': turn = 0
    else: turn = 1
    Time_Table[idx] = turn

# 상 하 좌 우
dy = [-1, 1, 0, 0]
dx = [0, 0, -1, 1]

# 상 -> L:좌 / D: 우
# 하 -> L:우 / D: 좌
# 좌 -> L:하 / D: 상
# 우 -> L:상 / D: 하
direction = [[2, 3], [3, 2], [1, 0], [0, 1]]

current_dir_idx, time, y, x = 3, 0, 0, 0
snack = [[0,0]]
# 꼬리~머리 순서

while True:

    time += 1
    n_y = y + dy[current_dir_idx]
    n_x = x + dx[current_dir_idx]

    # 종료 조건 검증
    if Check(n_y, n_x):
        break

    # 사과가 있는 경우 => 꼬리 위치 불변 & 사과 좌표 값을 뱀으로 변경(좌표 추가)
    if MyMap[n_y][n_x] == 2:
        MyMap[n_y][n_x] = 1
        snack.append([n_y, n_x])

    # 사과가 없는 경우 => 꼬리 좌표 제거 & 이동한 좌표 추가
    elif MyMap[n_y][n_x] == 0:
        MyMap[n_y][n_x] = 1
        snack.append([n_y, n_x])
        delete_y, delete_x = snack.pop(0)
        MyMap[delete_y][delete_x] = 0
    # 시간 증가, 기준 좌표값 업데이트

    y, x = n_y, n_x

    # 시간이 끝난 후, 방향 전환 검증 & 방향 전환
    if Time_Table[time] != -1:
        current_dir_idx = direction[current_dir_idx][Time_Table[time]]

print(time)

def Find_Set(x):
    if x == Parent[x]:
        return x
    else:
        return Find_Set(Parent[x])

def Union(x,y):
    Parent[Find_Set(y)] = Find_Set(x)

TC = int(input())
for tc in range(1, TC+1):
    N, M = map(int, input().split())
    Parent = [0]*(N+1)

    for i in range(1, N+1):
        Parent[i] = i

    Init_Data = list(map(int, input().split()))
    for i in range(M):
        start = Init_Data[2*i]
        end = Init_Data[2*i+1]
        Union(start, end)

    # print(Parent)

    result = []
    for i in range(len(Parent)):
        result.append(Find_Set(i))

    print('#%d %d'%(tc, len(set(result))-1))

from collections import deque

def BFS():
    global start_num, end_num, result, tc
    while Q:
        num, cnt = Q.popleft()
        if num == end_num:
            result = cnt
            return

        for i in range(4):
            num2 = 0
            if i == 0:
                num2 = num + 1
                if 0 < num2 <= 1000000 and num_lst[num2] != tc:
                    Q.append((num2, cnt+1))
                    num_lst[num2] = tc

            elif i == 1:
                num2 = num - 1
                if 0 < num2 <= 1000000 and num_lst[num2] != tc:
                    Q.append((num2, cnt+1))
                    num_lst[num2] = tc

            elif i == 2:
                num2 = num*2
                if 0 < num2 <= 1000000 and num_lst[num2] != tc:
                    Q.append((num2, cnt+1))
                    num_lst[num2] = tc

            elif i == 3:
                num2 = num - 10
                if 0 < num2 <= 1000000 and num_lst[num2] != tc:
                    Q.append((num2, cnt+1))
                    num_lst[num2] = tc

TC = int(input())
num_lst = [0] * 1000001
for tc in range(1, TC+1):
    start_num, end_num = map(int, input().split())
    Q = deque()
    Q.append((start_num, 0))
    num_lst[start_num] = tc
    result = 0
    BFS()
    print('#%d %d'%(tc, result))