if (n == 1) { // 1칸짜리 일 경우
				sb.append(Math.max(sticker[0][0], sticker[1][0]) + "\n");
				continue;
			}

			else { // 2칸 이상인 경우
				dp[0][0] = sticker[0][0];
				dp[1][0] = sticker[1][0];

				dp[0][1] = dp[1][0] + sticker[0][1];
				dp[1][1] = dp[0][0] + sticker[1][1];

				for (int i = 2; i < n; i++) { // dp 계산
					for (int j = 0; j < 2; j++) {
						dp[j][i] += Math.max(dp[(j * -1) + 1][i - 1], dp[(j * -1) + 1][i - 2]);
						dp[j][i] += sticker[j][i];
					}
				}

				sb.append(Math.max(dp[0][n - 1], dp[1][n - 1]) + "\n");
			}

static long pow(long a, int b) { // 큰 수 제곱 방식 활용
		if (b == 0)
			return 1;
		long half = pow(a, b / 2);
		long result = (half * half) % MOD;
		if (b % 2 == 1)
			result = (result * a) % MOD;
		return result;
	}

static String topostfix(String str) {
		StringBuilder sb = new StringBuilder();
		Stack<Character> stack = new Stack<>();

		for (char c : str.toCharArray()) {
			if (isAlphabet(c)) { // 알파벳이면 바로 입력
				sb.append(c);
			} else if (c == '(') { // 여는 괄호 나오면 스택에 저장
				stack.push(c);
			} else if (c == ')') { // 닫는 괄호 나오면
				while (!stack.isEmpty() && stack.peek() != '(') { // 여는 괄호 전까지
					sb.append(stack.pop()); // 스택에서 빼서 입력
				}
				stack.pop();
			} else if (isOperater(c)) { // 연산자인 경우
				while (!stack.isEmpty() && priority(stack.peek()) >= priority(c)) {
					sb.append(stack.pop()); // 스택에 들어있는 연산자가 현재 연산자보다 우선순위가 높으면 스택에서 꺼내서 입력
				}
				stack.push(c); // 연산자를 스택에 저장
			}
		}

		while (!stack.isEmpty()) {
			sb.append(stack.pop()); // 나머지 연산자 후위표기로 입력
		}

		return sb.toString();
	}

	static boolean isAlphabet(char c) { // 알파벳 대문자가 숫자 대용이므로 판단
		return c - 'A' >= 0 && c - 'A' <= 26;
	}

	static boolean isOperater(char c) { // 연산자인지 판단
		return c == '*' || c == '/' || c == '+' || c == '-';
	}

	static int priority(char c) { // 연산자 우선순위 판단
		if (c == '+' || c == '-')
			return 1;
		if (c == '/' || c == '*')
			return 2;
		return 0;
	}

static void bfs() {
		Queue<Cell> list = new ArrayDeque<>();
		list.add(new Cell(0, 0, 0));
		visited[0][0][0] = true;
		int step = 1;

		while (!list.isEmpty()) {
			int size = list.size();
			for (int s = 0; s < size; s++) {
				Cell cur = list.poll();
				if (cur.y == n - 1 && cur.x == m - 1) {
					System.out.println(step);
					return;
				}
				for (int d = 0; d < 4; d++) {
					int dy = cur.y + dir[d][0];
					int dx = cur.x + dir[d][1];
					if (dy >= 0 && dy < n && dx >= 0 && dx < m) {
						if (map[dy][dx] == 1 && cur.wall == 0 && !visited[dy][dx][1]) {
							visited[dy][dx][1] = true;
							list.add(new Cell(dy, dx, 1));
						} else if (map[dy][dx] == 0 && !visited[dy][dx][cur.wall]) {
							visited[dy][dx][cur.wall] = true;
							list.add(new Cell(dy, dx, cur.wall));
						}
					}
				}
			}
			step++;
		}
		System.out.println("-1");
	}

static void bfs() { // bfs처럼 탐색하면서 찾기
		while (!list.isEmpty()) {
			Node cur = list.poll();
			if (visited[cur.x])
				continue;
			visited[cur.x] = true;

			if (cur.x == k) {
				System.out.println(cur.time);
				return;
			}
			int dx = cur.x * 2;
			if (dx <= 100000 && !visited[dx]) {
				list.add(new Node(dx, cur.time));
			}
			dx = cur.x - 1;
			if (dx >= 0 && !visited[dx]) {
				list.add(new Node(dx, cur.time + 1));
			}
			dx = cur.x + 1;
			if (dx <= 100000 && !visited[dx]) {
				list.add(new Node(dx, cur.time + 1));
			}
		}
	}