from dataclasses import dataclass
from typing import Optional


def part_1(data):
    elf_count = int(data)

    elves = [i for i in range(1, elf_count + 1)]
    while len(elves) > 1:
        is_odd = len(elves) % 2 == 1
        elves = [elves[i] for i in range(0, len(elves), 2)]
        if is_odd and len(elves) > 1:
            elves = elves[1:]
    print(elves[0])


def part_2(data):
    elf_count = int(data)
    power_3 = 3
    while power_3 * 3 < elf_count:
        power_3 *= 3
    elf_count -= power_3
    print(elf_count)


def main():
    data = open(0).read().strip()
    part_1(data)
    part_2(data)


if __name__ == "__main__":
    main()


def part_2_naiv(data):
    @dataclass
    class Elf:
        id: int
        prev: Optional["Elf"]
        next: Optional["Elf"]

        def delete(self):
            if self.prev is not None:
                self.prev.next = self.next
            if self.next is not None:
                self.next.prev = self.prev
            self.prev = None
            self.next = None

        def all(self):
            elf = self
            elves = [elf]
            while elf.next is not None and elf.next.id != self.id:
                elf = elf.next
                elves.append(elf)
            return elves

        def forward(self, n):
            current = self
            for _ in range(n):
                assert current.next is not None
                current = current.next
                assert current.id != self.id
            return current

        def __repr__(self):
            assert self.prev is not None and self.next is not None
            return f"{self.prev.id} <- {self.id} -> {self.next.id}"

    elf_count = int(data)
    # elf_count = 5
    elves = [Elf(i, None, None) for i in range(1, elf_count + 1)]
    for i in range(len(elves)):
        elves[i].prev = elves[(i - 1) % len(elves)]
        elves[i].next = elves[(i + 1) % len(elves)]

    remaining_elves = elf_count
    current_elf = elves[0]
    while remaining_elves > 1:
        assert current_elf is not None
        # print(current_elf.all())
        current_elf.forward(remaining_elves // 2).delete()
        current_elf = current_elf.next
        remaining_elves -= 1
    assert current_elf is not None
    print(current_elf.id)