output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
attempt: #!usr/bin/env python3
  from collections import defaultdict
  from collections import deque
  from heapq import heappush, heappop
  import sys
  import math
  import bisect
  import random
  import itertools
  
  sys.setrecursionlimit(10**5)
  stdin = sys.stdin
  
  
  def LI():
      return list(map(int, stdin.readline().split()))
  
  
  def LF():
      return list(map(float, stdin.readline().split()))
  
  
  def LI_():
      return list(map(lambda x: int(x) - 1, stdin.readline().split()))
  
  
  def II():
      return int(stdin.readline())
  
  
  def IF():
      return float(stdin.readline())
  
  
  def LS():
      return list(map(list, stdin.readline().split()))
  
  
  def S():
      return list(stdin.readline().rstrip())
  
  
  def IR(n):
      return [II() for _ in range(n)]
  
  
  def LIR(n):
      return [LI() for _ in range(n)]
  
  
  def FR(n):
      return [IF() for _ in range(n)]
  
  
  def LFR(n):
      return [LI() for _ in range(n)]
  
  
  def LIR_(n):
      return [LI_() for _ in range(n)]
  
  
  def SR(n):
      return [S() for _ in range(n)]
  
  
  def LSR(n):
      return [LS() for _ in range(n)]
  
  
  mod = 1000000007
  
  
  # A
  def A():
      n = II()
      print("ABC" + str(n))
      return
  
  
  # B
  def B():
      ni = [2**i for i in range(1, 10)]
      n = II()
      ans = 1
      for i in range(1, n + 1):
          if i in ni:
              ans = i
      print(ans)
      return
  
  
  # C
  def C():
      return
  
  
  # D
  def D():
      return
  
  
  # E
  def E():
      return
  
  
  # F
  def F():
      return
  
  
  # G
  def G():
      return
  
  
  # H
  def H():
      return
  
  
  # Solve
  if __name__ == "__main__":
      A()
  
problem_description: Statement
  
  Takahashi loves numbers divisible by 2.
  
  You are given a positive integer N. Among the integers between 1 and N
  (inclusive), find the one that can be divisible by 2 for the most number of
  times. The solution is always unique.
  
  Here, the number of times an integer can be divisible by 2, is how many times
  the integer can be divided by 2 without remainder.
  
  For example,
  
    * 6 can be divided by 2 once: 6 -> 3.
    * 8 can be divided by 2 three times: 8 -> 4 -> 2 -> 1.
    * 3 can be divided by 2 zero times.
samples: [{"input": "7", "output": "4\n    \n\n4 can be divided by 2 twice, which is the most number of times among 1, 2,\n..., 7.\n\n* * *"}, {"input": "32", "output": "32\n    \n\n* * *"}, {"input": "1", "output": "1\n    \n\n* * *"}, {"input": "100", "output": "64"}]