

"""simple docstring"""


import json
import sys




def  _lowercase					(    __lowerCAmelCase  ,					__lowerCAmelCase							)       ->				List[str]:



      with open(lowerCamelCase_  ,					encoding="""utf-8"""							) as f:
            SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	json.load(lowerCamelCase_							)

      SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	["""<details>""", """<summary>Show updated benchmarks!</summary>""", """ """]

      for benchmark_name in sorted(lowerCamelCase_							):
            SCREAMING_SNAKE_CASE__   :      str      		=	results[benchmark_name]

            SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	benchmark_name.split("""/"""							)[-1]
            output_md.append(F'''### Benchmark: {benchmark_file_name}'''							)

            SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	"""| metric |"""
            SCREAMING_SNAKE_CASE__   :      Dict      		=	"""|--------|"""
            SCREAMING_SNAKE_CASE__   :      int      		=	"""| new / old (diff) |"""
            for metric_name in sorted(lowerCamelCase_							):
                  SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	benchmark_res[metric_name]
                  SCREAMING_SNAKE_CASE__   :      Tuple      		=	metric_vals["""new"""]
                  SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	metric_vals.get("""old"""  ,					lowerCamelCase_							)
                  SCREAMING_SNAKE_CASE__   :      Tuple      		=	metric_vals.get("""diff"""  ,					lowerCamelCase_							)

                  SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	F''' {new_val:f}''' if isinstance(lowerCamelCase_  ,					(int, float)							) else """None"""

                  if old_val is not None:
                        val_str += F''' / {old_val:f}''' if isinstance(lowerCamelCase_  ,					(int, float)							) else "None"
                  if dif_val is not None:
                        val_str += F''' ({dif_val:f})''' if isinstance(lowerCamelCase_  ,					(int, float)							) else "None"

                  title += " " + metric_name + " |"
                  lines += "---|"
                  value += val_str + " |"

            output_md += [title, lines, value, " "]

      output_md.append("""</details>"""							)

      with open(lowerCamelCase_  ,					"""w"""  ,					encoding="""utf-8"""							) as f:
            f.writelines("""\n""".join(lowerCamelCase_							)							)


if __name__ == "__main__":
  a					:Dict    = sys.argv[1]
  a					:Any    = sys.argv[2]

  format_json_to_md(input_json_file, output_md_file)







"""simple docstring"""


def  _lowercase					(    __lowerCAmelCase  ,					__lowerCAmelCase							)       ->				bool:
      SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	len(__lowerCAmelCase							) + 1
      SCREAMING_SNAKE_CASE__   :      int      		=	len(__lowerCAmelCase							) + 1

      # dp is a 2d matrix where dp[i][j] denotes whether prefix string of
      # length i of input_string matches with prefix string of length j of
      # given pattern.
      # "dp" stands for dynamic programming.
      SCREAMING_SNAKE_CASE__   :      Dict      		=	[[0 for i in range(__lowerCAmelCase							)] for j in range(__lowerCAmelCase							)]

      # since string of zero length match pattern of zero length
      SCREAMING_SNAKE_CASE__   :      Dict      		=	1

      # since pattern of zero length will never match with string of non-zero length
      for i in range(1  ,					__lowerCAmelCase							):
            SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	0

      # since string of zero length will match with pattern where there
      # is at least one * alternatively
      for j in range(1  ,					__lowerCAmelCase							):
            SCREAMING_SNAKE_CASE__   :      int      		=	dp[0][j - 2] if pattern[j - 1] == """*""" else 0

      # now using bottom-up approach to find for all remaining lengths
      for i in range(1  ,					__lowerCAmelCase							):
            for j in range(1  ,					__lowerCAmelCase							):
                  if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
                        SCREAMING_SNAKE_CASE__   :      Any      		=	dp[i - 1][j - 1]

                  elif pattern[j - 1] == "*":
                        if dp[i][j - 2] == 1:
                              SCREAMING_SNAKE_CASE__   :      List[str]      		=	1
                        elif pattern[j - 2] in (input_string[i - 1], "."):
                              SCREAMING_SNAKE_CASE__   :      List[Any]      		=	dp[i - 1][j]
                        else:
                              SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	0
                  else:
                        SCREAMING_SNAKE_CASE__   :      Dict      		=	0

      return bool(dp[-1][-1]							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  # inputing the strings
  # input_string = input("input a string :")
  # pattern = input("input a pattern :")

  a					:Any    = "aab"
  a					:Optional[Any]    = "c*a*b"

  # using function to check whether given string matches the given pattern
  if match_pattern(input_string, pattern):
    print(f'{input_string} matches the given pattern {pattern}')
  else:
    print(f'{input_string} does not match with the given pattern {pattern}')




