import sys
from collections import deque

def encode(board_lines):
    """将4行字符串编码为16位整数状态"""
    state = 0
    for i in range(4):
        for j in range(4):
            if board_lines[i][j] == '1':
                state |= 1 << (i * 4 + j)
    return state

def bidirectional_bfs(start, target):
    """双向BFS返回最短步数"""
    if start == target:
        return 0
    
    # 距离数组，-1表示未访问
    dist_start = [-1] * 65536
    dist_target = [-1] * 65536
    dist_start[start] = 0
    dist_target[target] = 0
    
    q_start = deque([start])
    q_target = deque([target])
    
    while q_start and q_target:
        # 从较小的队列开始扩展一层
        if len(q_start) <= len(q_target):
            for _ in range(len(q_start)):
                s = q_start.popleft()
                d = dist_start[s]
                # 生成所有可能的邻居状态
                for p in range(16):
                        # 与右侧棋子交换（不在最右列时）
                        if p % 4 != 3:
                            nb = p + 1
                            # 只交换值不同的相邻棋子
                            if ((s >> p) & 1) != ((s >> nb) & 1):
                                t = s ^ (1 << p) ^ (1 << nb)
                                if dist_start[t] == -1:
                                    dist_start[t] = d + 1
                                    if dist_target[t] != -1:
                                        return dist_start[t] + dist_target[t]
                                    q_start.append(t)
                        # 与下方棋子交换（不在最下行时）
                        if p < 12:
                            nb = p + 4
                            if ((s >> p) & 1) != ((s >> nb) & 1):
                                t = s ^ (1 << p) ^ (1 << nb)
                                if dist_start[t] == -1:
                                    dist_start[t] = d + 1
                                    if dist_target[t] != -1:
                                        return dist_start[t] + dist_target[t]
                                    q_start.append(t)
        else:
            for _ in range(len(q_target)):
                s = q_target.popleft()
                d = dist_target[s]
                for p in range(16):
                    if p % 4 != 3:
                        nb = p + 1
                        if ((s >> p) & 1) != ((s >> nb) & 1):
                            t = s ^ (1 << p) ^ (1 << nb)
                            if dist_target[t] == -1:
                                dist_target[t] = d + 1
                                if dist_start[t] != -1:
                                    return dist_start[t] + dist_target[t]
                                q_target.append(t)
                    if p < 12:
                        nb = p + 4
                        if ((s >> p) & 1) != ((s >> nb) & 1):
                            t = s ^ (1 << p) ^ (1 << nb)
                            if dist_target[t] == -1:
                                dist_target[t] = d + 1
                                if dist_start[t] != -1:
                                    return dist_start[t] + dist_target[t]
                                q_target.append(t)
    return -1  # 理论上应该总是可达

def main():
    # 读取输入，跳过空行
    lines = [line.strip() for line in sys.stdin if line.strip() != '']
    # 前4行为初始棋盘，后4行为目标棋盘
    init_lines = lines[:4]
    target_lines = lines[4:8]
    
    start_state = encode(init_lines)
    target_state = encode(target_lines)
    
    answer = bidirectional_bfs(start_state, target_state)
    print(answer)

if __name__ == "__main__":
    main()

python3才行