docs: def challenge(arg: ChallengeArg) -> dict:
      """ Response is dict like `Trial` because Status(OwlEnum) can't be pickled.
      """
  
      name: str = arg.req.name.get_or(str(arg.seq))
      log_prefix = f"[{arg.seq} / {arg.number_of_request}]"
  
      logger.info_lv3(f"{log_prefix} {'-'*80}")
      logger.info_lv3(f"{log_prefix}  {arg.seq}. {arg.req.name.get_or(arg.req.path)}")
      logger.info_lv3(f"{log_prefix} {'-'*80}")
  
      path_str_one = arg.path_one.map(lambda x: re.sub(x.before, x.after, arg.req.path)).get_or(arg.req.path)
      path_str_other = arg.path_other.map(lambda x: re.sub(x.before, x.after, arg.req.path)).get_or(arg.req.path)
      qs_str_one = create_query_string(arg.req.qs, arg.query_one, arg.req.url_encoding)
      qs_str_other = create_query_string(arg.req.qs, arg.query_other, arg.req.url_encoding)
      url_one = f'{arg.host_one}{path_str_one}?{qs_str_one}'
      url_other = f'{arg.host_other}{path_str_other}?{qs_str_other}'
  
      # Get two responses
      req_time = now()
      try:
          logger.info_lv3(f"{log_prefix} One   URL:   {url_one}")
          logger.debug(f"{log_prefix} One   PROXY: {arg.proxy_one.map(lambda x: x.to_dict()).get()}")
          logger.info_lv3(f"{log_prefix} Other URL:   {url_other}")
          logger.debug(f"{log_prefix} Other PROXY: {arg.proxy_other.map(lambda x: x.to_dict()).get()}")
          r_one, r_other = concurrent_request(arg.session, arg.req.headers,
                                              url_one, url_other,
                                              arg.proxy_one, arg.proxy_other)
          logger.info_lv3(
              f"{log_prefix} One:   {r_one.status_code} / {to_sec(r_one.elapsed)}s / {len(r_one.content)}b / {r_one.headers.get('content-type')}" # noqa
          )
          logger.info_lv3(
              f"{log_prefix} Other: {r_other.status_code} / {to_sec(r_other.elapsed)}s / {len(r_other.content)}b / {r_other.headers.get('content-type')}" # noqa
          )
      except ConnectionError:
          logger.info_lv1(f"{log_prefix} 💀 {arg.req.name.get()}")
          # TODO: Integrate logic into create_trial
          return {
              "seq": arg.seq,
              "name": name,
              "tags": [],
              "request_time": req_time.isoformat(),
              "status": 'failure',
              "path": arg.req.path,
              "queries": arg.req.qs,
              "headers": arg.req.headers,
              "one": {
                  "url": url_one,
                  "type": "unknown",
              },
              "other": {
                  "url": url_other,
                  "type": "unknown",
              }
          }
  
      res_one: Response = res2res(Response.from_requests(r_one, arg.default_response_encoding_one), arg.req)
      res_other: Response = res2res(Response.from_requests(r_other, arg.default_response_encoding_other), arg.req)
  
      dict_one: TOption[dict] = res2dict(res_one)
      dict_other: TOption[dict] = res2dict(res_other)
  
      # Create diff
      # Either dict_one or dic_other is None, it means that it can't be analyzed, therefore return None
      ddiff = None if dict_one.is_none() or dict_other.is_none() \
          else {} if res_one.body == res_other.body \
          else DeepDiff(dict_one.get(), dict_other.get())
  
      initial_diffs_by_cognition: Optional[TDict[DiffKeys]] = TDict({
          "unknown": DiffKeys.from_dict({
              "changed": TList(ddiff.get('type_changes', {}).keys() | ddiff.get('values_changed', {}).keys())
                  .map(to_jumeaux_xpath)
                  .order_by(_),
              "added": TList(ddiff.get('dictionary_item_added', {}) | ddiff.get('iterable_item_added', {}).keys())
                  .map(to_jumeaux_xpath)
                  .order_by(_),
              "removed": TList(ddiff.get('dictionary_item_removed', {}) | ddiff.get('iterable_item_removed', {}).keys())
                  .map(to_jumeaux_xpath)
                  .order_by(_)
          })
      }) if ddiff is not None else None
  
      # Judgement
      status, diffs_by_cognition = judgement(res_one, res_other, dict_one, dict_other,
                                             name, arg.req.path, arg.req.qs, arg.req.headers, initial_diffs_by_cognition)
      status_symbol = "O" if status == Status.SAME else "X"
      log_msg = f"{log_prefix} {status_symbol} ({res_one.status_code} - {res_other.status_code}) <{res_one.elapsed_sec}s - {res_other.elapsed_sec}s> {arg.req.name.get_or(arg.req.path)}"  # noqa
      (logger.info_lv2 if status == Status.SAME else logger.info_lv1)(log_msg)
  
      file_one: Optional[str] = None
      file_other: Optional[str] = None
      prop_file_one: Optional[str] = None
      prop_file_other: Optional[str] = None
      if store_criterion(status, name, arg.req, res_one, res_other):
          dir = f'{arg.res_dir}/{arg.key}'
          file_one = f'one/({arg.seq}){name}'
          file_other = f'other/({arg.seq}){name}'
          write_to_file(file_one, dir, dump(res_one))
          write_to_file(file_other, dir, dump(res_other))
          if not dict_one.is_none():
              prop_file_one = f'one-props/({arg.seq}){name}.json'
              write_to_file(prop_file_one, dir, TDict(dict_one.get()).to_json().encode('utf-8', errors='replace'))
          if not dict_other.is_none():
              prop_file_other = f'other-props/({arg.seq}){name}.json'
              write_to_file(prop_file_other, dir, TDict(dict_other.get()).to_json().encode('utf-8', errors='replace'))
  
      return global_addon_executor.apply_did_challenge(
          DidChallengeAddOnPayload.from_dict({
              "trial": Trial.from_dict({
                  "seq": arg.seq,
                  "name": name,
                  "tags": [], # TODO: tags created by reqs2reqs
                  "request_time": req_time.isoformat(),
                  "status": status,
                  "path": arg.req.path,
                  "queries": arg.req.qs,
                  "headers": arg.req.headers,
                  "diffs_by_cognition": diffs_by_cognition,
                  "one": {
                      "url": res_one.url,
                      "type": res_one.type,
                      "status_code": res_one.status_code,
                      "byte": res_one.byte,
                      "response_sec": res_one.elapsed_sec,
                      "content_type": res_one.content_type,
                      "mime_type": res_one.mime_type,
                      "encoding": res_one.encoding,
                      "file": file_one,
                      "prop_file": prop_file_one,
                  },
                  "other": {
                      "url": res_other.url,
                      "type": res_other.type,
                      "status_code": res_other.status_code,
                      "byte": res_other.byte,
                      "response_sec": res_other.elapsed_sec,
                      "content_type": res_other.content_type,
                      "mime_type": res_other.mime_type,
                      "encoding": res_other.encoding,
                      "file": file_other,
                      "prop_file": prop_file_other,
                  }
              })
          }),
          DidChallengeAddOnReference.from_dict({
              "res_one": res_one,
              "res_other": res_other,
              "res_one_props": dict_one,
              "res_other_props": dict_other,
          })
      ).trial.to_dict()