output_description: Print the image surrounded by a box that consists of `#` and has a thickness
  of 1.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      a_{11} ... a_{1W}
      :
      a_{H1} ... a_{HW}
attempt: import sys
  import math
  import collections
  import itertools
  import array
  import inspect
  
  # Set max recursion limit
  sys.setrecursionlimit(1000000)
  
  
  # Debug output
  def chkprint(*args):
      names = {id(v): k for k, v in inspect.currentframe().f_back.f_locals.items()}
      print(", ".join(names.get(id(arg), "???") + " = " + repr(arg) for arg in args))
  
  
  # Binary converter
  def to_bin(x):
      return bin(x)[2:]
  
  
  def li_input():
      return [int(_) for _ in input().split()]
  
  
  def gcd(n, m):
      if n % m == 0:
          return m
      else:
          return gcd(m, n % m)
  
  
  def gcd_list(L):
      v = L[0]
  
      for i in range(1, len(L)):
          v = gcd(v, L[i])
  
      return v
  
  
  def lcm(n, m):
      return (n * m) // gcd(n, m)
  
  
  def lcm_list(L):
      v = L[0]
  
      for i in range(1, len(L)):
          v = lcm(v, L[i])
  
      return v
  
  
  # Width First Search (+ Distance)
  def wfs_d(D, N, K):
      """
      D: 隣接行列(距離付き)
      N: ノード数
      K: 始点ノード
      """
  
      dfk = [-1] * (N + 1)
      dfk[K] = 0
  
      cps = [(K, 0)]
      r = [False] * (N + 1)
      r[K] = True
      while len(cps) != 0:
          n_cps = []
          for cp, cd in cps:
              for i, dfcp in enumerate(D[cp]):
                  if dfcp != -1 and not r[i]:
                      dfk[i] = cd + dfcp
                      n_cps.append((i, cd + dfcp))
                      r[i] = True
  
          cps = n_cps[:]
  
      return dfk
  
  
  # Depth First Search (+Distance)
  def dfs_d(v, pre, dist):
      """
      v:  現在のノード
      pre: １つ前のノード
      dist: 現在の距離
  
      以下は別途用意する
      D: 隣接リスト(行列ではない)
      D_dfs_d: dfs_d関数で用いる，始点ノードから見た距離リスト
      """
  
      global D
      global D_dfs_d
  
      D_dfs_d[v] = dist
  
      for next_v, d in D[v]:
          if next_v != pre:
              dfs_d(next_v, v, dist + d)
  
      return
  
  
  def sigma(N):
      ans = 0
      for i in range(1, N + 1):
          ans += i
      return ans
  
  
  class Combination:
      def __init__(self, n, mod):
  
          g1 = [1, 1]
          g2 = [1, 1]
          inverse = [0, 1]
          for i in range(2, n + 1):
              g1.append((g1[-1] * i) % mod)
              inverse.append((-inverse[mod % i] * (mod // i)) % mod)
              g2.append((g2[-1] * inverse[-1]) % mod)
          self.MOD = mod
          self.N = n
          self.g1 = g1
          self.g2 = g2
          self.inverse = inverse
  
      def __call__(self, n, r):
          if r < 0 or r > n:
              return 0
          r = min(r, n - r)
          return self.g1[n] * self.g2[r] * self.g2[n - r] % self.MOD
  
  
  # --------------------------------------------
  
  dp = None
  
  
  def main():
      H, W = li_input()
      S = [input() for _ in range(H)]
  
      print("#" * (W + 2))
      for s in S:
          print("#{}#".format(s))
      print("#" * (W + 2))
  
  
  main()
  
problem_description: Statement
  
  You are given a image with a height of H pixels and a width of W pixels. Each
  pixel is represented by a lowercase English letter. The pixel at the i-th row
  from the top and j-th column from the left is a_{ij}.
  
  Put a box around this image and output the result. The box should consist of
  `#` and have a thickness of 1.
samples: [{"input": "2 3\n    abc\n    arc", "output": "#####\n    #abc#\n    #arc#\n    #####\n    \n\n* * *"}, {"input": "1 1\n    z", "output": "###\n    #z#\n    ###"}]