diff --git a/AutoCoverTool/online/inference_one.py b/AutoCoverTool/online/inference_one.py
index d1cde10..22f3b71 100644
--- a/AutoCoverTool/online/inference_one.py
+++ b/AutoCoverTool/online/inference_one.py
@@ -1,713 +1,713 @@
 """
 单个处理的逻辑
 song_id:
     ---src.mp3                              // 源数据，需要提前放进去
     ---cache
         ---vocal.wav                            // 分离之后产生
         ---acc.wav                              // 分离之后产生
         ---vocal_32.wav                         // 分离之后产生
         ---song_id_sp1.wav                      // 合成之后产生
         ---song_id_sp2.wav                      // 合成之后产生
         ---song_id_sp2_d.wav                    // 降噪之后生成
         ---song_id_sp2_dv.wav                   // 降噪+拉伸之后产生 [占比太高的不产生]
         ---song_id_sp2_dve442.wav               // 手动调整之后产生
         ---song_id_sp2_dve442_replace.wav       // 替换之后产生
         ---song_id_sp2_dve442_replace_mix.wav   // 人声+伴奏混合之后产生
     ---song_id
         --acc.mp3                           // 44k双声道320k
         --vocal.mp3                         // 44k双声道320k
         --src.mp3                           // 44k双声道320k
         --song_id_sp2_dv.mp3                // 44k单声道320k
     ---song_id_out                          // 对外输出
         --src.mp3                           // 原始音频
         --song_id_sp2_dv_replace_mix.mp3    // 制作完成的音频
 
 环境安装:
 conda create -n auto_song_cover  python=3.9
 # 安装demucs环境[进入到ref.music_remover 执行pip install -r requirements.txt]
 # 安装so_vits_svc环境[进入到ref.so_vits_svc 执行pip install -r requirements.txt]
 pip install librosa
 pip install scikit-maad
 pip install praat-parselmouth
 pip install matplotlib
 pip install torchvision
 pip install madmom
 pip install torchstat
 环境设置:
 export PATH=$PATH:/data/gpu_env_common/env/bin/ffmpeg/bin
 export PYTHONPATH=$PWD:$PWD/ref/music_remover/demucs:$PWD/ref/so_vits_svc:$PWD/ref/split_dirty_frame
 """
 
 import os
 import time
 import shutil
 import random
 import logging
 import librosa
 
 logging.basicConfig(filename='/tmp/inference.log', level=logging.INFO)
 
 gs_err_code_success = 0
 gs_err_code_no_src_mp3 = 1
 gs_err_code_separate = 2
 gs_err_code_trans_32 = 3
 gs_err_code_encode_err = 4
 gs_err_code_replace_err = 5
 gs_err_code_replace_trans_err = 6
 gs_err_code_mix_err = 7
 gs_err_code_mix_transcode_err = 8
 gs_err_code_no_src_dir = 9
 gs_err_code_volume_err = 10
 gs_err_code_trans2_442 = 11
 gs_err_code_reverb = 12
 gs_err_code_no_good_choice = 13
 gs_err_code_preprocess_vocal = 14
 gs_err_code_replace_except_err = 15
 
 gs_denoise_exe = "/opt/soft/bin/denoise_exe"
 gs_draw_volume_exe = "/opt/soft/bin/draw_volume"
 gs_simple_mixer_path = "/opt/soft/bin/simple_mixer"
 gs_rever_path = "/opt/soft/bin/dereverbrate"
 
 from ref.music_remover.separate_interface import SeparateInterface
 from ref.so_vits_svc.inference_main import *
 from ref.split_dirty_frame.script.process_one import ReplaceVocalFrame, construct_power_fragment
 
 
 class SongCoverInference:
     def __init__(self):
         self.work_dir = None
         self.cache_dir = None
         self.cid = None
         self.src_mp3 = None
         self.vocal_path = None
         self.vocal_32_path = None
         self.acc_path = None
         self.speakers = [
             10414574138721494,
             10414574140317353,
             1688849864840588,
             3634463651,
             5629499489839033,
             5910973794723621,
             6755399374234747,
             8162774327817435,
             8162774329368194,
             1125899914308640,  # 以下为男声,包括这个
             12384898975368914,
             12947848931397021,
             3096224748076687,
             3096224751151928,
             5066549357604730,
             5348024335101054,
             6755399442719465,
             7036874421386111
         ]
 
         self.speakers2gender = {
             10414574138721494: 2,
             10414574140317353: 2,
             1688849864840588: 2,
             3634463651: 2,
             5629499489839033: 2,
             5910973794723621: 2,
             6755399374234747: 2,
             8162774327817435: 2,
             8162774329368194: 2,
             1125899914308640: 1,  # 1是男
             12384898975368914: 1,
             12947848931397021: 1,
             3096224748076687: 1,
             3096224751151928: 1,
             5066549357604730: 1,
             5348024335101054: 1,
             6755399442719465: 1,
             7036874421386111: 1
         }
         self.speakers_model_path = "data/train_users/{}/logs/32k/G_2000.pth"
         self.speakers_model_config = "data/train_users/{}/config/config.json"
 
         st = time.time()
         self.separate_inst = None
         logging.info("post process ... ReplaceVocalFrame init sp={}".format(time.time() - st))
         self.replace_vocal_frame_inst = None
         logging.info("SongCoverInference init sp={}".format(time.time() - st))
 
     def separate(self, cid, src_mp3, vocal_path, acc_path):
         """
         人声伴奏分离
         :param cid:
         :param src_mp3:
         :param vocal_path:
         :param acc_path:
         :return:
         """
         st = time.time()
         if self.separate_inst is None:
             self.separate_inst = SeparateInterface()
         if not self.separate_inst.process(cid, src_mp3, vocal_path, acc_path):
             return gs_err_code_separate
         if not os.path.exists(vocal_path) or not os.path.exists(acc_path):
             return gs_err_code_separate
 
         # 转码出一个32k单声道的数据
         cmd = "ffmpeg -i {} -ar 32000 -ac 1 -y {} -loglevel fatal".format(vocal_path, self.vocal_32_path)
         os.system(cmd)
         if not os.path.exists(self.vocal_32_path):
             return gs_err_code_trans_32
         print("separate:cid={}|sp={}".format(cid, time.time() - st))
         return gs_err_code_success
 
     def get_start_ms(self, vocal_path):
         """
         给定原始音频，找一段连续10s的音频
         :param vocal_path:
         :return:
         """
         audio, sr = librosa.load(vocal_path, sr=16000)
         audio = librosa.util.normalize(audio)
         # 帧长100ms,帧移10ms,计算能量
         power_arr = []
         for i in range(0, len(audio) - 1600, 160):
             power_arr.append(np.sum(np.abs(audio[i:i + 160])) / 160)
             # 将能量小于等于10的部分做成段
         power_arr = construct_power_fragment(power_arr)
         fragments = []
         last_pos = 0
         for idx, line in enumerate(power_arr):
             start = round(float(line[0]) * 0.01, 3)
             duration = round(float(line[1]) * 0.01, 3)
             fragments.append([last_pos, start - last_pos])
             last_pos = start + duration
         if last_pos < len(audio) / sr:
             fragments.append([last_pos, len(audio) / sr - last_pos])
 
         # 合并数据，两者间隔在50ms以内的合并起来
         idx = 0
         while idx < len(fragments) - 1:
             if fragments[idx + 1][0] - (fragments[idx][0] + fragments[idx][1]) < 0.05:
                 fragments[idx][1] = fragments[idx + 1][0] + fragments[idx + 1][1] - fragments[idx][0]
                 del fragments[idx + 1]
                 idx -= 1
             idx += 1
 
         # out_file = vocal_path + "_power.csv"
         # with open(out_file, "w") as f:
         #     f.write("Name\tStart\tDuration\tTime Format\tType\n")
         #     for fragment in fragments:
         #         start = round(float(fragment[0]), 3)
         #         duration = round(float(fragment[1]), 3)
         #         strr = "{}\t{}\t{}\t{}\n".format("11", start, duration, "decimal\tCue\t")
         #         f.write(strr)
 
         # 筛选出开始的位置
         # 1. 连续时长大于10s，当前段长度大于3s
         # 2. 不可用
         # 从0到fragments[idx], 包含idx其中人声段的总和
         tot_vocal_duration = [fragments[0][1]]
         for i in range(1, len(fragments)):
             tot_vocal_duration.append(tot_vocal_duration[i - 1] + fragments[i][1])
 
         # 计算出任意两段之间非人声占比
         for i in range(0, len(fragments)):
             if fragments[i][1] >= 3:
                 now_tot = 0
                 if i > 0:
                     now_tot = tot_vocal_duration[i - 1]
                 for j in range(i + 1, len(fragments)):
                     cur_rate = tot_vocal_duration[j] - now_tot
                     cur_rate = cur_rate / (fragments[j][1] + fragments[j][0] - fragments[i][0])
                     if cur_rate > 0.1:
                         return fragments[i][0]
         return -1
 
     def inference_speaker(self):
         """
         推理生成合成后的音频
         随机取5个干声,选择占比最小的，并且要求占比小于0.3
         :return:
         """
         st = time.time()
         out_speakers = random.sample(self.speakers, 15)
         out_songs_dict = {}
         for speaker in out_speakers:
             model_path = self.speakers_model_path.format(speaker)
             config_path = self.speakers_model_config.format(speaker)
             song_path = os.path.join(self.cache_dir, "{}_{}.wav".format(self.cid, speaker))
             try:
                 inf(model_path, config_path, self.vocal_32_path, song_path, "prod")
             except Exception as ex:
                 logging.info("cid={}, inference_speaker err={}".format(self.cid, ex))
                 continue
             if os.path.exists(song_path):
                 if self.replace_vocal_frame_inst is None:
                     self.replace_vocal_frame_inst = ReplaceVocalFrame(
                         "data/models/split_dirty_frame_v5_3_epoch3_852.pth")
                 rate = self.replace_vocal_frame_inst.get_rate(song_path)
                 if rate < 0.3:
                     out_songs_dict[song_path] = rate
 
         # 从内部选择占比最低的
         out_songs = []
         if len(out_songs_dict.keys()) > 0:
             st_sec = self.get_start_ms(self.vocal_path)
             song_msg = sorted(out_songs_dict.items(), key=lambda kv: kv[1])[0]
             out_songs = [song_msg[0]]
             logging.info("GetRate:cid={},song={},rate={},st_tm={}".format(self.cid, song_msg[0], round(song_msg[1], 2),
                                                                           round(st_sec, 3)))
             print("GetRate:cid={},song={},rate={},st_tm={}".format(self.cid, song_msg[0], round(song_msg[1], 2),
                                                                    round(st_sec, 3)))
         # logging.info("inference_speaker len = {} finish sp = {}".format(len(out_songs), time.time() - st))
         print("inference_speaker len = {} finish sp = {}".format(len(out_songs), time.time() - st))
         return out_songs
 
     def get_new_vocal_rate(self, songs):
         """
         获取人声的比率
         :param songs:
         :return:
         """
         st = time.time()
         need_to_process_song = []
         for song in songs:
             if self.replace_vocal_frame_inst is None:
                 self.replace_vocal_frame_inst = ReplaceVocalFrame("data/models/split_dirty_frame_v5_3_epoch3_852.pth")
             rate = self.replace_vocal_frame_inst.get_rate(song)
             logging.info("{} {} replace_rate={}".format(self.cid, song, rate))
             if rate < 1.0:
                 need_to_process_song.append(song)
         logging.info(
             "get_new_vocal_rate belen = {} len = {} finish sp = {}".format(len(songs), len(need_to_process_song),
                                                                            time.time() - st))
         return need_to_process_song
 
     def preprocess_vocal(self, songs, vocal_path):
         """
         1. 降噪
         2. 拉伸
         :param songs:
         :param vocal_path: 参考的音频信号
         :return:
         """
         st = time.time()
         dv_out_list = []
         for song in songs:
             denoise_path = str(song).replace(".wav", "_d.wav")
             cmd = "{} {} {}".format(gs_denoise_exe, song, denoise_path)
             os.system(cmd)
             if not os.path.exists(denoise_path):
                 print("{} {} ERROR denoise".format(self.cid, song))
                 continue
             # 拉伸
             volume_path = str(song).replace(".wav", "_dv.wav")
             cmd = "{} {} {} {}".format(gs_draw_volume_exe, denoise_path, vocal_path, volume_path)
             os.system(cmd)
             if not os.path.exists(volume_path):
                 print("{} {} ERROR denoise".format(self.cid, volume_path))
                 continue
             dv_out_list.append(volume_path)
         print(
             "preprocess_vocal belen = {} len = {} finish sp = {}".format(len(songs), len(dv_out_list),
                                                                          time.time() - st))
         return dv_out_list
 
     def output(self, dv_out_list):
         """
         对外输出数据
         :param dv_out_list:
         :return:
         """
         st = time.time()
         out_dir = os.path.join(self.work_dir, self.cid)
         if os.path.exists(out_dir):
             shutil.rmtree(out_dir)
         os.makedirs(out_dir)
 
         # 拷贝数据
         dst_mp3_path = os.path.join(out_dir, "src_mp3")
         dst_acc_path = os.path.join(out_dir, "acc.mp3")
         dst_vocal_path = os.path.join(out_dir, "vocal.mp3")
         shutil.copyfile(self.src_mp3, dst_mp3_path)
         cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(self.acc_path, dst_acc_path)
         os.system(cmd)
         if not os.path.exists(dst_acc_path):
             return gs_err_code_encode_err
         cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(self.vocal_path, dst_vocal_path)
         os.system(cmd)
         if not os.path.exists(dst_vocal_path):
             return gs_err_code_encode_err
 
         # 将所有数据放到out_dir中，用于给人工标注
         for dv_wav in dv_out_list:
             dv_wav_name = str(dv_wav).split("/")[-1].replace(".wav", "_441.mp3")
             dst_dv_path = os.path.join(out_dir, dv_wav_name)
 
             cmd = "ffmpeg -i {} -ar 44100 -ac 1 -ab 320k -y {} -loglevel fatal".format(dv_wav, dst_dv_path)
             os.system(cmd)
             if not os.path.exists(dst_dv_path):
                 print("{} encode err!".format(cmd))
                 continue
         logging.info(
             "preprocess_vocal output sp = {}".format(time.time() - st))
 
     def process_one(self, cid, work_dir, enable_output=False):
         logging.info("\nstart:cid={},work_dir={}----------------------->>>>>>>>".format(cid, work_dir))
         self.cid = cid
         self.work_dir = work_dir
 
         # 所有不对外交付的，全部放到这里
         self.cache_dir = os.path.join(work_dir, "cache")
         if os.path.exists(self.cache_dir):
             shutil.rmtree(self.cache_dir)
         os.makedirs(self.cache_dir)
 
         self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
         if not os.path.exists(self.src_mp3):
             return gs_err_code_no_src_mp3
         self.vocal_path = os.path.join(self.cache_dir, "vocal.wav")
         self.vocal_32_path = os.path.join(self.cache_dir, "vocal_32.wav")
         self.acc_path = os.path.join(self.cache_dir, "acc.wav")
 
         if not os.path.exists(self.vocal_32_path):
             logging.info("start separate ... {} {} {}".format(self.src_mp3, self.vocal_path, self.acc_path))
             err = self.separate(cid, self.src_mp3, self.vocal_path, self.acc_path)
             if err != gs_err_code_success:
                 return err, None, None
         logging.info("start inference_speaker ...")
         out_songs = self.inference_speaker()
         dv_out_list = self.preprocess_vocal(out_songs, self.vocal_path)
         if len(dv_out_list) == 0:
             return gs_err_code_no_good_choice, None, None
 
         mix_mp3_path = None
         gender = -1
         if enable_output:
             self.output(dv_out_list)
         else:
             # 默认全部处理一遍
             for dv_out_path in dv_out_list:
                 src_path = dv_out_path.replace("_dv.wav", ".wav")
                 err, mix_mp3_path = self.after_process(self.cid, self.work_dir, src_path, dv_out_path, self.vocal_path,
                                                        self.acc_path,
                                                        True, False)
                 if err != gs_err_code_success:
                     logging.info("after_process err {}".format(err))
 
                 # 取出性别属性
                 if err == gs_err_code_success and mix_mp3_path is not None:
                     gender = self.speakers2gender[int(str(os.path.basename(mix_mp3_path)).split("_")[1])]
         logging.info("finish:cid={},work_dir={}----------------------->>>>>>>>".format(cid, work_dir))
         return gs_err_code_success, mix_mp3_path, gender
 
     def reverb_by_vocal(self, file):
         st = time.time()
         file_442 = file.replace(".wav", "_442.wav")
         if not os.path.exists(file_442):
             cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {}".format(file, file_442)
             os.system(cmd)
             if not os.path.exists(file_442):
                 return gs_err_code_trans2_442, None
 
         file_dst = file.replace(".wav", "_442_dr.wav")
         cmd = "{} {} {} {}".format(gs_rever_path, self.vocal_path, file_442, file_dst)
         os.system(cmd)
         if not os.path.exists(file_dst):
             return gs_err_code_reverb, None
         print("cid = {}, reverb_by_vocal sp={}".format(self.cid, time.time() - st))
         return gs_err_code_success, file_dst
 
     def after_process(self, cid, work_dir, in_file, effect_file, vocal_file, acc_file, need_draw=True,
                       need_reverb=True):
         """
         后处理逻辑
         将处理好的音频进行替换，然后和伴奏进行混合，最后进行编码
         :return:
         """
         if need_reverb:
             # 抓取混响
             err, effect_file = self.reverb_by_vocal(in_file)
             if err != gs_err_code_success:
                 return err, None
 
         if need_draw:
             # 增加一个拉伸的步骤
             volume_path = str(effect_file).replace(".wav", "_dv.wav")
             cmd = "{} {} {} {}".format(gs_draw_volume_exe, effect_file, vocal_file, volume_path)
             print(cmd)
             os.system(cmd)
             if not os.path.exists(volume_path):
                 print("{} {} ERROR draw volume".format(self.cid, volume_path))
                 return gs_err_code_volume_err, None
             effect_file = volume_path
 
         st = time.time()
         self.cid = cid
         self.work_dir = work_dir
         self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
         if not os.path.exists(self.work_dir):
             return gs_err_code_no_src_dir
         self.replace_vocal_frame_inst.process(in_file, effect_file, vocal_file)
         dst_path = effect_file + "_replace.wav"
         if not os.path.exists(dst_path):
             return gs_err_code_replace_err, None
         print("replace_vocal_frame_inst sp = {}".format(time.time() - st))
 
         # 转码
         dst_path_442 = dst_path.replace("_replace.wav", "_replace442.wav")
         cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {} -loglevel fatal".format(dst_path, dst_path_442)
         os.system(cmd)
         if not os.path.exists(dst_path_442):
             return gs_err_code_replace_trans_err, None
 
         # 合并转码后再做一次拉伸，保证响度
         volume_path = str(dst_path_442).replace(".wav", "_dv.wav")
         cmd = "{} {} {} {}".format(gs_draw_volume_exe, dst_path_442, vocal_file, volume_path)
         print(cmd)
         os.system(cmd)
         if not os.path.exists(volume_path):
             print("{} {} ERROR draw volume".format(self.cid, volume_path))
             return gs_err_code_volume_err, None
         dst_path_442 = volume_path
 
         # 混合
         mix_path = dst_path_442.replace("_replace442.wav", "_replace442_mix.wav")
         cmd = "{} {} {} {}".format(gs_simple_mixer_path, dst_path_442, acc_file, mix_path)
         print("{}".format(cmd))
         os.system(cmd)
         if not os.path.exists(mix_path):
             return gs_err_code_mix_err, None
 
         # 编码为mp3
         output_dir = os.path.join(self.work_dir, self.cid + "_out")
         if not os.path.exists(output_dir):
             os.makedirs(output_dir)
         name = str(mix_path).replace("_replace442_mix.wav", "_replace442_mix.mp3").split("/")[-1]
         mix_path_mp3 = os.path.join(output_dir, name)
         cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
         os.system(cmd)
         if not os.path.exists(mix_path_mp3):
             return gs_err_code_mix_transcode_err, None
 
         # 拷贝src到output_dir
         # shutil.copyfile(self.src_mp3, os.path.join(output_dir, "src.mp3"))
         # logging.info("after_process sp = {}".format(time.time() - st))
         return gs_err_code_success, mix_path_mp3
 
     ####################################新对外接口############################################################
     def prepare_env(self, cid, work_dir, create_dir=False):
         self.cid = cid
         self.work_dir = work_dir
 
         # 所有不对外交付的，全部放到这里
         self.cache_dir = os.path.join(work_dir, "cache")
         if create_dir:
             if os.path.exists(self.cache_dir):
                 shutil.rmtree(self.cache_dir)
             os.makedirs(self.cache_dir)
 
         self.src_mp3 = os.path.join(self.work_dir, "src.mp3")
         if not os.path.exists(self.src_mp3):
             return gs_err_code_no_src_mp3
         self.vocal_path = os.path.join(self.cache_dir, "vocal.wav")
         self.vocal_32_path = os.path.join(self.cache_dir, "vocal_32.wav")
         self.acc_path = os.path.join(self.cache_dir, "acc.wav")
         return gs_err_code_success
 
     def generate_svc_file(self, cid, work_dir):
         """
         :param cid:
         :param work_dir:
         :return:err_code, 生成出的svc的文件名称
         """
         err = self.prepare_env(cid, work_dir, create_dir=True)
         if err != gs_err_code_success:
             return err, None
 
         # 音源分离
         if not os.path.exists(self.vocal_32_path):
             st = time.time()
             err = self.separate(cid, self.src_mp3, self.vocal_path, self.acc_path)
             logging.info("cid={},separate,sp={}".format(self.cid, time.time() - st))
             if err != gs_err_code_success:
                 return err, None
 
         # 生成svc,只保留一个最佳的
         st = time.time()
         out_songs = self.inference_speaker()
         if len(out_songs) == 0:
             return gs_err_code_no_good_choice, None
         logging.info("cid={},inference_speaker,{},sp={}".format(self.cid, out_songs[0], time.time() - st))
         return gs_err_code_success, out_songs[0]
 
     def effect(self, cid, work_dir, svc_file):
         st = time.time()
         err = self.prepare_env(cid, work_dir)
         if err != gs_err_code_success:
             return err, None
         logging.info("cid={},effect_and_mix,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 预处理人声
         dv_out_list = self.preprocess_vocal([svc_file], self.vocal_path)
         if len(dv_out_list) == 0:
             return gs_err_code_preprocess_vocal, None
         svc_file = dv_out_list[0]
 
         # 做音效
         st = time.time()
         err, effect_file = self.reverb_by_vocal(svc_file)
         if err != gs_err_code_success:
             return err, None
         logging.info("cid={},reverb_by_vocal,{},sp={}".format(self.cid, svc_file, time.time() - st))
         return err, effect_file
 
     def mix(self, cid, work_dir, svc_file, effect_file):
         """
         做音效以及合并
         :param cid:
         :param work_dir:
         :param svc_file:
         :param effect_file:
         :return: err_code, 完成的mp3文件
         """
         st = time.time()
         err = self.prepare_env(cid, work_dir)
         if err != gs_err_code_success:
             return err, None
         logging.info("cid={},effect_and_mix,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 拉伸
         st = time.time()
         volume_path = str(effect_file).replace(".wav", "_dv.wav")
         cmd = "{} {} {} {}".format(gs_draw_volume_exe, effect_file, self.vocal_path, volume_path)
         os.system(cmd)
         if not os.path.exists(volume_path):
             print("{} {} ERROR draw volume".format(self.cid, volume_path))
             return gs_err_code_volume_err, None
         effect_file = volume_path
         logging.info("cid={},draw_volume,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 替换
         st = time.time()
         try:
             if self.replace_vocal_frame_inst is None:
                 self.replace_vocal_frame_inst = ReplaceVocalFrame("data/models/split_dirty_frame_v5_3_epoch3_852.pth")
             self.replace_vocal_frame_inst.process(svc_file, effect_file, self.vocal_path)
         except Exception as ex:
             logging.info("{},replace_vocal_frame_inst, {}", self.cid, ex)
             return gs_err_code_replace_except_err, None
         dst_path = effect_file + "_replace.wav"
         if not os.path.exists(dst_path):
             return gs_err_code_replace_err, None
         logging.info("cid={},replace_vocal_frame_inst,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 转码
         st = time.time()
         dst_path_442 = dst_path.replace("_replace.wav", "_replace442.wav")
         cmd = "ffmpeg -i {} -ar 44100 -ac 2 -y {} -loglevel fatal".format(dst_path, dst_path_442)
         os.system(cmd)
         if not os.path.exists(dst_path_442):
             return gs_err_code_replace_trans_err, None
         logging.info("cid={},transcode,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 合并转码后再做一次拉伸，保证响度
         st = time.time()
         volume_path = str(dst_path_442).replace("_replace442.wav", "_replace442_dv.wav")
         cmd = "{} {} {} {}".format(gs_draw_volume_exe, dst_path_442, self.vocal_path, volume_path)
         os.system(cmd)
         if not os.path.exists(volume_path):
             print("{} {} ERROR draw volume".format(self.cid, volume_path))
             return gs_err_code_volume_err, None
         dst_path_442 = volume_path
         logging.info("cid={},draw_volume2,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 混合
         st = time.time()
         mix_path = dst_path_442.replace("_replace442_dv.wav", "_replace442_dv_mix.wav")
         cmd = "{} {} {} {}".format(gs_simple_mixer_path, dst_path_442, self.acc_path, mix_path)
         os.system(cmd)
         if not os.path.exists(mix_path):
             return gs_err_code_mix_err, None
         logging.info("cid={},mixer,{},sp={}".format(self.cid, svc_file, time.time() - st))
 
         # 编码为mp3
         st = time.time()
         output_dir = os.path.join(self.work_dir, self.cid + "_out")
         if not os.path.exists(output_dir):
             os.makedirs(output_dir)
         name = str(mix_path).replace("_replace442_dv_mix.wav", "_replace442_dv_mix.mp3").split("/")[-1]
         mix_path_mp3 = os.path.join(output_dir, name)
         cmd = "ffmpeg -i {} -ab 320k -y {} -loglevel fatal".format(mix_path, mix_path_mp3)
         print(cmd)
         os.system(cmd)
         if not os.path.exists(mix_path_mp3):
             return gs_err_code_mix_transcode_err, None
         logging.info("cid={},encode,{},sp={}".format(self.cid, svc_file, time.time() - st))
         return gs_err_code_success, mix_path_mp3
 
     def get_gender(self, svc_file):
         return self.speakers2gender[int(os.path.basename(svc_file.replace(".wav", "")).split("_")[1])]
 
     def process_one_logic(self, cid, work_dir):
         """
         搞成两部分:
         1. 分离数据+5次推理，获取最佳结果,并保存
         2. 利用最佳结果做音效以及合并
         :return:
         """
         err, svc_file = self.generate_svc_file(cid, work_dir)
         gender = -1
         if err != gs_err_code_success:
             return err, svc_file, gender,
         gender = self.get_gender(svc_file)
         err, effect_file = self.effect(cid, work_dir, svc_file)
         if err != gs_err_code_success:
             return err, svc_file, gender
         err, mix_mp3_path = self.mix(cid, work_dir, svc_file, effect_file)
         return err, mix_mp3_path, gender
 
 
 def test():
     arr = [
         # "611752105020343687",
         # "611752105023532439",
         # "611752105030419688",
         # "611752105030485748",
         # "611752105030485685",
         "dzq",
     ]
     base_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/test"
     s_inst = SongCoverInference()
     for cid in arr:
         st = time.time()
         # err, mix_mp3, gender = s_inst.process_one(cid, os.path.join(base_dir, cid), False)
         err, mix_mp3, gender = s_inst.process_one_logic(cid, os.path.join(base_dir, cid))
         print(mix_mp3, gender)
         print("cid={} RealFinish err={} sp={}".format(cid, err, time.time() - st))
 
 
 def test_gene_svc():
     base_dir = "/data/rsync/jianli.yang/AutoCoverTool/data/test"
     # cid = "clean_yibo"
     cid = "dzq"
     work_dir = os.path.join(base_dir, cid)
     st = time.time()
-    speaker = "jianli"
-    speakers_model_path = "data/train_users/{}/logs/32k/G_2000.pth"
+    speaker = "train_sing_base"
+    speakers_model_path = "data/train_users/{}/logs/32k/G_6000.pth"
     speakers_model_config = "data/train_users/{}/config/config.json"
     model_path = speakers_model_path.format(speaker)
     config_path = speakers_model_config.format(speaker)
 
     # 缓存目录:
     cache_dir = os.path.join(work_dir, "cache")
     if os.path.exists(cache_dir):
         shutil.rmtree(cache_dir)
     os.makedirs(cache_dir)
     song_path = os.path.join(cache_dir, "{}_{}.wav".format(cid, speaker))
     # vocal_path = os.path.join(work_dir, "vocal_32.wav")
     vocal_path = os.path.join(work_dir, "test_silce.wav")
     inf(model_path, config_path, vocal_path, song_path, "prod")
     print("finish....")
 
 
 if __name__ == '__main__':
     test_gene_svc()
diff --git a/AutoCoverTool/ref/so_vits_svc/inference_main.py b/AutoCoverTool/ref/so_vits_svc/inference_main.py
index 326ad07..57bfdd2 100644
--- a/AutoCoverTool/ref/so_vits_svc/inference_main.py
+++ b/AutoCoverTool/ref/so_vits_svc/inference_main.py
@@ -1,85 +1,85 @@
 import io
 import os
 import sys
 import logging
 import time
 from pathlib import Path
 from copy import deepcopy
 
 import torch
 import librosa
 import numpy as np
 import soundfile
 
 from inference import infer_tool
 from inference import slicer
 from inference.infer_tool import Svc
 
 logging.getLogger('numba').setLevel(logging.WARNING)
 chunks_dict = infer_tool.read_temp("ref/so_vits_svc/inference/chunks_temp.json")
 
 
 def inf(model_path, config_path, raw_audio_path, dst_path, dev):
     # model_path = "logs/32k/G_174000-Copy1.pth"
     # config_path = "configs/config.json"
     svc_model = Svc(model_path, config_path)
     out_dir = os.path.dirname(dst_path)
     print(dst_path)
     os.makedirs(out_dir, exist_ok=True)
     # 支持多个wav文件，放在raw文件夹下
     tran = 0
-    spk_list = ['speaker0']  # 每次同时合成多语者音色
+    spk_list = ['speaker6']  # 每次同时合成多语者音色
     slice_db = -40  # 默认-40，嘈杂的音频可以-30，干声保留呼吸可以-50
     wav_format = 'wav'  # 音频输出格式
 
     # infer_tool.fill_a_to_b(trans, clean_names)
     # for clean_name, tran in zip(clean_names, trans):
     #     raw_audio_path = f"raw/{clean_name}"
     #     if "." not in raw_audio_path:
     #         raw_audio_path += ".wav"
     infer_tool.format_wav(raw_audio_path)
     wav_path = Path(raw_audio_path).with_suffix('.wav')
     chunks = slicer.cut(wav_path, db_thresh=slice_db)
     audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)
 
     for spk in spk_list:
         audio = []
         for (slice_tag, data) in audio_data:
             print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
             length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
             raw_path = io.BytesIO()
             soundfile.write(raw_path, data, audio_sr, format="wav")
             raw_path.seek(0)
             if slice_tag:
                 print('jump empty segment')
                 _audio = np.zeros(length)
             else:
                 out_audio, out_sr = svc_model.infer(spk, tran, raw_path, dev == "test")
                 _audio = out_audio.cpu().numpy()
             audio.extend(list(_audio))
         soundfile.write(dst_path, audio, svc_model.target_sample, format=wav_format)
 
 
 if __name__ == '__main__':
     g_model = sys.argv[1]  # 模型地址
     g_config = sys.argv[2]  # 配置文件地址
     g_audio_path = sys.argv[3]  # 输入的音频文件地址,wav
     g_dst_path = sys.argv[4]  # 输出的音频文件地址
     if os.path.exists(g_dst_path):
         print("{} success ...".format(g_dst_path))
         exit(0)
 
     g_dev = "prod"
     if len(sys.argv) > 5:
         g_dev = sys.argv[5]
 
     g_aa, g_sr = librosa.load(g_audio_path)
     d = librosa.get_duration(g_aa, g_sr)
     # if g_dev != "test":
     # if d > 250:
     #     print("{} too long".format(g_audio_path))
     #     exit(0)
 
     st = time.time()
     inf(g_model, g_config, g_audio_path, g_dst_path, g_dev)
     print("{}, inference sp={}".format(g_audio_path, time.time() - st))
diff --git a/AutoCoverTool/ref/so_vits_svc/models.py b/AutoCoverTool/ref/so_vits_svc/models.py
index 6fdea53..477f395 100644
--- a/AutoCoverTool/ref/so_vits_svc/models.py
+++ b/AutoCoverTool/ref/so_vits_svc/models.py
@@ -1,388 +1,412 @@
 import copy
 import math
 import torch
 from torch import nn
 from torch.nn import functional as F
 
 import attentions
 import commons
 import modules
 
 from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
 from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
 from commons import init_weights, get_padding
 from vdecoder.hifigan.models import Generator
 from utils import f0_to_coarse
 
+
 class ResidualCouplingBlock(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      n_flows=4,
-      gin_channels=0):
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.n_flows = n_flows
-    self.gin_channels = gin_channels
-
-    self.flows = nn.ModuleList()
-    for i in range(n_flows):
-      self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
-      self.flows.append(modules.Flip())
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    if not reverse:
-      for flow in self.flows:
-        x, _ = flow(x, x_mask, g=g, reverse=reverse)
-    else:
-      for flow in reversed(self.flows):
-        x = flow(x, x_mask, g=g, reverse=reverse)
-    return x
+    def __init__(self,
+                 channels,
+                 hidden_channels,
+                 kernel_size,
+                 dilation_rate,
+                 n_layers,
+                 n_flows=4,
+                 gin_channels=0):
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.n_flows = n_flows
+        self.gin_channels = gin_channels
+
+        self.flows = nn.ModuleList()
+        for i in range(n_flows):
+            self.flows.append(
+                modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers,
+                                              gin_channels=gin_channels, mean_only=True))
+            self.flows.append(modules.Flip())
+
+    def forward(self, x, x_mask, g=None, reverse=False):
+        if not reverse:
+            for flow in self.flows:
+                x, _ = flow(x, x_mask, g=g, reverse=reverse)
+        else:
+            for flow in reversed(self.flows):
+                x = flow(x, x_mask, g=g, reverse=reverse)
+        return x
 
 
 class Encoder(nn.Module):
-  def __init__(self,
-      in_channels,
-      out_channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      gin_channels=0):
-    super().__init__()
-    self.in_channels = in_channels
-    self.out_channels = out_channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-
-    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-    self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
-    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-  def forward(self, x, x_lengths, g=None):
-    # print(x.shape,x_lengths.shape)
-    # commons.sequence_mask 对于batch层级有价值，x_lengths是每个batch中每一个元素的帧数
-    # 比如输入（[3,5,2]， 5）那么得到 3 * 5的True/False矩阵，其中第一层矩阵为3个true,2个false,第二层全true，第三层前两个true,其余false
-    # 作用一个批次中允许不同长度的数据一起训练，此时较短的乘以false，剔除影响
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-    x = self.pre(x) * x_mask
-    x = self.enc(x, x_mask, g=g)
-    stats = self.proj(x) * x_mask
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-    return z, m, logs, x_mask
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 hidden_channels,
+                 kernel_size,
+                 dilation_rate,
+                 n_layers,
+                 gin_channels=0):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.gin_channels = gin_channels
+
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
+        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+    def forward(self, x, x_lengths, g=None):
+        # print(x.shape,x_lengths.shape)
+        # commons.sequence_mask 对于batch层级有价值，x_lengths是每个batch中每一个元素的帧数
+        # 比如输入（[3,5,2]， 5）那么得到 3 * 5的True/False矩阵，其中第一层矩阵为3个true,2个false,第二层全true，第三层前两个true,其余false
+        # 作用一个批次中允许不同长度的数据一起训练，此时较短的乘以false，剔除影响
+        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+        x = self.pre(x) * x_mask
+        x = self.enc(x, x_mask, g=g)
+        stats = self.proj(x) * x_mask
+        m, logs = torch.split(stats, self.out_channels, dim=1)
+        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+        return z, m, logs, x_mask
 
 
 class TextEncoder(nn.Module):
-  def __init__(self,
-      in_channels,
-      out_channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      gin_channels=0,
-      filter_channels=None,
-      n_heads=None,
-      p_dropout=None):
-    super().__init__()
-    self.in_channels = in_channels
-    self.out_channels = out_channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-    self.f0_emb = nn.Embedding(256, hidden_channels)
-
-    self.enc_ =  attentions.Encoder(
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout)
-
-  def forward(self, x, x_lengths, f0=None):
-    # x->(b,256,frame_num), x_lengths -> (b)
-    # commons.sequence_mask 对于batch层级有价值，x_lengths是每个batch中每一个元素的帧数
-    # 比如输入（[3,5,2]， 5）那么得到 3 * 5的True/False矩阵，其中第一层矩阵为3个true,2个false,第二层全true，第三层前两个true,其余false
-    # 作用一个批次中允许不同长度的数据一起训练，此时较短的乘以false，剔除影响
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-    x = self.pre(x) * x_mask
-    x = x + self.f0_emb(f0).transpose(1,2)
-    x = self.enc_(x * x_mask, x_mask)
-    stats = self.proj(x) * x_mask
-    # m是VAE过程中得到的mu,而log对应的是log(sigma)
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    # z是随机采样过程
-    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-
-    return z, m, logs, x_mask
-
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 hidden_channels,
+                 kernel_size,
+                 dilation_rate,
+                 n_layers,
+                 gin_channels=0,
+                 filter_channels=None,
+                 n_heads=None,
+                 p_dropout=None):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+        self.gin_channels = gin_channels
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+        self.f0_emb = nn.Embedding(256, hidden_channels)
+
+        self.enc_ = attentions.Encoder(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            p_dropout)
+
+    def forward(self, x, x_lengths, f0=None):
+        # x->(b,256,frame_num), x_lengths -> (b)
+        # commons.sequence_mask 对于batch层级有价值，x_lengths是每个batch中每一个元素的帧数
+        # 比如输入（[3,5,2]， 5）那么得到 3 * 5的True/False矩阵，其中第一层矩阵为3个true,2个false,第二层全true，第三层前两个true,其余false
+        # 作用一个批次中允许不同长度的数据一起训练，此时较短的乘以false，剔除影响
+        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+        x = self.pre(x) * x_mask
+        x = x + self.f0_emb(f0).transpose(1, 2)
+        x = self.enc_(x * x_mask, x_mask)
+        stats = self.proj(x) * x_mask
+        # m是VAE过程中得到的mu,而log对应的是log(sigma)
+        m, logs = torch.split(stats, self.out_channels, dim=1)
+        # z是随机采样过程
+        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+
+        return z, m, logs, x_mask
 
 
 class DiscriminatorP(torch.nn.Module):
     def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
         super(DiscriminatorP, self).__init__()
         self.period = period
         self.use_spectral_norm = use_spectral_norm
         norm_f = weight_norm if use_spectral_norm == False else spectral_norm
         self.convs = nn.ModuleList([
             norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
             norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
             norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
             norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
             norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
         ])
         self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
 
     def forward(self, x):
         fmap = []
 
         # 1d to 2d
         b, c, t = x.shape
-        if t % self.period != 0: # pad first
+        if t % self.period != 0:  # pad first
             n_pad = self.period - (t % self.period)
             x = F.pad(x, (0, n_pad), "reflect")
             t = t + n_pad
         x = x.view(b, c, t // self.period, self.period)
 
         for l in self.convs:
             x = l(x)
             x = F.leaky_relu(x, modules.LRELU_SLOPE)
             fmap.append(x)
         x = self.conv_post(x)
         fmap.append(x)
         x = torch.flatten(x, 1, -1)
 
         return x, fmap
 
 
 class DiscriminatorS(torch.nn.Module):
     def __init__(self, use_spectral_norm=False):
         super(DiscriminatorS, self).__init__()
         norm_f = weight_norm if use_spectral_norm == False else spectral_norm
         self.convs = nn.ModuleList([
             norm_f(Conv1d(1, 16, 15, 1, padding=7)),
             norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
             norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
             norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
             norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
             norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
         ])
         self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
 
     def forward(self, x):
         fmap = []
 
         for l in self.convs:
             x = l(x)
             x = F.leaky_relu(x, modules.LRELU_SLOPE)
             fmap.append(x)
         x = self.conv_post(x)
         fmap.append(x)
         x = torch.flatten(x, 1, -1)
 
         return x, fmap
 
 
 class MultiPeriodDiscriminator(torch.nn.Module):
     def __init__(self, use_spectral_norm=False):
         super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2,3,5,7,11]
+        periods = [2, 3, 5, 7, 11]
 
         discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
         discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
         self.discriminators = nn.ModuleList(discs)
 
     def forward(self, y, y_hat):
         y_d_rs = []
         y_d_gs = []
         fmap_rs = []
         fmap_gs = []
         for i, d in enumerate(self.discriminators):
             y_d_r, fmap_r = d(y)
             y_d_g, fmap_g = d(y_hat)
             y_d_rs.append(y_d_r)
             y_d_gs.append(y_d_g)
             fmap_rs.append(fmap_r)
             fmap_gs.append(fmap_g)
 
         return y_d_rs, y_d_gs, fmap_rs, fmap_gs
 
 
 class SpeakerEncoder(torch.nn.Module):
     def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
         super(SpeakerEncoder, self).__init__()
         self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
         self.linear = nn.Linear(model_hidden_size, model_embedding_size)
         self.relu = nn.ReLU()
 
     def forward(self, mels):
         self.lstm.flatten_parameters()
         _, (hidden, _) = self.lstm(mels)
         embeds_raw = self.relu(self.linear(hidden[-1]))
         return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
 
     def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
         mel_slices = []
-        for i in range(0, total_frames-partial_frames, partial_hop):
-            mel_range = torch.arange(i, i+partial_frames)
+        for i in range(0, total_frames - partial_frames, partial_hop):
+            mel_range = torch.arange(i, i + partial_frames)
             mel_slices.append(mel_range)
 
         return mel_slices
 
     def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
         mel_len = mel.size(1)
-        last_mel = mel[:,-partial_frames:]
+        last_mel = mel[:, -partial_frames:]
 
         if mel_len > partial_frames:
             mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
-            mels = list(mel[:,s] for s in mel_slices)
+            mels = list(mel[:, s] for s in mel_slices)
             mels.append(last_mel)
             mels = torch.stack(tuple(mels), 0).squeeze(1)
 
             with torch.no_grad():
                 partial_embeds = self(mels)
             embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
-            #embed = embed / torch.linalg.norm(embed, 2)
+            # embed = embed / torch.linalg.norm(embed, 2)
         else:
             with torch.no_grad():
                 embed = self(last_mel)
 
         return embed
 
 
 class SynthesizerTrn(nn.Module):
-  """
-  Synthesizer for Training
-  """
-
-  def __init__(self,
-    spec_channels,
-    segment_size,
-    inter_channels,
-    hidden_channels,
-    filter_channels,
-    n_heads,
-    n_layers,
-    kernel_size,
-    p_dropout,
-    resblock,
-    resblock_kernel_sizes,
-    resblock_dilation_sizes,
-    upsample_rates,
-    upsample_initial_channel,
-    upsample_kernel_sizes,
-    gin_channels,
-    ssl_dim,
-    n_speakers,
-    **kwargs):
-
-    super().__init__()
-    self.spec_channels = spec_channels
-    self.inter_channels = inter_channels
-    self.hidden_channels = hidden_channels
-    self.filter_channels = filter_channels
-    self.n_heads = n_heads
-    self.n_layers = n_layers
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.resblock = resblock
-    self.resblock_kernel_sizes = resblock_kernel_sizes
-    self.resblock_dilation_sizes = resblock_dilation_sizes
-    self.upsample_rates = upsample_rates
-    self.upsample_initial_channel = upsample_initial_channel
-    self.upsample_kernel_sizes = upsample_kernel_sizes
-    self.segment_size = segment_size
-    self.gin_channels = gin_channels
-    self.ssl_dim = ssl_dim
-    self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
-    self.enc_p_ = TextEncoder(ssl_dim, inter_channels, hidden_channels, 5, 1, 16,0, filter_channels, n_heads, p_dropout)
-    hps = {
-        "sampling_rate": 32000,
-        "inter_channels": 192,
-        "resblock": "1",
-        "resblock_kernel_sizes": [3, 7, 11],
-        "resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
-        "upsample_rates": [10, 8, 2, 2],
-        "upsample_initial_channel": 512,
-        "upsample_kernel_sizes": [16, 16, 4, 4],
-        "gin_channels": 256,
-    }
-    self.dec = Generator(h=hps)
-    self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
-    self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-
-  def forward(self, c, f0, spec, g=None, mel=None, c_lengths=None, spec_lengths=None):
-    # hubert特征(b,256,frame_num), f0 (frame_num), 幅度谱特征, 说话人id,mel谱特征
-    if c_lengths == None:
-      c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device) # (b, frame_num)
-    if spec_lengths == None:
-      spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)
-
-    # 说话人信息embding
-    g = self.emb_g(g).transpose(1,2)
-
-    # 采样得到的z,vae需要的均值，logs_p是vae需要的log(sigma)
-    # 输入hubert特征(b,256,frame_num), f0 (frame_num)，对应的是文本出隐变量的那段模型
-    z_ptemp, m_p, logs_p, _ = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
-
-    # 输入幅度谱和说话人信息
-    # 输出采样得到的z，m_q是均值，logs_q是log(sigma)
-    z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
-
-    # 标准化流，增加分布复杂程度
-    z_p = self.flow(z, spec_mask, g=g)
-    # 由于整个batch中含有的音频帧数不一致，要求每一个元素都随机裁剪出segment_size长度的特征
-    # 返回z的batch列表，pitch_slice列表和ids_slice的列表
-    z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)
-
-    # o = self.dec(z_slice, g=g)
-    # 解码部分，输入未经过标准化的z,以及说话人信息和pitch，得到wav波形
-    o = self.dec(z_slice, g=g, f0=pitch_slice)
-
-    # 原始波形,批次中每个采样到的帧的位置,批次中幅度谱的有效帧位置，
-    # 幅度谱编码得到正态分布后随机采样得到的z, z经过标准化流之后得到z_p, hubert特征层得到的正态分布的均值，
-    # hubert特征层得到的正态分布的标准差(logs_p)，幅度谱和人声信息得到的均值(m_q),幅度谱和人声信息得到的标准差(logs_q)
-    return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-  def infer(self, c, f0, g=None, mel=None, c_lengths=None):
-    if c_lengths == None:
-      c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
-    g = self.emb_g(g).transpose(1,2)
-
-    z_p, m_p, logs_p, c_mask = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
-    z = self.flow(z_p, c_mask, g=g, reverse=True)
-
-    o = self.dec(z * c_mask, g=g, f0=f0)
-
-    return o
-
-  def infer_v1(self, c, spec, f0, g):
-      print(c.shape, spec.shape, f0.shape, g.shape)
-      c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device) # (b, frame_num)
-      spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)
-      g = self.emb_g(g).transpose(1, 2)
-
-      # z_p, m_p, logs_p, c_mask = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
-      # z = self.flow(z_p, c_mask, g=g, reverse=True)
-      # o = self.dec(z * c_mask, g=g, f0=f0)
-      # print(c_mask.shape, c_mask)
-      z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
-      o = self.dec(z, g=g, f0=f0)
-      return o
+    """
+    Synthesizer for Training
+    """
+
+    def __init__(self,
+                 spec_channels,
+                 segment_size,
+                 inter_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout,
+                 resblock,
+                 resblock_kernel_sizes,
+                 resblock_dilation_sizes,
+                 upsample_rates,
+                 upsample_initial_channel,
+                 upsample_kernel_sizes,
+                 gin_channels,
+                 ssl_dim,
+                 n_speakers,
+                 **kwargs):
+
+        super().__init__()
+        self.spec_channels = spec_channels
+        self.inter_channels = inter_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.resblock = resblock
+        self.resblock_kernel_sizes = resblock_kernel_sizes
+        self.resblock_dilation_sizes = resblock_dilation_sizes
+        self.upsample_rates = upsample_rates
+        self.upsample_initial_channel = upsample_initial_channel
+        self.upsample_kernel_sizes = upsample_kernel_sizes
+        self.segment_size = segment_size
+        self.gin_channels = gin_channels
+        self.ssl_dim = ssl_dim
+        self.emb_g = nn.Embedding(n_speakers, gin_channels)
+
+        self.enc_p_ = TextEncoder(ssl_dim, inter_channels, hidden_channels, 5, 1, 16, 0, filter_channels, n_heads,
+                                  p_dropout)
+        hps = {
+            "sampling_rate": 32000,
+            "inter_channels": 192,
+            "resblock": "1",
+            "resblock_kernel_sizes": [3, 7, 11],
+            "resblock_dilation_sizes": [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+            "upsample_rates": [10, 8, 2, 2],
+            "upsample_initial_channel": 512,
+            "upsample_kernel_sizes": [16, 16, 4, 4],
+            "gin_channels": 256,
+        }
+        self.dec = Generator(h=hps)
+        self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
+        self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
+
+    def forward(self, c, f0, spec, g=None, mel=None, c_lengths=None, spec_lengths=None):
+        # hubert特征(b,256,frame_num), f0 (frame_num), 幅度谱特征, 说话人id,mel谱特征
+        if c_lengths == None:
+            c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)  # [frame_num,....]
+        if spec_lengths == None:
+            spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)
+
+        # 说话人信息embding
+        g = self.emb_g(g).transpose(1, 2)
+
+        # 采样得到的z,vae需要的均值，logs_p是vae需要的log(sigma)
+        # 输入hubert特征(b,256,frame_num), f0 (frame_num)，对应的是文本出隐变量的那段模型
+        z_ptemp, m_p, logs_p, _ = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
+
+        # 输入幅度谱和说话人信息
+        # 输出采样得到的z，m_q是均值，logs_q是log(sigma)
+        z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
+
+        # 标准化流，增加分布复杂程度
+        z_p = self.flow(z, spec_mask, g=g)
+        # 由于整个batch中含有的音频帧数不一致，要求每一个元素都随机裁剪出segment_size长度的特征
+        # 返回z的batch列表，pitch_slice列表和ids_slice的列表
+        z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)
+
+        # o = self.dec(z_slice, g=g)
+        # 解码部分，输入未经过标准化的z,以及说话人信息和pitch，得到wav波形
+        o = self.dec(z_slice, g=g, f0=pitch_slice)
+
+        # 原始波形,批次中每个采样到的帧的位置,批次中幅度谱的有效帧位置，
+        # 幅度谱编码得到正态分布后随机采样得到的z, z经过标准化流之后得到z_p, hubert特征层得到的正态分布的均值，
+        # hubert特征层得到的正态分布的标准差(logs_p)，幅度谱和人声信息得到的均值(m_q),幅度谱和人声信息得到的标准差(logs_q)
+        return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
+
+    def infer(self, c, f0, g=None, mel=None, c_lengths=None):
+        # hubert特征(b,256,frame_num), f0 (frame_num), 说话人id, mel谱特征
+        if c_lengths == None:
+            c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)  # [frame_num,....]
+
+        # 说话人信息经过embdding
+        g = self.emb_g(g).transpose(1, 2)
+
+        # 采样得到的z,vae需要的均值，logs_p是vae需要的log(sigma)
+        # 输入hubert特征(b,256,frame_num), f0 (frame_num)
+        # 其中c_mask的内容是由于每个batch中的元素的frame_num有可能不一致长，所以使用c_mask保证每个元素都能训练到自己的所有信息
+        z_p, m_p, logs_p, c_mask = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
+
+        # 将说话人和采样到的z信息塞入到标准化流中
+        z = self.flow(z_p, c_mask, g=g, reverse=True)
+
+        # 解码得到波形信息
+        o = self.dec(z * c_mask, g=g, f0=f0)
+
+        return o
+
+    def infer_v1(self, c, spec, f0, g):
+        print(c.shape, spec.shape, f0.shape, g.shape)
+        c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)  # (b, frame_num)
+        spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)
+        g = self.emb_g(g).transpose(1, 2)
+
+        # z_p, m_p, logs_p, c_mask = self.enc_p_(c, c_lengths, f0=f0_to_coarse(f0))
+        # z = self.flow(z_p, c_mask, g=g, reverse=True)
+        # o = self.dec(z * c_mask, g=g, f0=f0)
+        # print(c_mask.shape, c_mask)
+        z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g)
+        o = self.dec(z, g=g, f0=f0)
+        return o
+
+
+if __name__ == '__main__':
+    # m = MultiPeriodDiscriminator()
+    # y = torch.rand((1, 1, 96000))
+    # y_hat = torch.rand((1, 1, 96000))
+    # a, b, c, d = m(y, y_hat)
+
+    t1 = DiscriminatorS()
+    y = torch.rand(1, 1, 512)
+    a, b = t1(y)
+    print(a.shape)
diff --git a/AutoCoverTool/ref/so_vits_svc/train.py b/AutoCoverTool/ref/so_vits_svc/train.py
index 4fcc72a..ace0928 100644
--- a/AutoCoverTool/ref/so_vits_svc/train.py
+++ b/AutoCoverTool/ref/so_vits_svc/train.py
@@ -1,304 +1,305 @@
 import logging
 
 logging.getLogger('matplotlib').setLevel(logging.WARNING)
 import os
 import json
 import argparse
 import itertools
 import math
 import torch
 from torch import nn, optim
 from torch.nn import functional as F
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 import torch.multiprocessing as mp
 import torch.distributed as dist
 from torch.nn.parallel import DistributedDataParallel as DDP
 from torch.cuda.amp import autocast, GradScaler
 
 import commons
 import utils
 from data_utils import TextAudioSpeakerLoader, EvalDataLoader
 from models import (
     SynthesizerTrn,
     MultiPeriodDiscriminator,
 )
 from losses import (
     kl_loss,
     generator_loss, discriminator_loss, feature_loss
 )
 
 from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
 
 torch.backends.cudnn.benchmark = True
 global_step = 0
 
 
 # os.environ['TORCH_DISTRIBUTED_DEBUG'] = 'INFO'
 
 
 def main():
     """Assume Single Node Multi GPUs Training Only"""
     assert torch.cuda.is_available(), "CPU training is not allowed."
     hps = utils.get_hparams()
 
     n_gpus = torch.cuda.device_count()
     os.environ['MASTER_ADDR'] = 'localhost'
     os.environ['MASTER_PORT'] = hps.train.port
 
     mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,))
 
 
 def run(rank, n_gpus, hps):
     print("CurRank:===>", rank)
     global global_step
     if rank == 0:
         logger = utils.get_logger(hps.model_dir)
         logger.info(hps)
         utils.check_git_hash(hps.model_dir)
         writer = SummaryWriter(log_dir=hps.model_dir)
         writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
 
     dist.init_process_group(backend='nccl', init_method='env://', world_size=n_gpus, rank=rank)
     torch.manual_seed(hps.train.seed)
     torch.cuda.set_device(rank)
 
     # 从每段音频文件中获取特征
     # hubert特征,f0,幅度谱特征,对应音频段波形(384 * hop_length),人声编码[0],每一次获取3840ms长度的特征
     train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps)
     train_loader = DataLoader(train_dataset, num_workers=8, shuffle=False, pin_memory=True,
                               batch_size=hps.train.batch_size)
     if rank == 0:
         eval_dataset = EvalDataLoader(hps.data.validation_files, hps)
         eval_loader = DataLoader(eval_dataset, num_workers=1, shuffle=False,
                                  batch_size=1, pin_memory=False,
                                  drop_last=False)
 
     net_g = SynthesizerTrn(
         hps.data.filter_length // 2 + 1,
         hps.train.segment_size // hps.data.hop_length,
         **hps.model).cuda(rank)
     net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).cuda(rank)
     optim_g = torch.optim.AdamW(
         net_g.parameters(),
         hps.train.learning_rate,
         betas=hps.train.betas,
         eps=hps.train.eps)
     optim_d = torch.optim.AdamW(
         net_d.parameters(),
         hps.train.learning_rate,
         betas=hps.train.betas,
         eps=hps.train.eps)
     net_g = DDP(net_g, device_ids=[rank])  # , find_unused_parameters=True)
     net_d = DDP(net_d, device_ids=[rank])
 
     try:
         _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g,
                                                    optim_g)
         _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d,
                                                    optim_d)
         global_step = (epoch_str - 1) * len(train_loader)
         print("load checkpoint ok !")
     except:
         epoch_str = 1
         global_step = 0
 
     scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
     scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
 
     scaler = GradScaler(enabled=hps.train.fp16_run)
 
     for epoch in range(epoch_str, hps.train.epochs + 1):
         if rank == 0:
             train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler,
                                [train_loader, eval_loader], logger, [writer, writer_eval])
         else:
             train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler,
                                [train_loader, None], None, None)
         scheduler_g.step()
         scheduler_d.step()
 
 
 def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers):
     net_g, net_d = nets
     optim_g, optim_d = optims
     scheduler_g, scheduler_d = schedulers
     train_loader, eval_loader = loaders
     if writers is not None:
         writer, writer_eval = writers
 
     # train_loader.batch_sampler.set_epoch(epoch)
     global global_step
 
     net_g.train()
     net_d.train()
     for batch_idx, items in enumerate(train_loader):
         # hubert特征,f0,幅度谱特征,对应音频段波形(384 * hop_length),人声编码[0]
         c, f0, spec, y, spk = items
         g = spk.cuda(rank, non_blocking=True)
         spec, y = spec.cuda(rank, non_blocking=True), y.cuda(rank, non_blocking=True)
         c = c.cuda(rank, non_blocking=True)
         f0 = f0.cuda(rank, non_blocking=True)
         """
         "sampling_rate": 32000,
         "filter_length": 1280,
         "hop_length": 320,
         "win_length": 1280,
         "n_mel_channels": 80,
         "mel_fmin": 0.0,
         "mel_fmax": null
         """
         mel = spec_to_mel_torch(
             spec,
             hps.data.filter_length,
             hps.data.n_mel_channels,
             hps.data.sampling_rate,
             hps.data.mel_fmin,
             hps.data.mel_fmax)
 
         with autocast(enabled=hps.train.fp16_run):
             # net_g的输入: hubert特征,f0,幅度谱特征,说话人id,mel谱特征
             # net_g的输出:
             # 原始波形,批次中每个采样到的帧的位置,批次中幅度谱的有效帧位置，
             # 幅度谱编码得到正态分布后随机采样得到的z, z经过标准化流之后得到z_p, hubert特征层得到的正态分布的均值，
             # hubert特征层得到的正态分布的标准差(logs_p)，幅度谱和人声信息得到的均值(m_q),幅度谱和人声信息得到的标准差(logs_q)
             y_hat, ids_slice, z_mask, \
             (z, z_p, m_p, logs_p, m_q, logs_q) = net_g(c, f0, spec, g=g, mel=mel)
 
             y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length)
             y_hat_mel = mel_spectrogram_torch(
                 y_hat.squeeze(1),
                 hps.data.filter_length,
                 hps.data.n_mel_channels,
                 hps.data.sampling_rate,
                 hps.data.hop_length,
                 hps.data.win_length,
                 hps.data.mel_fmin,
                 hps.data.mel_fmax
             )
             y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size)  # slice
 
             # Discriminator
             y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
 
             with autocast(enabled=False):
                 loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g)
                 loss_disc_all = loss_disc
 
         optim_d.zero_grad()
         scaler.scale(loss_disc_all).backward()
         scaler.unscale_(optim_d)
         grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
         scaler.step(optim_d)
 
         with autocast(enabled=hps.train.fp16_run):
             # Generator
             y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat)
             with autocast(enabled=False):
                 # mel谱之间的损失函数，后面是系数，误差越小越好
                 loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
-                #
+                # KL散度,z_p: 幅度谱侧得到的采样值经过标准化流之后的结果，logs_q: 幅度谱侧得到的标准差,m_p:hubert侧得到的均值
+                # logs_p: hubert侧得到的标准差,z_mask: 批次中幅度谱的有效帧位置，
                 loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
+                # 在d模型中将y和y_hat的每一层特征结果都拿出来，做l1距离
                 loss_fm = feature_loss(fmap_r, fmap_g)
                 loss_gen, losses_gen = generator_loss(y_d_hat_g)
                 loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
         optim_g.zero_grad()
         scaler.scale(loss_gen_all).backward()
         scaler.unscale_(optim_g)
         grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
         scaler.step(optim_g)
         scaler.update()
 
         if rank == 0:
             if global_step % hps.train.log_interval == 0:
                 lr = optim_g.param_groups[0]['lr']
                 losses = [loss_disc, loss_gen, loss_fm, loss_mel, loss_kl]
                 logger.info('Train Epoch: {} [{:.0f}%]'.format(
                     epoch,
                     100. * batch_idx / len(train_loader)))
                 logger.info([x.item() for x in losses] + [global_step, lr])
 
                 scalar_dict = {"loss/g/total": loss_gen_all, "loss/d/total": loss_disc_all, "learning_rate": lr,
                                "grad_norm_d": grad_norm_d, "grad_norm_g": grad_norm_g}
                 scalar_dict.update({"loss/g/fm": loss_fm, "loss/g/mel": loss_mel, "loss/g/kl": loss_kl})
 
                 scalar_dict.update({"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)})
                 scalar_dict.update({"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)})
                 scalar_dict.update({"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)})
                 image_dict = {
                     "slice/mel_org": utils.plot_spectrogram_to_numpy(y_mel[0].data.cpu().numpy()),
                     "slice/mel_gen": utils.plot_spectrogram_to_numpy(y_hat_mel[0].data.cpu().numpy()),
                     "all/mel": utils.plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()),
                 }
 
                 utils.summarize(
                     writer=writer,
                     global_step=global_step,
                     images=image_dict,
                     scalars=scalar_dict
                 )
 
             if global_step % hps.train.eval_interval == 0:
                 evaluate(hps, net_g, eval_loader, writer_eval)
                 utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch,
                                       os.path.join(hps.model_dir, "G_{}.pth".format(global_step)))
                 utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch,
                                       os.path.join(hps.model_dir, "D_{}.pth".format(global_step)))
         global_step += 1
-        logger.info('Debug..... ====> Epoch: {},{}'.format(epoch, global_step))
 
     if rank == 0:
         logger.info('====> Epoch: {},{}'.format(epoch, global_step))
 
 
 def evaluate(hps, generator, eval_loader, writer_eval):
     generator.eval()
     image_dict = {}
     audio_dict = {}
     with torch.no_grad():
         for batch_idx, items in enumerate(eval_loader):
             c, f0, spec, y, spk = items
             g = spk[:1].cuda(0)
             spec, y = spec[:1].cuda(0), y[:1].cuda(0)
             c = c[:1].cuda(0)
             f0 = f0[:1].cuda(0)
             mel = spec_to_mel_torch(
                 spec,
                 hps.data.filter_length,
                 hps.data.n_mel_channels,
                 hps.data.sampling_rate,
                 hps.data.mel_fmin,
                 hps.data.mel_fmax)
             y_hat = generator.module.infer(c, f0, g=g, mel=mel)
 
             y_hat_mel = mel_spectrogram_torch(
                 y_hat.squeeze(1).float(),
                 hps.data.filter_length,
                 hps.data.n_mel_channels,
                 hps.data.sampling_rate,
                 hps.data.hop_length,
                 hps.data.win_length,
                 hps.data.mel_fmin,
                 hps.data.mel_fmax
             )
 
             audio_dict.update({
                 f"gen/audio_{batch_idx}": y_hat[0],
                 f"gt/audio_{batch_idx}": y[0]
             })
         image_dict.update({
             f"gen/mel": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()),
             "gt/mel": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())
         })
     utils.summarize(
         writer=writer_eval,
         global_step=global_step,
         images=image_dict,
         audios=audio_dict,
         audio_sampling_rate=hps.data.sampling_rate
     )
     generator.train()
 
 
 if __name__ == "__main__":
     main()
diff --git a/AutoCoverTool/script/get_song_url.py b/AutoCoverTool/script/get_song_url.py
index d158e99..538b620 100644
--- a/AutoCoverTool/script/get_song_url.py
+++ b/AutoCoverTool/script/get_song_url.py
@@ -1,4880 +1,517 @@
 """
 获取歌曲的地址
 
 # song_src=2 是来源108和109的歌曲，未被洗过的
 # song_src=1 是曲库给的
 # song_src=3 # 用于轻变调的
 """
 from script.common import *
 from copy import deepcopy
 from online.common import update_db
 
 
 def get_url_by_song_id(song_id):
     sql = "select task_url,starmaker_songid from silence where starmaker_songid = {} order by task_id desc limit 1".format(
         song_id)
     ban = deepcopy(banned_user_map)
     ban["db"] = "starmaker_musicbook"
     data = get_data_by_mysql(sql, ban)
     if len(data) > 0:
         return data[0][0]
     return None
 
 
 def process():
     arr = [
-        "611752105022730783",
-        "611752105022784310",
-        "611752105020374044",
-        "611752105022735198",
-        "611752105022775027",
-        "611752105022754495",
-        "611752105022766008",
-        "611752105022766505",
-        "611752105022739297",
-        "611752105022739703",
-        "611752105022771608",
-        "611752105022779149",
-        "611752105022751483",
-        "611752105022616052",
-        "611752105022752080",
-        "611752105030487427",
-        "611752105022784335",
-        "611752105022777418",
-        "611752105026536887",
-        "611752105024692685",
-        "611752105030533594",
-        "611752105024380131",
-        "611752105030533590",
-        "611752105023164720",
-        "611752105022785156",
-        "611752105030533593",
-        "611752105022775126",
-        "611752105022770837",
-        "611752105022730823",
-        "611752105022738512",
-        "611752105022764562",
-        "611752105022745811",
-        "611752105022775949",
-        "611752105022739186",
-        "611752105022742420",
-        "611752105022777145",
-        "611752105022745840",
-        "611752105022784340",
-        "611752105022727935",
-        "611752105022784307",
-        "611752105030487439",
-        "611752105022765308",
-        "611752105022766816",
-        "611752105022784309",
-        "611752105022751474",
-        "611752105022784338",
-        "611752105030487431",
-        "611752105022751039",
-        "611752105022756142",
-        "611752105022784321",
-        "611752105022759049",
-        "611752105022784302",
-        "611752105030487432",
-        "611752105022784337",
-        "611752105030487426",
-        "611752105022765307",
-        "611752105022728053",
-        "611752105027802534",
-        "611752105030487423",
-        "611752105030534639",
-        "611752105029695264",
-        "611752105030534631",
-        "611752105022753598",
-        "611752105030535120",
-        "611752105022753599",
-        "611752105030535124",
-        "611752105022752072",
-        "611752105030535121",
-        "611752105030487418",
-        "611752105030535118",
-        "611752105022753606",
-        "611752105030502746",
-        "611752105022735046",
-        "611752105030535115",
-        "611752105022753615",
-        "611752105030535116",
-        "611752105029753873",
-        "611752105024996260",
-        "611752105022752070",
-        "611752105030535114",
-        "611752105022735043",
-        "611752105024099233",
-        "611752105029753875",
-        "611752105030535112",
-        "611752105022752064",
-        "611752105030535043",
-        "611752105022616312",
-        "611752105022647078",
-        "611752105022753380",
-        "611752105022842728",
-        "611752105022752071",
-        "611752105030533599",
-        "611752105022753595",
-        "611752105022839263",
-        "611752105030487416",
-        "611752105022838771",
-        "611752105022752856",
-        "611752105030535109",
-        "611752105022819633",
-        "611752105022785564",
-        "611752105022785285",
-        "611752105022784063",
-        "611752105022783270",
-        "611752105030535107",
-        "611752105022779125",
-        "611752105022785106",
-        "611752105029706916",
-        "611752105022614185",
-        "611752105015224256",
-        "611752105022745268",
-        "611752105022772649",
-        "611752105020334522",
-        "611752105022739227",
-        "611752105022741315",
-        "611752105022758836",
-        "611752105022772222",
-        "611752105022730875",
-        "611752105022738303",
-        "611752105022731627",
-        "611752105026284669",
-        "611752105022746804",
-        "611752105030535102",
-        "611752105022766574",
-        "611752105022741948",
-        "611752105030535106",
-        "611752105022753033",
-        "611752105030535098",
-        "611752105022766129",
-        "611752105022731434",
-        "611752105022616504",
-        "611752105022746133",
-        "611752105030533585",
-        "611752105022766813",
-        "611752105030502742",
-        "611752105022743324",
-        "611752105022736599",
-        "611752105022729066",
-        "611752105022838930",
-        "611752105022749158",
-        "611752105030535099",
-        "611752105030535096",
-        "611752105030535093",
-        "611752105030535090",
-        "611752105030535086",
-        "611752105030533605",
-        "611752105030535085",
-        "611752105030535083",
-        "611752105030535077",
-        "611752105030535084",
-        "611752105024269546",
-        "611752105030529370",
-        "611752105030535080",
-        "611752105022733539",
-        "611752105022729645",
-        "611752105022843380",
-        "611752105022841941",
-        "611752105022614911",
-        "611752105022783493",
-        "611752105022781971",
-        "611752105030535074",
-        "611752105030535076",
-        "611752105030535070",
-        "611752105030535068",
-        "611752105030535065",
-        "611752105030535069",
-        "611752105030535062",
-        "611752105022735164",
-        "611752105029398847",
-        "611752105022614946",
-        "611752105030535060",
-        "611752105022613730",
-        "611752105022764737",
-        "611752105022776519",
-        "611752105022753605",
-        "611752105022741290",
-        "611752105022762976",
-        "611752105022736270",
-        "611752105030535063",
-        "611752105022727860",
-        "611752105022743493",
-        "611752105030502975",
-        "611752105030502976",
-        "611752105030502972",
-        "611752105030477337",
-        "611752105026751708",
-        "611752105022733308",
-        "611752105025048454",
-        "611752105030502971",
-        "611752105030494892",
-        "611752105022728227",
-        "611752105030502973",
-        "611752105024938914",
-        "611752105022973052",
-        "611752105030487442",
-        "611752105022999725",
-        "611752105022746885",
-        "611752105022813071",
-        "611752105022842737",
-        "611752105022839630",
-        "611752105022776794",
-        "611752105022782001",
-        "611752105022614979",
-        "611752105022759047",
-        "611752105030502965",
-        "611752105022781978",
-        "611752105022740861",
-        "611752105022770970",
-        "611752105022770497",
-        "611752105022736167",
-        "611752105030487436",
-        "611752105022731734",
-        "611752105022735483",
-        "611752105022739221",
-        "611752105022864484",
-        "611752105030477353",
-        "611752105022729556",
-        "611752105022741814",
-        "611752105022767054",
-        "611752105022729548",
-        "611752105022742630",
-        "611752105022777638",
-        "611752105030477339",
-        "611752105030477341",
-        "611752105022743933",
-        "611752105030477345",
-        "611752105022744719",
-        "611752105022615911",
-        "611752105030477347",
-        "611752105022745714",
-        "611752105022763471",
-        "611752105022778126",
-        "611752105022730841",
-        "611752105022730085",
-        "611752105030477349",
-        "611752105022730084",
-        "611752105030477351",
-        "611752105022729550",
-        "611752105030477352",
-        "611752105030502964",
-        "611752105022752849",
-        "611752105022745703",
-        "611752105030502963",
-        "611752105022842469",
-        "611752105022781979",
-        "611752105022781983",
-        "611752105022735916",
-        "611752105022842471",
-        "611752105022752843",
-        "611752105022738322",
-        "611752105022741806",
-        "611752105022750997",
-        "611752105022842481",
-        "611752105022842465",
-        "611752105030502959",
-        "611752105022785196",
-        "611752105022752850",
-        "611752105022753660",
-        "611752105022842468",
-        "611752105022730643",
-        "611752105030494903",
-        "611752105022753074",
-        "611752105022764508",
-        "611752105022615623",
-        "611752105022752858",
-        "611752105022612502",
-        "611752105030535054",
-        "611752105022752814",
-        "611752105022730898",
-        "611752105030535053",
-        "611752105022728109",
-        "611752105030535049",
-        "611752105030535051",
-        "611752105022738463",
-        "611752105030535048",
-        "611752105030533603",
-        "611752105030533606",
-        "611752105029380722",
-        "611752105022730730",
-        "611752105030533601",
-        "611752105023016037",
-        "611752105030533596",
-        "611752105022779121",
-        "611752105022842795",
-        "611752105022779281",
-        "611752105022730833",
-        "611752105029753881",
-        "611752105030487420",
-        "611752105030487411",
-        "611752105022750068",
-        "611752105022776918",
-        "611752105022843481",
-        "611752105022751195",
-        "611752105022769999",
-        "611752105022735951",
-        "611752105030487414",
-        "611752105030487410",
-        "611752105022744003",
-        "611752105030487403",
-        "611752105030487401",
-        "611752105022757037",
-        "611752105030487399",
-        "611752105030487398",
-        "611752105022784313",
-        "611752105022751027",
-        "611752105022739102",
-        "611752105022741815",
-        "611752105022751016",
-        "611752105030487400",
-        "611752105022784336",
-        "611752105022751014",
-        "611752105022784312",
-        "611752105022759050",
-        "611752105022751029",
-        "611752105022784343",
-        "611752105022784298",
-        "611752105022751028",
-        "611752105022823675",
-        "611752105022617183",
-        "611752105022765303",
-        "611752105022751038",
-        "611752105022784303",
-        "611752105030487396",
-        "611752105022784297",
-        "611752105030535162",
-        "611752105030535158",
-        "611752105029701043",
-        "611752105030535163",
-        "611752105030535152",
-        "611752105030535157",
-        "611752105030535149",
-        "611752105030535145",
-        "611752105030535142",
-        "611752105026351458",
-        "611752105030535146",
-        "611752105030535139",
-        "611752105026134338",
-        "611752105030503021",
-        "611752105030535140",
-        "611752105030535132",
-        "611752105030535137",
-        "611752105030535131",
-        "611752105025250773",
-        "611752105025142588",
-        "611752105030535127",
-        "611752105030535129",
-        "611752105030535125",
-        "611752105030517798",
-        "611752105030535126",
-        "611752105030502969",
-        "611752105030517793",
-        "611752105030517791",
-        "611752105030517787",
-        "611752105030517789",
-        "611752105030517782",
-        "611752105030517778",
-        "611752105025453401",
-        "611752105030517779",
-        "611752105023164721",
-        "611752105022841724",
-        "611752105022889136",
-        "611752105029665040",
-        "611752105022837923",
-        "611752105022783624",
-        "611752105022781230",
-        "611752105022779675",
-        "611752105022779162",
-        "611752105022775495",
-        "611752105022769637",
-        "611752105022766828",
-        "611752105022763781",
-        "611752105022728556",
-        "611752105030517769",
-        "611752105022741908",
-        "611752105022771364",
-        "611752105030517770",
-        "611752105030747658",
-        "611752105022838496",
-        "611752105030539016",
-        "611752105030539005",
-        "611752105030539006",
-        "611752105030538995",
-        "611752105030486233",
-        "611752105029470644",
-        "611752105029914428",
-        "611752105029290560",
-        "611752105030538988",
-        "611752105029558802",
-        "611752105030538990",
-        "611752105030538987",
-        "611752105030538983",
-        "611752105030538985",
-        "611752105029290561",
-        "611752105030538977",
-        "611752105030538979",
-        "611752105030484868",
-        "611752105030538974",
-        "611752105029290548",
-        "611752105030538970",
-        "611752105030538973",
-        "611752105030538966",
-        "611752105029306951",
-        "611752105030486239",
-        "611752105030538968",
-        "611752105030538963",
-        "611752105029290551",
-        "611752105030538961",
-        "611752105030538959",
-        "611752105028450911",
-        "611752105030538958",
-        "611752105030538954",
-        "611752105030538957",
-        "611752105030538951",
-        "611752105030534247",
-        "611752105030538944",
-        "611752105030538946",
-        "611752105030313355",
-        "611752105030538941",
-        "611752105030538938",
-        "611752105030538940",
-        "611752105029290542",
-        "611752105030538936",
-        "611752105030484865",
-        "611752105030538934",
-        "611752105030538933",
-        "611752105030538932",
-        "611752105030538927",
-        "611752105030484872",
-        "611752105030538929",
-        "611752105030538924",
-        "611752105029290553",
-        "611752105030538921",
-        "611752105030659997",
-        "611752105030538923",
-        "611752105030538702",
-        "611752105030538912",
-        "611752105030538916",
-        "611752105030538915",
-        "611752105030538908",
-        "611752105030538906",
-        "611752105029290557",
-        "611752105030538907",
-        "611752105030538910",
-        "611752105029734060",
-        "611752105030538707",
-        "611752105030538903",
-        "611752105030538905",
-        "611752105030538900",
-        "611752105030487276",
-        "611752105030487285",
-        "611752105030487272",
-        "611752105030487274",
-        "611752105022780230",
-        "611752105030487275",
-        "611752105030484864",
-        "611752105030487267",
-        "611752105030487265",
-        "611752105030487260",
-        "611752105030487258",
-        "611752105025046605",
-        "611752105030747660",
-        "611752105028958736",
-        "611752105030713240",
-        "611752105030602192",
-        "611752105029096484",
-        "611752105030747657",
-        "611752105027795232",
-        "611752105030602182",
-        "611752105030485412",
-        "611752105030747654",
-        "611752105030747656",
-        "611752105030747653",
-        "611752105027924490",
-        "611752105030737388",
-        "611752105030577647",
-        "611752105030747648",
-        "611752105030747651",
-        "611752105030747644",
-        "611752105028432736",
-        "611752105030747646",
-        "611752105030747641",
-        "611752105027239739",
-        "611752105030747643",
-        "611752105030747639",
-        "611752105030747640",
-        "611752105030730926",
-        "611752105028032122",
-        "611752105030747635",
-        "611752105026580842",
-        "611752105027435139",
-        "611752105030602173",
-        "611752105030747632",
-        "611752105030747633",
-        "611752105030747628",
-        "611752105026649662",
-        "611752105030747631",
-        "611752105030747624",
-        "611752105030602111",
-        "611752105025380252",
-        "611752105022759665",
-        "611752105030534540",
-        "611752105030747622",
-        "611752105030631092",
-        "611752105030747625",
-        "611752105030631088",
-        "611752105030572346",
-        "611752105029481513",
-        "611752105029054061",
-        "611752105030747618",
-        "611752105030587776",
-        "611752105030747616",
-        "611752105030572339",
-        "611752105030747614",
-        "611752105030747610",
-        "611752105030679652",
-        "611752105030747612",
-        "611752105030747606",
-        "611752105030747608",
-        "611752105030747603",
-        "611752105025499615",
-        "611752105024628017",
-        "611752105030643920",
-        "611752105030747605",
-        "611752105024130115",
-        "611752105030747599",
-        "611752105030747602",
-        "611752105030585146",
-        "611752105030747596",
-        "611752105030747598",
-        "611752105030747595",
-        "611752105022840811",
-        "611752105022768985",
-        "611752105022732380",
-        "611752105030589786",
-        "611752105030747591",
-        "611752105030747589",
-        "611752105022753966",
-        "611752105030668436",
-        "611752105030723499",
-        "611752105030747587",
-        "611752105022613095",
-        "611752105030747584",
-        "611752105022779993",
-        "611752105022749037",
-        "611752105030747588",
-        "611752105022748996",
-        "611752105022760320",
-        "611752105022783177",
-        "611752105022778496",
-        "611752105030747581",
-        "611752105022775467",
-        "611752105030747583",
-        "611752105022616238",
-        "611752105022833930",
-        "611752105027626963",
-        "611752105030747576",
-        "611752105029680362",
-        "611752105030747579",
-        "611752105028995523",
-        "611752105030679645",
-        "611752105030747573",
-        "611752105030693292",
-        "611752105030747569",
-        "611752105030747437",
-        "611752105030747432",
-        "611752105030662284",
-        "611752105030643678",
-        "611752105023730119",
-        "611752105030648174",
-        "611752105030747434",
-        "611752105030747427",
-        "611752105030747424",
-        "611752105029676413",
-        "611752105030747422",
-        "611752105030747421",
-        "611752105030747418",
-        "611752105024263899",
-        "611752105025621591",
-        "611752105022729308",
-        "611752105022616340",
-        "611752105025557474",
-        "611752105030747691",
-        "611752105030747685",
-        "611752105030747682",
-        "611752105030747680",
-        "611752105030747678",
-        "611752105030747675",
-        "611752105030747677",
-        "611752105030747674",
-        "611752105030747672",
-        "611752105030747671",
-        "611752105030747667",
-        "611752105030747670",
-        "611752105022733167",
-        "611752105030747664",
-        "611752105030747662",
-        "611752105022843477",
-        "611752105030747665",
-        "611752105022842608",
-        "611752105025045376",
-        "611752105022840340",
-        "611752105030747570",
-        "611752105030747567",
-        "611752105030747568",
-        "611752105030747565",
-        "611752105030747560",
-        "611752105030747564",
-        "611752105030747559",
-        "611752105030747554",
-        "611752105030747557",
-        "611752105030602129",
-        "611752105030747549",
-        "611752105030747550",
-        "611752105030747544",
-        "611752105030747547",
-        "611752105030747548",
-        "611752105030747542",
-        "611752105030577983",
-        "611752105030747537",
-        "611752105030747540",
-        "611752105030747534",
-        "611752105030747530",
-        "611752105030747532",
-        "611752105030747525",
-        "611752105030747526",
-        "611752105030747522",
-        "611752105030591092",
-        "611752105030630661",
-        "611752105030747517",
-        "611752105030679659",
-        "611752105030577986",
-        "611752105030630644",
-        "611752105029443805",
-        "611752105030516900",
-        "611752105030548082",
-        "611752105030649913",
-        "611752105030747521",
-        "611752105030747512",
-        "611752105030640773",
-        "611752105030747516",
-        "611752105030747507",
-        "611752105030747511",
-        "611752105030747417",
-        "611752105030544013",
-        "611752105022838658",
-        "611752105022779972",
-        "611752105022843508",
-        "611752105027081364",
-        "611752105030747501",
-        "611752105023329574",
-        "611752105030747502",
-        "611752105022843514",
-        "611752105025142592",
-        "611752105022616727",
-        "611752105030577605",
-        "611752105030747496",
-        "611752105030747494",
-        "611752105030747492",
-        "611752105030747495",
-        "611752105030747488",
-        "611752105030747489",
-        "611752105030538937",
-        "611752105030612827",
-        "611752105030747484",
-        "611752105028487816",
-        "611752105030747481",
-        "611752105030747482",
-        "611752105024643265",
-        "611752105022729273",
-        "611752105027460126",
-        "611752105030747477",
-        "611752105030747480",
-        "611752105027435144",
-        "611752105030747474",
-        "611752105030747467",
-        "611752105027239740",
-        "611752105027381087",
-        "611752105030747472",
-        "611752105030747462",
-        "611752105030747460",
-        "611752105030747455",
-        "611752105030747459",
-        "611752105022797962",
-        "611752105025741790",
-        "611752105030747450",
-        "611752105030747454",
-        "611752105023227300",
-        "611752105030747443",
-        "611752105030747445",
-        "611752105030747439",
-        "611752105027877860",
-        "611752105030747441",
-        "611752105023594218",
-        "611752105029896819",
-        "611752105030747435",
-        "611752105029810705",
-        "611752105027162350",
-        "611752105030747414",
-        "611752105030747769",
-        "611752105030747770",
-        "611752105027712296",
-        "611752105030747768",
-        "611752105030630693",
-        "611752105030630678",
-        "611752105030630669",
-        "611752105030679653",
-        "611752105030630680",
-        "611752105030630513",
-        "611752105030630687",
-        "611752105030630642",
-        "611752105030630660",
-        "611752105030737451",
-        "611752105030747763",
-        "611752105030585142",
-        "611752105030747765",
-        "611752105030630675",
-        "611752105030747761",
-        "611752105030747762",
-        "611752105028983072",
-        "611752105030747758",
-        "611752105030747753",
-        "611752105030747751",
-        "611752105030630741",
-        "611752105030747750",
-        "611752105030747744",
-        "611752105030747748",
-        "611752105030747742",
-        "611752105030747739",
-        "611752105028820622",
-        "611752105030747741",
-        "611752105030747733",
-        "611752105030679662",
-        "611752105030747735",
-        "611752105030648468",
-        "611752105030747730",
-        "611752105030747726",
-        "611752105030747727",
-        "611752105030747723",
-        "611752105030747719",
-        "611752105030747720",
-        "611752105030747718",
-        "611752105030543725",
-        "611752105030747714",
-        "611752105030747717",
-        "611752105025571121",
-        "611752105030585145",
-        "611752105030747713",
-        "611752105030747710",
-        "611752105030747712",
-        "611752105030747707",
-        "611752105030747705",
-        "611752105022784114",
-        "611752105030683802",
-        "611752105030747704",
-        "611752105030747703",
-        "611752105030747697",
-        "611752105030747700",
-        "611752105030606236",
-        "611752105030747696",
-        "611752105030747694",
-        "611752105030747692",
-        "611752105030747688",
-        "611752105022822679",
-        "611752105022839054",
-        "611752105030739870",
-        "611752105022784141",
-        "611752105022712661",
-        "611752105022829787",
-        "611752105022778445",
-        "611752105022839024",
-        "611752105022838519",
-        "611752105030739862",
-        "611752105022838293",
-        "611752105022838777",
-        "611752105022838764",
-        "611752105022785329",
-        "611752105022783808",
-        "611752105022784456",
-        "611752105030700228",
-        "611752105030739867",
-        "611752105029527203",
-        "611752105030739858",
-        "611752105030700215",
-        "611752105030486238",
-        "611752105028010207",
-        "611752105030739860",
-        "611752105030739855",
-        "611752105025293174",
-        "611752105030739856",
-        "611752105030739850",
-        "611752105024961728",
-        "611752105030739851",
-        "611752105025507981",
-        "611752105022864666",
-        "611752105030589600",
-        "611752105030653604",
-        "611752105022840012",
-        "611752105026578237",
-        "611752105022841049",
-        "611752105030649676",
-        "611752105030739846",
-        "611752105030739847",
-        "611752105030538964",
-        "611752105030739573",
-        "611752105030739576",
-        "611752105030739572",
-        "611752105030700206",
-        "611752105030700221",
-        "611752105030739567",
-        "611752105030739569",
+        "611752105030548048",
+        "611752105030548042",
+        "611752105030517085",
+        "611752105030485219",
+        "611752105030773591",
+        "611752105030629604",
+        "611752105029461042",
+        "611752105030629605",
+        "611752105030649282",
+        "611752105030773587",
+        "611752105030773586",
+        "611752105030773582",
+        "611752105030558704",
+        "611752105030773578",
+        "611752105028990750",
+        "611752105028477539",
+        "611752105030598726",
+        "611752105030485212",
+        "611752105027484914",
+        "611752105028450908",
+        "611752105027460090",
+        "611752105030773576",
+        "611752105030517080",
+        "611752105030588074",
+        "611752105030611002",
+        "611752105028413629",
+        "611752105030773572",
+        "611752105028778443",
+        "611752105026976871",
+        "611752105028102453",
+        "611752105030773569",
+        "611752105030588011",
+        "611752105028800798",
+        "611752105028477538",
+        "611752105030629642",
+        "611752105030487027",
+        "611752105029054058",
+        "611752105028497813",
+        "611752105028510639",
+        "611752105030548037",
+        "611752105030548041",
+        "611752105030486911",
+        "611752105030548021",
+        "611752105030553757",
+        "611752105029558659",
+        "611752105030487494",
+        "611752105029381727",
+        "611752105028975151",
+        "611752105030534119",
+        "611752105028427015",
+        "611752105030532828",
+        "611752105030501864",
+        "611752105028408815",
+        "611752105030486255",
+        "611752105029646790",
+        "611752105028932362",
+        "611752105030502067",
+        "611752105028975148",
+        "611752105030517536",
         "611752105030494683",
-        "611752105030700224",
         "611752105030630667",
-        "611752105028966242",
         "611752105030739634",
-        "611752105030589799",
         "611752105030547919",
         "611752105030577557",
-        "611752105030739558",
         "611752105030547903",
-        "611752105030739561",
         "611752105030547881",
-        "611752105029204264",
         "611752105030739633",
-        "611752105030559431",
         "611752105030630646",
-        "611752105030494659",
         "611752105030630615",
-        "611752105030700232",
         "611752105030488624",
-        "611752105030739552",
         "611752105030739630",
-        "611752105029334339",
         "611752105030630518",
-        "611752105030700283",
         "611752105030602720",
-        "611752105030628796",
         "611752105030739631",
-        "611752105030739538",
         "611752105030538997",
-        "611752105029848355",
         "611752105030739628",
-        "611752105030739534",
         "611752105030739625",
         "611752105030739626",
         "611752105030739623",
         "611752105030630616",
         "611752105030630498",
         "611752105030739620",
         "611752105030739842",
         "611752105030739840",
-        "611752105029543878",
         "611752105030739834",
         "611752105030739836",
         "611752105030739827",
         "611752105030700227",
         "611752105030739828",
         "611752105030589605",
         "611752105030679611",
         "611752105030739826",
-        "611752105029502254",
         "611752105030739821",
         "611752105030739824",
         "611752105030739820",
         "611752105030737424",
-        "611752105029290586",
-        "611752105029306946",
         "611752105030739814",
         "611752105030737420",
         "611752105030735716",
         "611752105030739816",
         "611752105030739813",
-        "611752105029041700",
         "611752105030713239",
-        "611752105028906603",
         "611752105030723574",
         "611752105030739809",
         "611752105030662427",
-        "611752105028932349",
         "611752105030739807",
         "611752105030737399",
         "611752105028778437",
         "611752105030739801",
         "611752105030739804",
         "611752105030739797",
-        "611752105030534736",
-        "611752105030739531",
-        "611752105030631126",
-        "611752105030739796",
-        "611752105030517874",
-        "611752105030631121",
-        "611752105030539007",
-        "611752105030692737",
-        "611752105030739791",
-        "611752105030631114",
-        "611752105030739792",
-        "611752105030739788",
-        "611752105030739785",
-        "611752105030739786",
-        "611752105030739783",
-        "611752105030739784",
-        "611752105030739779",
-        "611752105030630613",
-        "611752105030739775",
-        "611752105030739776",
-        "611752105030630512",
-        "611752105030739771",
-        "611752105030739772",
-        "611752105030739767",
-        "611752105030739765",
-        "611752105030739762",
-        "611752105030739763",
-        "611752105030672157",
-        "611752105030630665",
-        "611752105030739554",
-        "611752105030739760",
-        "611752105030534613",
-        "611752105030739754",
-        "611752105030739757",
-        "611752105030739749",
-        "611752105030519880",
-        "611752105030739752",
-        "611752105030739746",
-        "611752105030739744",
-        "611752105030739742",
-        "611752105030631107",
-        "611752105030631089",
-        "611752105030739743",
-        "611752105030534517",
-        "611752105030739739",
-        "611752105030630066",
-        "611752105030164618",
-        "611752105030739737",
-        "611752105030577570",
-        "611752105030739738",
-        "611752105030739555",
-        "611752105030630624",
-        "611752105030739735",
-        "611752105030630617",
-        "611752105027435142",
-        "611752105029621761",
-        "611752105030630508",
-        "611752105030485434",
-        "611752105030485414",
-        "611752105030577989",
-        "611752105030739732",
-        "611752105030737143",
-        "611752105030739734",
-        "611752105030739723",
-        "611752105030494697",
-        "611752105030630502",
-        "611752105030739725",
-        "611752105030739717",
-        "611752105030739718",
-        "611752105030739716",
-        "611752105030739710",
-        "611752105030739709",
-        "611752105022732282",
-        "611752105022729638",
-        "611752105030739705",
-        "611752105030739704",
-        "611752105030488557",
-        "611752105030641110",
-        "611752105030735714",
-        "611752105030739702",
-        "611752105029444009",
-        "611752105030739697",
-        "611752105030739699",
-        "611752105030216450",
-        "611752105030739618",
-        "611752105030735710",
-        "611752105030739619",
-        "611752105030739614",
-        "611752105030490625",
-        "611752105030733597",
-        "611752105030739616",
-        "611752105030614416",
-        "611752105029290619",
-        "611752105030739612",
-        "611752105030739611",
-        "611752105030739607",
-        "611752105030739610",
-        "611752105030739600",
-        "611752105030739603",
-        "611752105030739595",
-        "611752105030739598",
-        "611752105030739591",
-        "611752105030575386",
-        "611752105030736941",
-        "611752105030736836",
-        "611752105030739593",
-        "611752105030739586",
-        "611752105030739588",
-        "611752105030739585",
-        "611752105030739582",
-        "611752105030739578",
-        "611752105030739580",
-        "611752105030739890",
-        "611752105030739887",
-        "611752105030739888",
-        "611752105030534281",
-        "611752105022729365",
-        "611752105022733089",
-        "611752105030716930",
-        "611752105022842713",
-        "611752105022647096",
-        "611752105030544093",
-        "611752105030739882",
-        "611752105022842917",
-        "611752105022843732",
-        "611752105030739884",
-        "611752105022843512",
-        "611752105022842891",
-        "611752105022842479",
-        "611752105022841781",
-        "611752105030739880",
-        "611752105022841441",
-        "611752105022841086",
-        "611752105030739875",
-        "611752105022840983",
-        "611752105022841010",
-        "611752105030739877",
-        "611752105022840143",
-        "611752105022840600",
-        "611752105022840799",
-        "611752105022840146",
-        "611752105030739872",
-        "611752105030739869",
-        "611752105022840069",
-        "611752105030649702",
-        "611752105030425339",
-        "611752105030693300",
-        "611752105030669365",
-        "611752105030554004",
-        "611752105030739689",
-        "611752105030739690",
-        "611752105030577980",
-        "611752105030630619",
-        "611752105030739686",
-        "611752105030739688",
         "611752105030739684",
-        "611752105030538981",
-        "611752105030739681",
-        "611752105030538980",
-        "611752105030739676",
         "611752105030739677",
-        "611752105029395403",
-        "611752105030739674",
         "611752105030739671",
-        "611752105030538976",
-        "611752105030739669",
-        "611752105030739665",
         "611752105030739666",
-        "611752105030739660",
-        "611752105030739662",
-        "611752105029348040",
-        "611752105029306791",
-        "611752105030739656",
-        "611752105030739653",
-        "611752105026578358",
         "611752105030739655",
-        "611752105030739651",
-        "611752105030739647",
-        "611752105030739648",
-        "611752105030739644",
-        "611752105030722203",
-        "611752105030387728",
-        "611752105030739642",
-        "611752105030739641",
-        "611752105030739638",
-        "611752105025720326",
-        "611752105030538920",
-        "611752105030538952",
-        "611752105030538730",
-        "611752105030730929",
         "611752105030577995",
         "611752105030739636",
-        "611752105030693302",
-        "611752105030739695",
-        "611752105029395216",
-        "611752105028941759",
-        "611752105030739693",
-        "611752105030739692",
-        "611752105030630686",
         "611752105030631344",
-        "611752105030630676",
         "611752105030547885",
-        "611752105030486180",
-        "611752105030494718",
-        "611752105030631345",
-        "611752105030494705",
-        "611752105030631341",
-        "611752105030630668",
-        "611752105030577572",
-        "611752105030631343",
-        "611752105030631338",
-        "611752105030630688",
-        "611752105030631335",
-        "611752105030577597",
-        "611752105030644712",
-        "611752105030486151",
-        "611752105030631328",
-        "611752105030631326",
-        "611752105030631323",
-        "611752105030631320",
-        "611752105030486250",
-        "611752105030488644",
-        "611752105030631322",
-        "611752105030631318",
-        "611752105030631316",
-        "611752105030631317",
-        "611752105030533633",
-        "611752105030516912",
-        "611752105030560373",
-        "611752105030494657",
-        "611752105030488562",
-        "611752105030630682",
-        "611752105030602002",
-        "611752105030630654",
-        "611752105030486914",
         "611752105030631311",
-        "611752105030585149",
-        "611752105030602161",
-        "611752105030630656",
-        "611752105030631309",
         "611752105030486286",
-        "611752105030631310",
         "611752105030488567",
-        "611752105030631307",
-        "611752105030679669",
-        "611752105030631303",
-        "611752105030631306",
-        "611752105030631300",
-        "611752105030630640",
-        "611752105030544605",
-        "611752105030738536",
-        "611752105030631301",
-        "611752105030631297",
         "611752105030494668",
-        "611752105030488563",
-        "611752105030631299",
-        "611752105030494723",
-        "611752105030631296",
         "611752105030532592",
-        "611752105030631290",
-        "611752105030631292",
-        "611752105030547912",
-        "611752105030484616",
-        "611752105030631287",
-        "611752105030631289",
-        "611752105030631285",
-        "611752105030631279",
-        "611752105030631282",
-        "611752105030630652",
-        "611752105030539001",
-        "611752105030630639",
-        "611752105030630645",
-        "611752105030631275",
-        "611752105030631277",
-        "611752105030486165",
-        "611752105030631272",
-        "611752105030631266",
-        "611752105030631268",
-        "611752105030738661",
-        "611752105030631262",
-        "611752105029257583",
-        "611752105030577577",
         "611752105030478368",
         "611752105030487499",
-        "611752105029054053",
-        "611752105030693282",
-        "611752105030252056",
-        "611752105030738657",
-        "611752105029395215",
-        "611752105029590523",
-        "611752105029621758",
-        "611752105029395227",
-        "611752105029257580",
-        "611752105029636088",
-        "611752105030486043",
         "611752105030486028",
-        "611752105030486057",
-        "611752105029570158",
         "611752105030486182",
-        "611752105030486148",
-        "611752105030486140",
-        "611752105030486172",
-        "611752105027435143",
-        "611752105029481679",
-        "611752105028857401",
         "611752105030486156",
-        "611752105022616223",
-        "611752105030509266",
-        "611752105030667057",
-        "611752105022742646",
-        "611752105030738655",
-        "611752105030629373",
-        "611752105022739737",
-        "611752105022775125",
-        "611752105030738646",
-        "611752105030738648",
-        "611752105030738652",
-        "611752105030738644",
-        "611752105030738640",
-        "611752105030738642",
-        "611752105030738634",
-        "611752105030738637",
-        "611752105022782847",
-        "611752105022747757",
-        "611752105030738630",
-        "611752105022757850",
-        "611752105030678140",
-        "611752105022767966",
-        "611752105030738627",
-        "611752105022757574",
-        "611752105022839402",
-        "611752105022749251",
-        "611752105030738625",
-        "611752105030593862",
-        "611752105030738626",
-        "611752105030713471",
-        "611752105022781447",
-        "611752105022841562",
-        "611752105022780607",
-        "611752105020345842",
-        "611752105030738620",
-        "611752105022743661",
-        "611752105030637589",
-        "611752105030738623",
-        "611752105029729817",
-        "611752105022773291",
-        "611752105022840447",
-        "611752105020419054",
-        "611752105022782624",
-        "611752105022780332",
-        "611752105020366214",
-        "611752105022840802",
-        "611752105030630488",
-        "611752105030738617",
-        "611752105030602105",
-        "611752105030738612",
-        "611752105030700226",
-        "611752105030577568",
         "611752105030738611",
-        "611752105030738613",
-        "611752105030738610",
-        "611752105030738609",
-        "611752105030738604",
-        "611752105030738606",
-        "611752105030738601",
-        "611752105030738602",
-        "611752105030738596",
-        "611752105029348191",
         "611752105030704793",
-        "611752105029648899",
-        "611752105030704811",
-        "611752105030738594",
-        "611752105030630610",
-        "611752105030547878",
-        "611752105030738595",
-        "611752105029064399",
-        "611752105030739658",
-        "611752105030738590",
-        "611752105029290779",
-        "611752105030738587",
-        "611752105030738582",
-        "611752105030738584",
-        "611752105030738578",
-        "611752105030738575",
-        "611752105030738576",
-        "611752105030591101",
-        "611752105030738570",
-        "611752105030738572",
-        "611752105022780495",
-        "611752105022840442",
-        "611752105030738564",
-        "611752105029648896",
-        "611752105030738568",
-        "611752105030738559",
         "611752105030494860",
-        "611752105030738562",
-        "611752105030658916",
-        "611752105030738556",
-        "611752105030738667",
-        "611752105030738558",
-        "611752105030322343",
-        "611752105030738550",
-        "611752105030631398",
-        "611752105030602193",
-        "611752105030488643",
-        "611752105030602055",
-        "611752105030738664",
-        "611752105030738551",
-        "611752105030539011",
-        "611752105030738545",
-        "611752105030539012",
-        "611752105030738538",
-        "611752105030486249",
-        "611752105030577996",
-        "611752105030631395",
-        "611752105030631396",
-        "611752105030644711",
-        "611752105030631391",
-        "611752105030538999",
         "611752105030631392",
-        "611752105030630730",
-        "611752105030602082",
-        "611752105030630719",
-        "611752105030494650",
-        "611752105030631385",
-        "611752105030631387",
-        "611752105030631381",
-        "611752105030631377",
-        "611752105030631383",
-        "611752105030631372",
-        "611752105030630726",
-        "611752105030738668",
         "611752105030631373",
-        "611752105030631368",
-        "611752105030494648",
-        "611752105030631364",
-        "611752105030547896",
-        "611752105030494672",
-        "611752105030494688",
-        "611752105030631367",
         "611752105030547882",
-        "611752105030631361",
-        "611752105030631357",
-        "611752105030631359",
-        "611752105030631353",
-        "611752105030638519",
-        "611752105030486242",
         "611752105030534733",
-        "611752105030547901",
-        "611752105030532572",
-        "611752105030631355",
         "611752105030494745",
-        "611752105030631348",
-        "611752105030631351",
-        "611752105030486026",
-        "611752105022768338",
-        "611752105030750505",
-        "611752105022615735",
-        "611752105030750504",
-        "611752105022777541",
-        "611752105030750506",
-        "611752105030750500",
-        "611752105022876754",
-        "611752105022772027",
-        "611752105030750502",
-        "611752105022750336",
-        "611752105030750496",
-        "611752105030750497",
-        "611752105030750498",
-        "611752105022736406",
-        "611752105030570939",
-        "611752105030750492",
-        "611752105030750494",
-        "611752105030537150",
-        "611752105030750488",
-        "611752105030750486",
-        "611752105030750489",
-        "611752105030750377",
-        "611752105030750373",
-        "611752105030750375",
-        "611752105030750369",
-        "611752105030750370",
-        "611752105030750363",
-        "611752105030537105",
-        "611752105030750364",
-        "611752105030750362",
-        "611752105030750358",
-        "611752105030750360",
-        "611752105030750698",
-        "611752105030750699",
-        "611752105022781711",
-        "611752105029661970",
-        "611752105030750693",
-        "611752105022756530",
-        "611752105030590775",
-        "611752105030569708",
-        "611752105022772028",
-        "611752105022838409",
-        "611752105024765689",
-        "611752105030750695",
-        "611752105030750692",
-        "611752105022780264",
-        "611752105022775753",
-        "611752105026561502",
-        "611752105030750688",
-        "611752105030750691",
-        "611752105022779301",
-        "611752105022741321",
-        "611752105030750687",
-        "611752105030750686",
-        "611752105030750681",
-        "611752105022838915",
-        "611752105022734626",
-        "611752105030484434",
-        "611752105030750683",
-        "611752105030750678",
-        "611752105030551116",
-        "611752105030750386",
-        "611752105030750675",
-        "611752105030569717",
-        "611752105030750671",
-        "611752105030750379",
-        "611752105030750668",
-        "611752105030589601",
-        "611752105030750666",
-        "611752105030750483",
-        "611752105030750660",
-        "611752105030750485",
-        "611752105030750658",
-        "611752105023971172",
-        "611752105030750651",
-        "611752105030663172",
-        "611752105030750652",
-        "611752105030750478",
-        "611752105030750647",
-        "611752105030750480",
-        "611752105030750649",
-        "611752105030568324",
-        "611752105030750645",
-        "611752105030750476",
-        "611752105030750642",
-        "611752105030750474",
-        "611752105030750644",
-        "611752105030750472",
-        "611752105022771183",
-        "611752105030750465",
-        "611752105022785080",
-        "611752105030750469",
-        "611752105030750635",
-        "611752105022735256",
-        "611752105030750627",
-        "611752105030535284",
-        "611752105030750461",
-        "611752105030524630",
-        "611752105030524625",
-        "611752105030503257",
-        "611752105030524626",
-        "611752105030524611",
-        "611752105030524609",
-        "611752105030524608",
-        "611752105030524635",
-        "611752105030524605",
-        "611752105030524599",
-        "611752105022779984",
-        "611752105030524594",
-        "611752105030524587",
-        "611752105022777544",
-        "611752105030502932",
-        "611752105030524585",
-        "611752105030524584",
-        "611752105030518158",
-        "611752105030518152",
-        "611752105030518153",
-        "611752105030487786",
-        "611752105030487776",
-        "611752105030487778",
-        "611752105022735000",
-        "611752105030487772",
-        "611752105030533865",
-        "611752105030487767",
-        "611752105030487770",
-        "611752105030487765",
-        "611752105030518150",
-        "611752105030477621",
-        "611752105030477623",
-        "611752105030477620",
-        "611752105030477619",
-        "611752105030477617",
-        "611752105030477614",
-        "611752105030533866",
-        "611752105030477612",
-        "611752105030477607",
-        "611752105030477608",
-        "611752105030477602",
-        "611752105030750456",
-        "611752105030575498",
-        "611752105027757377",
-        "611752105027877850",
-        "611752105030750457",
-        "611752105029692389",
-        "611752105029740730",
-        "611752105029695550",
-        "611752105022805024",
-        "611752105022839294",
-        "611752105022803103",
-        "611752105029683095",
-        "611752105030750453",
-        "611752105022728733",
-        "611752105030750448",
-        "611752105022746774",
-        "611752105022775458",
-        "611752105022763424",
-        "611752105022752190",
-        "611752105030679428",
-        "611752105030655307",
-        "611752105022763403",
-        "611752105030750439",
-        "611752105030663166",
-        "611752105020396961",
-        "611752105022763777",
-        "611752105030554105",
-        "611752105030750436",
-        "611752105030750433",
-        "611752105026089756",
-        "611752105030750430",
-        "611752105030750431",
-        "611752105022736591",
-        "611752105030750426",
-        "611752105030750424",
-        "611752105030750427",
-        "611752105030750420",
-        "611752105030750419",
-        "611752105030750418",
-        "611752105030477436",
-        "611752105030750412",
-        "611752105030750413",
-        "611752105030750407",
-        "611752105030750409",
-        "611752105030750404",
-        "611752105030750405",
-        "611752105030536087",
-        "611752105030571069",
-        "611752105030750400",
-        "611752105030750392",
-        "611752105030571091",
-        "611752105030571067",
-        "611752105030750388",
-        "611752105030613548",
-        "611752105030633698",
-        "611752105030750391",
-        "611752105030750384",
-        "611752105030750574",
-        "611752105030750602",
-        "611752105030750595",
-        "611752105030552835",
-        "611752105030750597",
-        "611752105030750593",
-        "611752105030750588",
-        "611752105030750591",
-        "611752105030570917",
-        "611752105030750585",
-        "611752105030563098",
-        "611752105022729576",
-        "611752105030750582",
-        "611752105030750579",
-        "611752105030750583",
-        "611752105022841460",
-        "611752105022841342",
-        "611752105022841554",
-        "611752105030571013",
-        "611752105022841890",
-        "611752105030750578",
-        "611752105030750570",
-        "611752105029656106",
-        "611752105030750566",
-        "611752105030750567",
-        "611752105022757682",
-        "611752105030750562",
-        "611752105029656093",
-        "611752105022782339",
-        "611752105030537124",
-        "611752105030750563",
-        "611752105030537137",
-        "611752105022781163",
-        "611752105022784874",
-        "611752105022745821",
-        "611752105022782928",
-        "611752105030750561",
-        "611752105022780510",
-        "611752105022746136",
-        "611752105030750558",
-        "611752105030750556",
-        "611752105030750551",
-        "611752105022617153",
-        "611752105030750552",
-        "611752105030750548",
-        "611752105022780957",
-        "611752105022783430",
-        "611752105022750781",
-        "611752105022617062",
-        "611752105030750549",
-        "611752105030570923",
-        "611752105030750542",
-        "611752105030750544",
-        "611752105030750537",
-        "611752105030750539",
-        "611752105030750535",
-        "611752105030531571",
-        "611752105022740360",
-        "611752105030750533",
-        "611752105022734622",
-        "611752105030750529",
-        "611752105022755446",
-        "611752105030750528",
-        "611752105030750527",
-        "611752105030750519",
-        "611752105022823993",
-        "611752105030750521",
-        "611752105030537117",
-        "611752105022741042",
-        "611752105030750517",
-        "611752105030523474",
-        "611752105030733930",
-        "611752105030750514",
-        "611752105030750512",
-        "611752105030750515",
-        "611752105020382105",
-        "611752105030750508",
+        "611752105028848562",
+        "611752105030570248",
+        "611752105030550279",
+        "611752105030591221",
+        "611752105030485676",
+        "611752105030630876",
+        "611752105030674722",
+        "611752105030484183",
+        "611752105030630867",
+        "611752105030630871",
+        "611752105030580027",
+        "611752105030644708",
+        "611752105030630863",
+        "611752105030600361",
+        "611752105030600311",
+        "611752105030630857",
+        "611752105030630861",
+        "611752105030629310",
+        "611752105030630823",
+        "611752105030630460",
+        "611752105030484117",
+        "611752105030630853",
+        "611752105030630856",
+        "611752105030630851",
+        "611752105030630850",
+        "611752105030630845",
+        "611752105030630842",
+        "611752105030630843",
+        "611752105030630457",
+        "611752105030630453",
+        "611752105030630132",
+        "611752105030630805",
+        "611752105030630128",
+        "611752105030630477",
+        "611752105030630547",
+        "611752105030588820",
+        "611752105030483580",
+        "611752105030630449",
+        "611752105030630542",
+        "611752105030630445",
+        "611752105030630478",
+        "611752105030484394",
+        "611752105030630448",
+        "611752105030576611",
+        "611752105030598794",
+        "611752105030630835",
+        "611752105030588851",
+        "611752105030630348",
+        "611752105030630349",
+        "611752105030630126",
+        "611752105030544749",
+        "611752105030553750",
+        "611752105030553746",
+        "611752105030553736",
+        "611752105030553743",
+        "611752105030484121",
+        "611752105030544745",
+        "611752105030747660",
+        "611752105030591221",
+        "611752105030485517",
+        "611752105030478344",
+        "611752105030478343",
         "611752105030750819",
         "611752105030750817",
         "611752105030750818",
         "611752105030750816",
         "611752105030554115",
         "611752105030629748",
         "611752105030750815",
         "611752105030750878",
         "611752105030746530",
         "611752105026577483",
         "611752105030550263",
         "611752105030750881",
         "611752105025034371",
         "611752105030750876",
         "611752105030750875",
         "611752105030750390",
         "611752105030717472",
         "611752105030750873",
         "611752105030750872",
         "611752105028876417",
         "611752105025741780",
         "611752105030750870",
         "611752105030750871",
         "611752105022973103",
         "611752105030750867",
         "611752105022840505",
         "611752105030750868",
         "611752105022832271",
         "611752105022759233",
         "611752105022765990",
         "611752105022833335",
-        "611752105030535382",
-        "611752105030585296",
-        "611752105026151198",
-        "611752105030750866",
-        "611752105030750862",
-        "611752105030750864",
-        "611752105030750859",
-        "611752105030750860",
-        "611752105030750857",
-        "611752105030750858",
-        "611752105030750855",
-        "611752105030750853",
-        "611752105030750850",
-        "611752105030487768",
-        "611752105030750852",
-        "611752105030750848",
-        "611752105030650614",
-        "611752105030675201",
-        "611752105030750845",
-        "611752105030750380",
-        "611752105030750841",
-        "611752105030750840",
-        "611752105030750836",
-        "611752105030750834",
-        "611752105030750838",
-        "611752105030750830",
-        "611752105030499810",
-        "611752105030750831",
-        "611752105030750827",
-        "611752105030750828",
-        "611752105030477637",
-        "611752105030750632",
-        "611752105030750626",
-        "611752105030568311",
-        "611752105030750622",
-        "611752105030750625",
-        "611752105030750618",
-        "611752105030707486",
-        "611752105030750620",
-        "611752105030739294",
-        "611752105030750613",
-        "611752105029386765",
-        "611752105030750614",
-        "611752105030750610",
-        "611752105030750611",
-        "611752105030750608",
-        "611752105030750381",
-        "611752105030750603",
-        "611752105030750606",
-        "611752105030750601",
-        "611752105030750353",
-        "611752105030750352",
-        "611752105030750350",
-        "611752105030750348",
-        "611752105030750346",
-        "611752105030750347",
-        "611752105030750343",
-        "611752105030750342",
-        "611752105030750341",
-        "611752105030750712",
-        "611752105030739269",
-        "611752105030750714",
-        "611752105030750708",
-        "611752105030750711",
-        "611752105030630038",
-        "611752105030535317",
-        "611752105030750703",
-        "611752105030750706",
-        "611752105030735429",
-        "611752105030750701",
-        "611752105030750702",
-        "611752105030750355",
-        "611752105030750749",
-        "611752105030750748",
-        "611752105022841432",
-        "611752105030569712",
-        "611752105030750745",
-        "611752105030750741",
-        "611752105022838888",
-        "611752105030750744",
-        "611752105030750739",
-        "611752105030750740",
-        "611752105030750734",
-        "611752105030750737",
-        "611752105030477641",
-        "611752105030555184",
-        "611752105022826307",
-        "611752105030750730",
-        "611752105030750732",
-        "611752105030750726",
-        "611752105030535633",
-        "611752105022783523",
-        "611752105030750722",
-        "611752105030750723",
-        "611752105030750720",
-        "611752105030569716",
-        "611752105022779722",
-        "611752105030750718",
-        "611752105030750716",
-        "611752105030750715",
-        "611752105030750763",
-        "611752105030670638",
-        "611752105030750765",
-        "611752105030573283",
-        "611752105030630092",
-        "611752105030750759",
-        "611752105022767100",
-        "611752105022750122",
-        "611752105022759278",
-        "611752105029664180",
-        "611752105022734623",
-        "611752105030750760",
-        "611752105022734618",
-        "611752105030679448",
-        "611752105030575525",
-        "611752105030750757",
-        "611752105030750754",
-        "611752105030750756",
-        "611752105030750752",
-        "611752105030750338",
-        "611752105030750339",
-        "611752105030712051",
-        "611752105030750335",
-        "611752105030750333",
-        "611752105030750330",
-        "611752105030502203",
-        "611752105030750332",
-        "611752105030750329",
-        "611752105030750325",
-        "611752105030750328",
-        "611752105030750322",
-        "611752105030750811",
-        "611752105030750810",
-        "611752105030750812",
-        "611752105030750807",
-        "611752105030573284",
-        "611752105030750808",
-        "611752105030750803",
-        "611752105030750801",
-        "611752105030750802",
-        "611752105030750797",
-        "611752105030750798",
-        "611752105030750799",
-        "611752105030750793",
-        "611752105030750789",
-        "611752105030641790",
-        "611752105030552702",
-        "611752105030750787",
-        "611752105030750791",
-        "611752105030750784",
-        "611752105030750785",
-        "611752105030543205",
-        "611752105022758329",
-        "611752105030750782",
-        "611752105030750780",
-        "611752105030750778",
-        "611752105030750779",
-        "611752105030750777",
-        "611752105030750775",
-        "611752105030750773",
-        "611752105030750774",
-        "611752105030636790",
         "611752105030548385",
         "611752105030750768",
         "611752105029648557",
         "611752105030554122",
         "611752105030750767",
         "611752105030487077",
         "611752105022842161",
         "611752105022756613",
         "611752105030568505",
         "611752105022740047",
         "611752105022763524",
         "611752105022741741",
         "611752105030640738",
         "611752105030533166",
         "611752105030554085",
         "611752105030532771",
         "611752105022808705",
         "611752105030750824",
         "611752105030750823",
         "611752105022779893",
         "611752105030750825",
-        "611752105030569797",
-        "611752105030750967",
-        "611752105022783018",
-        "611752105022843404",
-        "611752105022762601",
-        "611752105030612814",
-        "611752105030750961",
-        "611752105030630416",
-        "611752105030575407",
-        "611752105030532712",
-        "611752105026614996",
-        "611752105030750965",
-        "611752105030750956",
-        "611752105030750955",
-        "611752105030568510",
-        "611752105022746903",
-        "611752105025741814",
-        "611752105030750441",
-        "611752105030750442",
-        "611752105022771600",
-        "611752105029682569",
-        "611752105022747207",
-        "611752105022775318",
-        "611752105022747600",
-        "611752105022728590",
-        "611752105022774769",
-        "611752105030477406",
-        "611752105022769449",
-        "611752105022753113",
-        "611752105030750892",
-        "611752105030750890",
-        "611752105030750891",
-        "611752105030750886",
-        "611752105030750885",
-        "611752105028032112",
-        "611752105030750320",
-        "611752105030750318",
-        "611752105029386654",
-        "611752105030750314",
-        "611752105030750315",
-        "611752105030750311",
-        "611752105030678992",
-        "611752105030750305",
-        "611752105022728297",
-        "611752105022732529",
-        "611752105022842698",
-        "611752105022745996",
-        "611752105022767201",
-        "611752105022745296",
-        "611752105022768323",
-        "611752105022743753",
-        "611752105030544072",
-        "611752105030750307",
-        "611752105022772083",
-        "611752105030750302",
-        "611752105030585351",
-        "611752105030517824",
-        "611752105026582253",
-        "611752105030751014",
-        "611752105025034424",
-        "611752105024984967",
-        "611752105024938938",
-        "611752105030619378",
-        "611752105024683311",
-        "611752105030068419",
-        "611752105030678989",
-        "611752105024285758",
-        "611752105024258631",
-        "611752105030751009",
-        "611752105023286243",
-        "611752105022732622",
-        "611752105030751011",
-        "611752105022843130",
-        "611752105022842597",
-        "611752105022839729",
-        "611752105022839207",
-        "611752105022839310",
-        "611752105030751007",
-        "611752105030751004",
-        "611752105022836553",
-        "611752105022778355",
-        "611752105022741824",
-        "611752105022780559",
-        "611752105030534618",
-        "611752105030751000",
-        "611752105029071206",
-        "611752105030554102",
-        "611752105030750999",
-        "611752105030750996",
-        "611752105030750997",
-        "611752105030679480",
-        "611752105030750994",
-        "611752105030750990",
-        "611752105030750991",
-        "611752105022840532",
-        "611752105022784924",
-        "611752105022783393",
-        "611752105022776608",
-        "611752105030750986",
-        "611752105022766560",
-        "611752105030750988",
-        "611752105030750969",
-        "611752105030517188",
-        "611752105022761160",
-        "611752105030750952",
-        "611752105030750945",
-        "611752105026069587",
-        "611752105030750948",
-        "611752105030750943",
-        "611752105030630047",
-        "611752105030587757",
-        "611752105029087255",
-        "611752105026227894",
-        "611752105030575430",
-        "611752105023426678",
-        "611752105030568328",
-        "611752105030750940",
-        "611752105030707633",
-        "611752105030606234",
-        "611752105030750934",
-        "611752105022780034",
-        "611752105022843256",
-        "611752105022843187",
-        "611752105022841539",
-        "611752105022828996",
-        "611752105022840478",
-        "611752105022816197",
-        "611752105022785541",
-        "611752105022704183",
-        "611752105030629744",
-        "611752105030655306",
-        "611752105030750936",
-        "611752105030750929",
-        "611752105030630141",
-        "611752105030750933",
-        "611752105030750925",
-        "611752105030717483",
-        "611752105030533669",
-        "611752105030750927",
-        "611752105030750919",
-        "611752105030750452",
-        "611752105030750912",
-        "611752105030750914",
-        "611752105030750910",
-        "611752105025508041",
-        "611752105030568322",
-        "611752105030630140",
-        "611752105022842764",
-        "611752105022775579",
-        "611752105022767503",
-        "611752105030643390",
-        "611752105022766405",
-        "611752105022768711",
-        "611752105022740049",
-        "611752105030717495",
-        "611752105030750908",
-        "611752105022740834",
-        "611752105030588326",
-        "611752105030750482",
-        "611752105030722788",
-        "611752105022763874",
-        "611752105030487461",
-        "611752105022766916",
-        "611752105030750900",
-        "611752105030486922",
-        "611752105022892977",
-        "611752105022760478",
-        "611752105030750902",
-        "611752105022843478",
-        "611752105022740835",
-        "611752105022746906",
-        "611752105022736961",
-        "611752105020398774",
-        "611752105030750897",
-        "611752105030750898",
-        "611752105022750341",
-        "611752105030737381",
-        "611752105030534520",
-        "611752105030517868",
-        "611752105030517864",
         "611752105024973490",
-        "611752105030517865",
-        "611752105030477426",
-        "611752105024096873",
-        "611752105024021654",
-        "611752105030477423",
-        "611752105030477424",
-        "611752105030477419",
-        "611752105030477421",
         "611752105030477418",
-        "611752105022783938",
-        "611752105022617058",
-        "611752105022748993",
-        "611752105030751063",
-        "611752105022764526",
-        "611752105030751059",
-        "611752105022781972",
-        "611752105030629951",
-        "611752105030751061",
-        "611752105022750434",
-        "611752105030535642",
-        "611752105022729841",
-        "611752105022774743",
-        "611752105022737656",
-        "611752105030751054",
-        "611752105022774318",
-        "611752105030683528",
-        "611752105030735870",
-        "611752105030751057",
-        "611752105030519849",
-        "611752105022764520",
-        "611752105022730216",
-        "611752105022764551",
-        "611752105030665017",
-        "611752105030683525",
-        "611752105030751053",
-        "611752105030751051",
-        "611752105030751052",
-        "611752105030751046",
-        "611752105030751047",
-        "611752105022757266",
-        "611752105030519890",
-        "611752105030519886",
-        "611752105030519885",
-        "611752105030519882",
-        "611752105020411647",
-        "611752105030489960",
-        "611752105030519879",
-        "611752105022776248",
-        "611752105030519878",
-        "611752105030519877",
-        "611752105030519869",
-        "611752105030519870",
-        "611752105030519864",
-        "611752105022763131",
-        "611752105022777563",
-        "611752105022745255",
-        "611752105030519866",
-        "611752105022742152",
-        "611752105030519861",
-        "611752105030519862",
-        "611752105022841596",
-        "611752105030519859",
-        "611752105030519856",
-        "611752105030519855",
-        "611752105030519853",
-        "611752105030519850",
-        "611752105030519845",
-        "611752105030519840",
-        "611752105030519843",
-        "611752105022781809",
-        "611752105030519836",
-        "611752105030517831",
-        "611752105030519834",
-        "611752105030519838",
-        "611752105030519831",
-        "611752105030519832",
-        "611752105030519828",
-        "611752105030519825",
-        "611752105030519823",
-        "611752105030519827",
-        "611752105030519819",
-        "611752105022764601",
-        "611752105030519821",
-        "611752105030519818",
-        "611752105030657581",
-        "611752105030735897",
-        "611752105030735889",
-        "611752105030494888",
-        "611752105030751042",
-        "611752105030533448",
-        "611752105022808508",
-        "611752105022774660",
-        "611752105022616037",
-        "611752105022757584",
-        "611752105022775917",
-        "611752105030735890",
-        "611752105030663208",
-        "611752105030531362",
-        "611752105020388650",
-        "611752105030709535",
-        "611752105020315352",
-        "611752105030735885",
-        "611752105030490989",
-        "611752105022745688",
-        "611752105030735882",
-        "611752105022761599",
-        "611752105030735878",
-        "611752105030735554",
-        "611752105030735397",
-        "611752105022755790",
-        "611752105030735389",
-        "611752105030751043",
-        "611752105030735527",
-        "611752105022770750",
-        "611752105030735600",
-        "611752105030751039",
-        "611752105022758378",
-        "611752105030751037",
-        "611752105030735782",
-        "611752105030735829",
-        "611752105030751033",
-        "611752105030751031",
-        "611752105030751028",
-        "611752105030751029",
-        "611752105030750280",
-        "611752105030750277",
-        "611752105030750272",
-        "611752105029665037",
-        "611752105025523319",
-        "611752105030750268",
-        "611752105022839223",
-        "611752105022837114",
-        "611752105022838981",
         "611752105030750269",
-        "611752105030750261",
-        "611752105030750263",
-        "611752105022749182",
-        "611752105022772910",
-        "611752105020398796",
-        "611752105022745170",
-        "611752105022774260",
-        "611752105022766103",
-        "611752105029665056",
-        "611752105020295123",
-        "611752105022770165",
-        "611752105030750255",
-        "611752105022753686",
-        "611752105030750257",
-        "611752105030751132",
-        "611752105030751133",
-        "611752105030750758",
-        "611752105030751129",
-        "611752105024665175",
-        "611752105030751131",
-        "611752105030751125",
-        "611752105030751126",
-        "611752105022732539",
-        "611752105022779656",
-        "611752105030751122",
-        "611752105030612816",
-        "611752105030750300",
-        "611752105022839747",
-        "611752105022843392",
-        "611752105022779858",
-        "611752105022838338",
-        "611752105030751123",
-        "611752105022839518",
-        "611752105022778990",
-        "611752105030750296",
-        "611752105030751118",
-        "611752105022839504",
-        "611752105022747488",
-        "611752105022838406",
-        "611752105022771572",
-        "611752105022889137",
-        "611752105022839744",
-        "611752105030750298",
-        "611752105022759882",
-        "611752105022784574",
-        "611752105030517173",
-        "611752105022784667",
-        "611752105030679196",
-        "611752105022778847",
-        "611752105022778988",
-        "611752105030750291",
-        "611752105030751119",
-        "611752105022816363",
-        "611752105022747487",
-        "611752105030750292",
-        "611752105030751116",
-        "611752105030750287",
-        "611752105022839746",
-        "611752105030750290",
-        "611752105030751115",
-        "611752105030750283",
-        "611752105024707924",
-        "611752105030750278",
-        "611752105030719364",
-        "611752105022775094",
-        "611752105022741357",
-        "611752105030585077",
-        "611752105030570918",
-        "611752105030751117",
-        "611752105022774563",
-        "611752105030751111",
-        "611752105022757757",
-        "611752105030751113",
-        "611752105030477431",
-        "611752105030750884",
-        "611752105030751109",
-        "611752105022775051",
-        "611752105030569744",
-        "611752105030678999",
-        "611752105030751110",
-        "611752105030751107",
-        "611752105030751108",
-        "611752105030707651",
-        "611752105030751104",
-        "611752105030750725",
-        "611752105022733123",
-        "611752105030751101",
-        "611752105030751103",
-        "611752105030751093",
-        "611752105030751091",
-        "611752105030751092",
-        "611752105030751089",
-        "611752105022842132",
-        "611752105030751088",
-        "611752105022841366",
-        "611752105022751455",
-        "611752105030681746",
-        "611752105022738600",
-        "611752105030679485",
-        "611752105030751087",
-        "611752105020327767",
-        "611752105022779629",
-        "611752105022749119",
-        "611752105022743759",
-        "611752105022752201",
-        "611752105022773336",
-        "611752105030489269",
-        "611752105022841862",
-        "611752105022770174",
-        "611752105022783623",
-        "611752105022760160",
-        "611752105030751084",
-        "611752105022840164",
-        "611752105022613688",
-        "611752105030751086",
-        "611752105030663144",
-        "611752105022771188",
-        "611752105022775918",
-        "611752105022779807",
-        "611752105030585257",
-        "611752105022736055",
-        "611752105022765225",
-        "611752105030751081",
-        "611752105022767258",
-        "611752105030751080",
-        "611752105022766107",
-        "611752105022780700",
-        "611752105022765325",
-        "611752105022768067",
-        "611752105030750906",
-        "611752105022838906",
-        "611752105030751079",
-        "611752105022738936",
-        "611752105030751078",
-        "611752105022749291",
-        "611752105022739048",
-        "611752105030538753",
-        "611752105030751074",
-        "611752105030751076",
-        "611752105025551178",
-        "611752105022779132",
-        "611752105030751073",
-        "611752105030751068",
-        "611752105030751067",
-        "611752105030751071",
-        "611752105022771316",
-        "611752105030535021",
-        "611752105030533468",
-        "611752105030519761",
-        "611752105030751064",
-        "611752105022781810",
-        "611752105030751024",
-        "611752105030631077",
-        "611752105028815368",
-        "611752105030517873",
-        "611752105030751027",
-        "611752105030535637",
-        "611752105030751022",
-        "611752105030750312",
-        "611752105030751018",
-        "611752105030751019",
-        "611752105030750303",
-        "611752105030554093",
-        "611752105030593871",
-        "611752105030593868",
-        "611752105022775298",
-        "611752105022780545",
-        "611752105022735551",
-        "611752105022739746",
-        "611752105030593870",
-        "611752105022750595",
-        "611752105030593867",
-        "611752105022757978",
-        "611752105022615737",
-        "611752105030593863",
-        "611752105030568397",
-        "611752105022756196",
-        "611752105022876789",
-        "611752105022743918",
-        "611752105022741320",
-        "611752105022762736",
-        "611752105022751454",
-        "611752105022766636",
-        "611752105022764218",
-        "611752105030575617",
-        "611752105023763923",
-        "611752105030569798",
-        "611752105022756126",
         "611752105022876788",
-        "611752105022785723",
-        "611752105022760682",
-        "611752105030593861",
-        "611752105022763408",
-        "611752105020396951",
-        "611752105028929126",
-        "611752105030568384",
-        "611752105022747598",
-        "611752105030477412",
-        "611752105022768288",
-        "611752105022774630",
-        "611752105022769506",
-        "611752105022752182",
-        "611752105022783357",
-        "611752105030554103",
-        "611752105022772913",
-        "611752105030593855",
-        "611752105030593856",
-        "611752105022738487",
-        "611752105022613051",
-        "611752105022744967",
-        "611752105030593854",
-        "611752105030593852",
-        "611752105022749959",
-        "611752105022749896",
-        "611752105027734190",
-        "611752105030655290",
-        "611752105022748795",
-        "611752105030568501",
-        "611752105020332453",
-        "611752105024594251",
-        "611752105022776176",
-        "611752105024938881",
-        "611752105030575505",
-        "611752105029837016",
-        "611752105030750234",
-        "611752105030606108",
-        "611752105022776279",
-        "611752105030569764",
-        "611752105022799288",
         "611752105022772534",
-        "611752105022784055",
         "611752105022783545",
-        "611752105030534489",
-        "611752105022766521",
-        "611752105022757598",
-        "611752105030751148",
-        "611752105030519872",
-        "611752105022770716",
-        "611752105022770297",
-        "611752105022766415",
-        "611752105030517518",
-        "611752105022747687",
-        "611752105022728600",
-        "611752105022764954",
-        "611752105030554986",
-        "611752105030534825",
-        "611752105030750321",
-        "611752105030490252",
-        "611752105030751149",
-        "611752105030602785",
-        "611752105030751147",
-        "611752105030751144",
-        "611752105030743603",
-        "611752105030571119",
-        "611752105030585075",
-        "611752105030751145",
-        "611752105030543731",
-        "611752105030750274",
         "611752105030750223",
-        "611752105030750217",
-        "611752105030750215",
-        "611752105030535322",
-        "611752105030503012",
-        "611752105030503014",
-        "611752105030750210",
-        "611752105022779841",
-        "611752105022791608",
-        "611752105030585069",
-        "611752105022779179",
-        "611752105022765974",
-        "611752105030750205",
-        "611752105030750208",
-        "611752105030535026",
-        "611752105030750201",
-        "611752105030750203",
-        "611752105022785446",
-        "611752105022780776",
-        "611752105022784598",
-        "611752105022782877",
-        "611752105030543675",
-        "611752105030489916",
-        "611752105030735412",
-        "611752105030750197",
-        "611752105022781347",
-        "611752105022778095",
-        "611752105022780202",
-        "611752105030585066",
-        "611752105022778207",
-        "611752105022778056",
-        "611752105022778068",
-        "611752105022781380",
-        "611752105030735784",
-        "611752105030585355",
-        "611752105022775385",
-        "611752105022760035",
-        "611752105022755466",
-        "611752105022769910",
-        "611752105022758054",
-        "611752105022768397",
-        "611752105030736423",
-        "611752105030750236",
-        "611752105030630188",
-        "611752105030750229",
-        "611752105030630164",
-        "611752105030630159",
-        "611752105030630156",
-        "611752105030630153",
-        "611752105030630151",
-        "611752105029678919",
-        "611752105030616780",
-        "611752105030630152",
-        "611752105030494847",
-        "611752105029656123",
-        "611752105030630147",
-        "611752105030750226",
-        "611752105025643045",
-        "611752105030585053",
-        "611752105026284420",
-        "611752105025498134",
         "611752105028899742",
         "611752105030630148",
-        "611752105030517504",
-        "611752105030517506",
-        "611752105030630143",
-        "611752105030629682",
-        "611752105030629684",
-        "611752105030629677",
         "611752105030629674",
-        "611752105030629680",
-        "611752105030630079",
-        "611752105030750227",
-        "611752105030629671",
-        "611752105022727866",
-        "611752105022775920",
-        "611752105022839186",
-        "611752105022735159",
-        "611752105030750220",
-        "611752105022768410",
-        "611752105030555609",
-        "611752105022748888",
-        "611752105022768286",
-        "611752105022782687",
-        "611752105022742631",
-        "611752105022759884",
-        "611752105022754073",
-        "611752105022752493",
-        "611752105030750458",
-        "611752105030751141",
-        "611752105022740362",
-        "611752105030679459",
-        "611752105030538829",
-        "611752105022766829",
-        "611752105022755269",
-        "611752105022776389",
-        "611752105022783609",
-        "611752105022775313",
-        "611752105022776162",
-        "611752105022766009",
-        "611752105030585383",
-        "611752105030751142",
-        "611752105030751136",
-        "611752105022769644",
-        "611752105022769278",
-        "611752105030575417",
-        "611752105030751137",
-        "611752105022767500",
-        "611752105022752183",
-        "611752105022756246",
-        "611752105030750970",
-        "611752105022757251",
-        "611752105030750212",
-        "611752105022770032",
-        "611752105030488749",
-        "611752105022764211",
-        "611752105022748412",
-        "611752105022768441",
-        "611752105030750248",
-        "611752105022764081",
-        "611752105030750250",
-        "611752105030750241",
-        "611752105022767205",
-        "611752105022762627",
-        "611752105022760689",
-        "611752105030750243",
-        "611752105022782592",
-        "611752105030593894",
-        "611752105030519896",
-        "611752105030593890",
         "611752105030593891",
-        "611752105030593887",
-        "611752105030593878",
-        "611752105024961744",
-        "611752105030517857",
-        "611752105024441026",
-        "611752105023434553",
-        "611752105030554107",
-        "611752105022973053",
-        "611752105030477410",
-        "611752105022732817",
-        "611752105022774474",
-        "611752105022762603",
-        "611752105022743922",
-        "611752105022770926",
-        "611752105022775312",
-        "611752105022757884",
-        "611752105022776405",
-        "611752105030585339",
-        "611752105022767501",
-        "611752105022754533",
-        "611752105022832384",
-        "611752105022772480",
-        "611752105030568376",
-        "611752105022759872",
-        "611752105022761840",
-        "611752105030593872",
-        "611752105030593874",
-        "611752105029692394",
-        "611752105029381035",
-        "611752105030629884",
-        "611752105030750118",
-        "611752105030629543",
         "611752105030554114",
-        "611752105030629876",
-        "611752105030629873",
-        "611752105025474701",
-        "611752105030629745",
-        "611752105030550189",
         "611752105024546871",
-        "611752105030629871",
-        "611752105030644144",
-        "611752105030629861",
-        "611752105022729202",
-        "611752105022647084",
-        "611752105022841536",
-        "611752105022842016",
-        "611752105022729185",
-        "611752105022839471",
-        "611752105022839157",
-        "611752105022841448",
-        "611752105022782716",
-        "611752105022777104",
-        "611752105020332474",
-        "611752105022775900",
-        "611752105022843566",
-        "611752105022775450",
-        "611752105022738737",
-        "611752105030750119",
-        "611752105022757321",
-        "611752105022759461",
-        "611752105022728562",
-        "611752105030750113",
-        "611752105030630406",
-        "611752105030502026",
-        "611752105030630405",
-        "611752105030630404",
-        "611752105030553606",
-        "611752105030575415",
-        "611752105030679460",
         "611752105030630393",
-        "611752105030629533",
-        "611752105030553600",
-        "611752105030630395",
-        "611752105030719535",
         "611752105030719536",
         "611752105030630396",
-        "611752105030719533",
-        "611752105030719531",
-        "611752105030585331",
-        "611752105030630390",
-        "611752105030553596",
-        "611752105030630385",
-        "611752105030750116",
-        "611752105022775881",
-        "611752105030663158",
-        "611752105030719528",
-        "611752105030585282",
-        "611752105022775325",
-        "611752105022782191",
-        "611752105022774248",
-        "611752105022728476",
-        "611752105022743754",
-        "611752105022728587",
-        "611752105022785719",
-        "611752105030534929",
-        "611752105022741544",
-        "611752105022742647",
-        "611752105022774821",
-        "611752105022752185",
-        "611752105022775773",
-        "611752105022761058",
-        "611752105030609459",
-        "611752105022755274",
-        "611752105022771573",
-        "611752105022739114",
-        "611752105022746137",
-        "611752105022755971",
-        "611752105022765561",
-        "611752105022774849",
-        "611752105022773322",
-        "611752105022749701",
-        "611752105022612776",
-        "611752105022728588",
-        "611752105022774593",
-        "611752105030643774",
-        "611752105030550234",
-        "611752105029041674",
-        "611752105028558151",
-        "611752105030605859",
         "611752105026827284",
-        "611752105030485416",
-        "611752105030679469",
-        "611752105030629537",
-        "611752105030719835",
-        "611752105030554113",
-        "611752105024728130",
         "611752105030517863",
-        "611752105030719832",
         "611752105030719833",
-        "611752105024683224",
-        "611752105022836704",
-        "611752105022782683",
-        "611752105022754498",
-        "611752105030719825",
-        "611752105030750110",
-        "611752105022754072",
-        "611752105030629521",
-        "611752105030681742",
-        "611752105022760476",
-        "611752105030585254",
-        "611752105030719823",
-        "611752105022750344",
-        "611752105022768792",
-        "611752105022766418",
-        "611752105030719821",
-        "611752105022775763",
-        "611752105030568381",
-        "611752105022736409",
         "611752105022745668",
-        "611752105022755802",
-        "611752105030719817",
-        "611752105022764210",
-        "611752105030719819",
-        "611752105022761903",
-        "611752105030517174",
-        "611752105020398777",
-        "611752105022752192",
-        "611752105030477373",
-        "611752105030585188",
-        "611752105022770907",
-        "611752105022841555",
-        "611752105030534820",
-        "611752105022776742",
-        "611752105030658886",
-        "611752105030750004",
-        "611752105030629824",
-        "611752105030749998",
-        "611752105030630161",
-        "611752105030749993",
-        "611752105030749994",
-        "611752105030631074",
-        "611752105030633773",
-        "611752105028893387",
-        "611752105030631066",
-        "611752105030749992",
-        "611752105030630105",
-        "611752105028900385",
-        "611752105030544032",
-        "611752105029713714",
-        "611752105030749989",
-        "611752105030517872",
-        "611752105030535647",
-        "611752105030749986",
         "611752105030749987",
-        "611752105028820602",
-        "611752105030749980",
-        "611752105030629883",
-        "611752105029648497",
-        "611752105027757383",
-        "611752105030601967",
-        "611752105030550273",
-        "611752105030587781",
-        "611752105026827278",
-        "611752105030630075",
-        "611752105030749978",
         "611752105026630782",
-        "611752105026580833",
-        "611752105030630064",
-        "611752105030749976",
-        "611752105030749972",
-        "611752105027067862",
-        "611752105030544030",
-        "611752105030544026",
-        "611752105030544008",
-        "611752105029648501",
-        "611752105030544011",
-        "611752105030544002",
-        "611752105030544007",
-        "611752105022774153",
-        "611752105030544005",
-        "611752105022757567",
-        "611752105022766240",
-        "611752105022774317",
-        "611752105022783059",
-        "611752105030543998",
-        "611752105022770343",
-        "611752105022774149",
-        "611752105022754532",
-        "611752105022760224",
-        "611752105022771932",
-        "611752105022777817",
-        "611752105030544001",
-        "611752105022771145",
-        "611752105022771635",
-        "611752105022736953",
-        "611752105030543994",
-        "611752105030543992",
-        "611752105030543993",
-        "611752105030543988",
-        "611752105030543985",
-        "611752105030543978",
-        "611752105022757982",
-        "611752105029721594",
-        "611752105023285352",
-        "611752105029679100",
-        "611752105030484433",
-        "611752105030749944",
-        "611752105030749945",
-        "611752105029292233",
-        "611752105030749940",
-        "611752105030749935",
-        "611752105030749938",
-        "611752105030749931",
-        "611752105030231751",
-        "611752105030749933",
-        "611752105030749929",
-        "611752105030749926",
-        "611752105022782156",
-        "611752105022785290",
-        "611752105022841829",
-        "611752105022776534",
-        "611752105030570160",
-        "611752105030749921",
-        "611752105030749922",
-        "611752105030749920",
-        "611752105030749915",
-        "611752105030749914",
-        "611752105030749911",
-        "611752105030749912",
-        "611752105020319431",
-        "611752105030749907",
-        "611752105030568429",
-        "611752105030659650",
-        "611752105030749905",
-        "611752105022778611",
-        "611752105030749901",
-        "611752105030749895",
-        "611752105022782651",
-        "611752105030749898",
-        "611752105022835318",
-        "611752105030704246",
-        "611752105030749893",
-        "611752105030749889",
-        "611752105030749892",
-        "611752105030749885",
-        "611752105030749881",
-        "611752105030749883",
-        "611752105030749878",
-        "611752105030749875",
-        "611752105030749874",
-        "611752105022840409",
-        "611752105022841287",
-        "611752105030749869",
-        "611752105030749868",
-        "611752105030749861",
-        "611752105030749864",
-        "611752105030749856",
-        "611752105030749853",
-        "611752105030749854",
-        "611752105030749849",
-        "611752105030749842",
-        "611752105030749846",
-        "611752105030749839",
-        "611752105030749837",
-        "611752105030749841",
-        "611752105030749832",
-        "611752105022838516",
-        "611752105030749835",
-        "611752105020345839",
-        "611752105022812770",
-        "611752105022840034",
-        "611752105030749823",
-        "611752105030749825",
-        "611752105030749820",
-        "611752105030749822",
-        "611752105030749814",
-        "611752105030749815",
-        "611752105030749813",
-        "611752105030750107",
-        "611752105030750105",
-        "611752105029718016",
-        "611752105030750106",
-        "611752105030750099",
-        "611752105030750102",
-        "611752105030509311",
-        "611752105030705616",
-        "611752105030750095",
-        "611752105030750096",
-        "611752105030750090",
-        "611752105030750085",
-        "611752105030750086",
-        "611752105030750081",
-        "611752105030750083",
-        "611752105030750076",
-        "611752105030750074",
-        "611752105030750071",
-        "611752105030750070",
-        "611752105030750068",
-        "611752105030750064",
-        "611752105030750063",
-        "611752105030750066",
-        "611752105030750057",
-        "611752105030750060",
-        "611752105030750054",
-        "611752105030750052",
-        "611752105030750050",
-        "611752105030750051",
-        "611752105030750047",
-        "611752105030750044",
-        "611752105030750046",
-        "611752105030495094",
-        "611752105030750041",
-        "611752105030750036",
-        "611752105030750037",
-        "611752105030750030",
-        "611752105030750032",
-        "611752105030750028",
-        "611752105030749970",
-        "611752105022753315",
-        "611752105022750436",
-        "611752105030749973",
-        "611752105022612914",
-        "611752105022736006",
-        "611752105026610681",
-        "611752105030749966",
-        "611752105030749969",
-        "611752105020286442",
-        "611752105022612291",
-        "611752105030749964",
-        "611752105030749961",
-        "611752105030749962",
-        "611752105022752667",
-        "611752105030749959",
-        "611752105030749953",
-        "611752105030749954",
-        "611752105030749951",
-        "611752105030538684",
-        "611752105030749949",
-        "611752105030749943",
-        "611752105030750023",
-        "611752105030659230",
-        "611752105030750024",
-        "611752105030740695",
-        "611752105022730829",
-        "611752105022751822",
-        "611752105030750017",
-        "611752105030750020",
-        "611752105022764625",
-        "611752105030737012",
-        "611752105030750014",
-        "611752105028891045",
-        "611752105030750011",
-        "611752105022728942",
-        "611752105022731226",
-        "611752105022738223",
-        "611752105022615335",
-        "611752105030750006",
-        "611752105030586172",
-        "611752105030750009",
-        "611752105030751161",
-        "611752105030751158",
-        "611752105022746571",
-        "611752105030751153",
-        "611752105030719828",
-        "611752105022755463",
-        "611752105030751154",
-        "611752105020411654",
-        "611752105030750194",
-        "611752105030593857",
-        "611752105022766534",
-        "611752105030750196",
-        "611752105030750189",
-        "611752105022772567",
-        "611752105022876793",
-        "611752105030749808",
-        "611752105030749809",
-        "611752105030749804",
-        "611752105030749805",
-        "611752105030749801",
-        "611752105030488602",
-        "611752105030486046",
-        "611752105029041670",
-        "611752105030532631",
-        "611752105030534587",
-        "611752105030534583",
-        "611752105030698921",
-        "611752105030534576",
-        "611752105028983069",
-        "611752105030749803",
-        "611752105028778350",
-        "611752105030749797",
-        "611752105028453186",
-        "611752105030556591",
         "611752105030749799",
-        "611752105028444608",
-        "611752105029656135",
-        "611752105030749796",
-        "611752105030554118",
-        "611752105029395212",
-        "611752105030749792",
-        "611752105030751002",
-        "611752105030554117",
-        "611752105030751214",
-        "611752105030569830",
-        "611752105025491884",
-        "611752105029665053",
-        "611752105022841108",
-        "611752105022759614",
-        "611752105030751212",
-        "611752105030751213",
-        "611752105022759871",
-        "611752105030751206",
-        "611752105030751209",
-        "611752105030629667",
-        "611752105022615738",
-        "611752105022740363",
-        "611752105022768450",
-        "611752105022769070",
-        "611752105030679451",
-        "611752105022615733",
-        "611752105030751201",
-        "611752105022733425",
-        "611752105022759523",
-        "611752105022739029",
-        "611752105030751203",
-        "611752105022735794",
-        "611752105030569814",
-        "611752105022841105",
-        "611752105022769069",
-        "611752105022615734",
-        "611752105030569832",
-        "611752105022841110",
-        "611752105030477401",
-        "611752105030751199",
-        "611752105030751197",
-        "611752105022762299",
-        "611752105022774994",
         "611752105025618640",
         "611752105022783154",
-        "611752105022840475",
-        "611752105030605773",
-        "611752105022759617",
-        "611752105030751196",
-        "611752105030751198",
-        "611752105030751192",
-        "611752105030751194",
-        "611752105030751189",
-        "611752105030751190",
-        "611752105030751188",
         "611752105022783707",
-        "611752105022973051",
-        "611752105030751185",
-        "611752105030751187",
-        "611752105030751183",
-        "611752105030569804",
-        "611752105022728085",
-        "611752105022772262",
-        "611752105030751181",
-        "611752105030723539",
-        "611752105030568528",
-        "611752105030548387",
-        "611752105030751180",
-        "611752105030751182",
-        "611752105030749904",
-        "611752105030751177",
-        "611752105022729852",
-        "611752105030751174",
-        "611752105030751175",
-        "611752105030751169",
-        "611752105030751172",
-        "611752105030751167",
-        "611752105030749857",
-        "611752105030751164",
-        "611752105030749829",
-        "611752105030751165",
-        "611752105030751162",
-        "611752105030568516",
-        "611752105030751160",
-        "611752105030750191",
-        "611752105022766643",
-        "611752105022769073",
-        "611752105022876790",
-        "611752105030679486",
-        "611752105022748100",
-        "611752105022766834",
-        "611752105022758645",
-        "611752105022785716",
-        "611752105022745254",
-        "611752105022756757",
         "611752105022767188",
-        "611752105030750184",
-        "611752105022775053",
-        "611752105022775308",
-        "611752105022768100",
-        "611752105022775320",
-        "611752105022759932",
-        "611752105022744565",
-        "611752105022876792",
-        "611752105022755838",
-        "611752105022736780",
-        "611752105022741324",
-        "611752105022742147",
-        "611752105022748298",
-        "611752105022750506",
-        "611752105022782645",
-        "611752105022759621",
-        "611752105022743656",
-        "611752105020419087",
-        "611752105022738084",
-        "611752105022838910",
-        "611752105022770470",
-        "611752105022747208",
-        "611752105022615260",
-        "611752105026578243",
-        "611752105030593864",
-        "611752105022783017",
         "611752105022615726",
         "611752105022759619",
-        "611752105022770952",
-        "611752105022742664",
-        "611752105022740831",
-        "611752105022737885",
-        "611752105022735279",
-        "611752105022769629",
-        "611752105022838257",
-        "611752105030696958",
-        "611752105022766196",
-        "611752105030696959",
-        "611752105030593881",
-        "611752105024415480",
-        "611752105030629869",
-        "611752105030613526",
-        "611752105022740830",
-        "611752105029661979",
-        "611752105030696956",
-        "611752105030696950",
-        "611752105030750185",
-        "611752105029884311",
-        "611752105030534523",
-        "611752105028873923",
-        "611752105022616674",
-        "611752105022750270",
-        "611752105030613531",
-        "611752105025090778",
-        "611752105022771323",
-        "611752105030696953",
-        "611752105022784782",
-        "611752105030155110",
-        "611752105022759618",
-        "611752105030696947",
-        "611752105022775319",
-        "611752105030572360",
-        "611752105029695282",
-        "611752105030750177",
-        "611752105030547983",
-        "611752105030750183",
-        "611752105030534601",
-        "611752105028932374",
-        "611752105030534555",
-        "611752105030750173",
-        "611752105028858598",
-        "611752105028032111",
-        "611752105027460079",
-        "611752105026437870",
-        "611752105029661971",
-        "611752105025293171",
-        "611752105030569837",
-        "611752105030750174",
-        "611752105030534623",
-        "611752105022741850",
-        "611752105030569826",
-        "611752105022736417",
-        "611752105030750162",
-        "611752105022741852",
-        "611752105030750165",
-        "611752105030750157",
-        "611752105030575398",
-        "611752105030707644",
-        "611752105022769619",
-        "611752105030750160",
-        "611752105030750154",
-        "611752105030750156",
-        "611752105030750150",
-        "611752105030750151",
-        "611752105030750147",
-        "611752105030750144",
-        "611752105022735956",
-        "611752105030750146",
-        "611752105030750140",
-        "611752105030750142",
-        "611752105022773680",
-        "611752105030750139",
         "611752105030750135",
-        "611752105030750136",
         "611752105022785717",
         "611752105022759615",
-        "611752105030750133",
-        "611752105022751302",
-        "611752105022753529",
-        "611752105030484037",
-        "611752105022766024",
-        "611752105030750134",
-        "611752105030546461",
-        "611752105022615630",
-        "611752105030750129",
-        "611752105030750128",
-        "611752105025720355",
-        "611752105030607636",
-        "611752105022758358",
-        "611752105030750125",
-        "611752105022912888",
-        "611752105030500490",
-        "611752105030707609",
-        "611752105022835737",
-        "611752105029387028",
-        "611752105030707571",
-        "611752105030629676",
-        "611752105022839034",
-        "611752105030719830",
-        "611752105030750124",
-        "611752105030750120",
-        "611752105029837015",
-        "611752105022783924",
-        "611752105022769621",
-        "611752105022807958",
-        "611752105029733300",
-        "611752105022616736",
-        "611752105030502738",
-        "611752105030534660",
-        "611752105027965664",
-        "611752105022841631",
-        "611752105030602072",
-        "611752105027734179",
-        "611752105027344690",
-        "611752105022775468",
-        "611752105030487030",
-        "611752105030544263",
-        "611752105030587765",
-        "611752105030630104",
-        "611752105030629730",
         "611752105030517508",
-        "611752105030629732",
-        "611752105030553604",
-        "611752105025817797",
-        "611752105030629727",
-        "611752105026110610",
-        "611752105025341131",
-        "611752105030629528",
-        "611752105030572355",
-        "611752105030629723",
-        "611752105030629726",
-        "611752105030629719",
         "611752105030593875",
-        "611752105028990332",
-        "611752105030587842",
-        "611752105029701053",
-        "611752105030487071",
-        "611752105030629714",
-        "611752105025508921",
-        "611752105022768073",
-        "611752105025835036",
-        "611752105022765981",
-        "611752105030585049",
         "611752105022849099",
-        "611752105022770473",
-        "611752105030749746",
-        "611752105022759873",
-        "611752105030677380",
-        "611752105030692734",
-        "611752105030613571",
-        "611752105030577744",
-        "611752105030631132",
-        "611752105030516873",
-        "611752105030590780",
-        "611752105030749788",
-        "611752105030612796",
-        "611752105030477435",
-        "611752105030631134",
-        "611752105030613524",
-        "611752105030575550",
-        "611752105030631122",
-        "611752105030631123",
-        "611752105030575423",
-        "611752105030486059",
-        "611752105030534633",
-        "611752105030588028",
-        "611752105030519899",
-        "611752105030494741",
-        "611752105030631115",
-        "611752105030534524",
-        "611752105030631113",
-        "611752105030605763",
-        "611752105030534569",
-        "611752105030533659",
-        "611752105030534530",
-        "611752105030534657",
-        "611752105030519893",
-        "611752105030534522",
-        "611752105030630782",
-        "611752105030631110",
-        "611752105030575419",
         "611752105030534533",
-        "611752105030486906",
-        "611752105030631100",
-        "611752105030631102",
-        "611752105030631098",
-        "611752105029460983",
-        "611752105030501882",
-        "611752105030613534",
-        "611752105030501838",
-        "611752105030631095",
-        "611752105030749781",
-        "611752105030517875",
-        "611752105030524628",
-        "611752105030554128",
-        "611752105030486190",
-        "611752105030631097",
-        "611752105029598717",
-        "611752105030575445",
-        "611752105030577737",
-        "611752105030631090",
-        "611752105030575546",
-        "611752105030606110",
-        "611752105029470531",
-        "611752105029543873",
-        "611752105029108047",
-        "611752105030631085",
-        "611752105030749784",
-        "611752105029395401",
-        "611752105030517869",
-        "611752105030749780",
-        "611752105029372764",
-        "611752105029078391",
-        "611752105030749775",
-        "611752105029041680",
-        "611752105030553611",
-        "611752105030575421",
-        "611752105030631083",
-        "611752105029656134",
-        "611752105030629895",
-        "611752105030630403",
-        "611752105030486037",
-        "611752105029775005",
-        "611752105030488604",
-        "611752105030488606",
-        "611752105030488598",
-        "611752105024231225",
-        "611752105030532552",
-        "611752105022785811",
-        "611752105030488599",
-        "611752105030486213",
-        "611752105030588025",
-        "611752105030543997",
-        "611752105029621813",
-        "611752105030749778",
-        "611752105029071201",
-        "611752105030502743",
-        "611752105030749771",
-        "611752105030749767",
-        "611752105022774470",
-        "611752105022774235",
-        "611752105022841861",
-        "611752105030749769",
-        "611752105027460115",
-        "611752105030502999",
-        "611752105030749765",
-        "611752105030631080",
-        "611752105030613542",
-        "611752105030629539",
-        "611752105030537160",
-        "611752105023311896",
-        "611752105030749760",
         "611752105030546630",
-        "611752105030746536",
-        "611752105029725397",
-        "611752105030696955",
-        "611752105027326091",
-        "611752105030749761",
-        "611752105030608982",
-        "611752105025251372",
-        "611752105030749756",
         "611752105024973489",
-        "611752105025494485",
-        "611752105030749755",
-        "611752105030749752",
-        "611752105024649707",
-        "611752105030715216",
-        "611752105024603051",
-        "611752105030629857",
-        "611752105030575428",
-        "611752105024427478",
-        "611752105030629717",
-        "611752105030685613",
-        "611752105024293851",
-        "611752105024948883",
-        "611752105023692969",
-        "611752105029884283",
-        "611752105030749754",
-        "611752105030487035",
-        "611752105030517486",
-        "611752105030501864",
-        "611752105025320933",
-        "611752105029905830",
-        "611752105030533661",
-        "611752105028861911",
-        "611752105024692687",
-        "611752105022778708",
-        "611752105023206036",
-        "611752105022775655",
-        "611752105022615626",
-        "611752105022843286",
-        "611752105022816256",
-        "611752105022840456",
-        "611752105030533656",
-        "611752105029682899",
-        "611752105022735033",
-        "611752105029828797",
-        "611752105022734571",
-        "611752105029828798",
-        "611752105030478134",
-        "611752105030487467",
-        "611752105030487449",
-        "611752105030487446",
-        "611752105030487444",
-        "611752105030510532",
-        "611752105030510529",
-        "611752105022750188",
-        "611752105030510526",
-        "611752105030510522",
-        "611752105030510519",
-        "611752105030510517",
-        "611752105022764610",
-        "611752105030510518",
-        "611752105029971885",
-        "611752105030510512",
-        "611752105030510322",
-        "611752105030510507",
-        "611752105030510501",
-        "611752105030534898",
-        "611752105030519391",
-        "611752105022746142",
-        "611752105030534900",
-        "611752105030532401",
-        "611752105030534894",
-        "611752105030534895",
-        "611752105030534888",
-        "611752105030534890",
-        "611752105030534884",
-        "611752105030534881",
-        "611752105022742629",
-        "611752105030534882",
-        "611752105022742150",
-        "611752105030534875",
-        "611752105030534877",
-        "611752105030534872",
-        "611752105017175678",
-        "611752105030534870",
-        "611752105022774995",
-        "611752105030534863",
-        "611752105030534865",
-        "611752105030534860",
-        "611752105030534862",
-        "611752105030534853",
-        "611752105030534857",
-        "611752105030534855",
-        "611752105028815363",
-        "611752105030534850",
-        "611752105030534846",
-        "611752105030534847",
-        "611752105030534841",
-        "611752105030534836",
-        "611752105030534839",
-        "611752105030534835",
-        "611752105030534832",
-        "611752105030534833",
-        "611752105022745581",
-        "611752105030534829",
-        "611752105030534797",
-        "611752105030534827",
-        "611752105022734000",
-        "611752105022783897",
-        "611752105022756250",
-        "611752105022743999",
-        "611752105022842069",
-        "611752105022734707",
-        "611752105030534823",
-        "611752105030533676",
-        "611752105022756563",
-        "611752105030534818",
-        "611752105022728598",
-        "611752105022756527",
-        "611752105030534814",
-        "611752105030534809",
-        "611752105030534811",
-        "611752105030534805",
-        "611752105030534807",
-        "611752105030534800",
-        "611752105030534802",
-        "611752105030534793",
-        "611752105030534791",
-        "611752105030534795",
-        "611752105030534789",
-        "611752105030534787",
-        "611752105030534784",
-        "611752105030534786",
-        "611752105030534782",
-        "611752105030534776",
-        "611752105030502748",
-        "611752105030534778",
-        "611752105030534772",
-        "611752105030534774",
-        "611752105030534770",
-        "611752105030534771",
-        "611752105030534765",
-        "611752105030534767",
-        "611752105030486657",
-        "611752105030534761",
-        "611752105030534760",
-        "611752105030502989",
-        "611752105030477385",
-        "611752105030502317",
-        "611752105030502991",
-        "611752105030477381",
-        "611752105030502987",
-        "611752105030502988",
-        "611752105030502986",
-        "611752105030502981",
-        "611752105030502980",
-        "611752105030502979",
-        "611752105030477371",
-        "611752105030477355",
-        "611752105030477324",
-        "611752105030477340",
-        "611752105030477326",
-        "611752105030477328",
-        "611752105030477329",
-        "611752105030477334",
-        "611752105030477331",
-        "611752105030477335",
-        "611752105030534936",
-        "611752105022754289",
-        "611752105030534928",
-        "611752105030534932",
-        "611752105022742311",
-        "611752105030517170",
-        "611752105030534925",
-        "611752105022613859",
-        "611752105022767981",
-        "611752105030534923",
-        "611752105030534922",
-        "611752105030534917",
-        "611752105022766862",
-        "611752105022779824",
-        "611752105030534912",
-        "611752105022768760",
-        "611752105022754298",
-        "611752105020323379",
-        "611752105030534822",
-        "611752105030534914",
-        "611752105030534911",
-        "611752105030534907",
-        "611752105030534910",
-        "611752105030534902",
-        "611752105030534905",
-        "611752105030534903",
-        "611752105030533632",
-        "611752105030533628",
-        "611752105030533625",
-        "611752105030533627",
-        "611752105030533623",
-        "611752105030531356",
-        "611752105030533621",
-        "611752105030533167",
-        "611752105030533618",
-        "611752105030519552",
-        "611752105030533620",
-        "611752105030533613",
-        "611752105030519339",
-        "611752105030533616",
-        "611752105022758389",
-        "611752105022746140",
-        "611752105030510530",
-        "611752105030517837",
-        "611752105022738974",
-        "611752105022737523",
-        "611752105030517833",
-        "611752105030517835",
-        "611752105030517830",
-        "611752105022736595",
-        "611752105030517825",
-        "611752105030517821",
-        "611752105030517675",
-        "611752105030510784",
-        "611752105030517822",
-        "611752105022741828",
-        "611752105022767507",
-        "611752105022756562",
-        "611752105022736664",
-        "611752105030517819",
-        "611752105022760225",
-        "611752105030487473",
-        "611752105030487470",
-        "611752105030487471",
-        "611752105030487465",
-        "611752105030487453",
-        "611752105030502994",
-        "611752105030502995",
-        "611752105030579295",
-        "611752105030512981",
-        "611752105030511829",
-        "611752105022766404",
-        "611752105030535046",
-        "611752105030535039",
-        "611752105030535036",
-        "611752105030512997",
-        "611752105030535035",
-        "611752105030535029",
-        "611752105030535033",
-        "611752105022736597",
-        "611752105030532774",
-        "611752105030535024",
-        "611752105030532775",
-        "611752105030511831",
-        "611752105030532768",
-        "611752105030532766",
-        "611752105030510527",
-        "611752105030532761",
-        "611752105022746138",
-        "611752105030532763",
-        "611752105030532759",
-        "611752105030532757",
-        "611752105030532753",
-        "611752105030517817",
-        "611752105030517816",
-        "611752105022776359",
-        "611752105030517812",
-        "611752105030511766",
-        "611752105030517810",
-        "611752105030517805",
-        "611752105030517811",
-        "611752105030517807",
-        "611752105030517803",
-        "611752105030517797",
-        "611752105030517800",
-        "611752105030511820",
-        "611752105030535025",
-        "611752105030535018",
-        "611752105030535017",
-        "611752105030535008",
-        "611752105030535009",
-        "611752105030535005",
-        "611752105030534998",
-        "611752105030534997",
-        "611752105030500485",
-        "611752105030534995",
-        "611752105030534991",
-        "611752105029716494",
-        "611752105030534989",
-        "611752105030534984",
-        "611752105030534981",
-        "611752105030534987",
-        "611752105030534978",
-        "611752105022753677",
-        "611752105030534979",
-        "611752105030534972",
-        "611752105030534974",
-        "611752105030478107",
-        "611752105030534970",
-        "611752105030534969",
-        "611752105030534966",
-        "611752105030534968",
-        "611752105030534961",
-        "611752105030534955",
-        "611752105030534956",
-        "611752105022766937",
-        "611752105022728617",
-        "611752105030511808",
-        "611752105030534949",
-        "611752105030534948",
-        "611752105030534828",
-        "611752105022751798",
-        "611752105030534944",
-        "611752105022753550",
-        "611752105022764600",
-        "611752105022753543",
-        "611752105022751796",
-        "611752105022766946",
-        "611752105022752993",
-        "611752105022751785",
-        "611752105017175558",
-        "611752105019456874",
-        "611752105022751800",
-        "611752105019456873",
-        "611752105022751790",
-        "611752105022728619",
-        "611752105030511836",
-        "611752105030511835",
-        "611752105030511832",
-        "611752105030511826",
-        "611752105030511825",
-        "611752105030511824",
-        "611752105022736594",
-        "611752105030511818",
-        "611752105030511823",
-        "611752105030511817",
-        "611752105030477389",
-        "611752105022757080",
-        "611752105030511813",
-        "611752105030511811",
-        "611752105017523942",
-        "611752105030511809",
-        "611752105030511805",
-        "611752105030511802",
-        "611752105030511800",
-        "611752105030511804",
-        "611752105030510826",
-        "611752105022746172",
-        "611752105030511795",
-        "611752105030511798",
-        "611752105030511791",
-        "611752105030511789",
-        "611752105030511792",
-        "611752105015234050",
-        "611752105030511783",
-        "611752105030511788",
-        "611752105030511776",
-        "611752105030511777",
-        "611752105030511778",
-        "611752105030511771",
-        "611752105030511774",
-        "611752105022766072",
-        "611752105022867887",
-        "611752105030511762",
-        "611752105030511759",
-        "611752105030511764",
-        "611752105030511760",
-        "611752105030511756",
-        "611752105030511754",
-        "611752105030511757",
-        "611752105030511755",
-        "611752105030511749",
-        "611752105030511752",
-        "611752105022776363",
-        "611752105030511746",
-        "611752105030511741",
-        "611752105030511739",
-        "611752105030511745",
-        "611752105022749464",
-        "611752105030511735",
-        "611752105030511733",
-        "611752105030511732",
-        "611752105030511728",
-        "611752105030511731",
-        "611752105030511724",
-        "611752105030511727",
-        "611752105030511721",
-        "611752105030511723",
-        "611752105030511714",
-        "611752105025506040",
-        "611752105030511717",
-        "611752105030511712",
-        "611752105030511711",
-        "611752105030511709",
-        "611752105030511710",
-        "611752105030511705",
-        "611752105030511707",
-        "611752105030511704",
-        "611752105030511702",
-        "611752105030511697",
-        "611752105030511698",
-        "611752105030511699",
-        "611752105030511689",
-        "611752105030511695",
-        "611752105030511691",
-        "611752105030511687",
-        "611752105030511686",
-        "611752105030502756",
-        "611752105022738031",
-        "611752105030533703",
-        "611752105022615664",
-        "611752105029559908",
-        "611752105022771679",
-        "611752105030533702",
-        "611752105030484362",
-        "611752105020286429",
-        "611752105022738374",
-        "611752105022745335",
-        "611752105022735612",
-        "611752105030533701",
-        "611752105030533697",
-        "611752105030533694",
-        "611752105022740562",
-        "611752105022728439",
-        "611752105030549016",
-        "611752105030533692",
-        "611752105029290662",
-        "611752105030534235",
-        "611752105030534233",
-        "611752105030534237",
-        "611752105029648544",
-        "611752105029292512",
-        "611752105030534228",
-        "611752105030534229",
-        "611752105028427017",
-        "611752105030534226",
-        "611752105030534223",
-        "611752105030534221",
-        "611752105030534218",
-        "611752105027326101",
-        "611752105030534213",
-        "611752105022615442",
-        "611752105030534216",
-        "611752105030534207",
-        "611752105022735098",
-        "611752105030484299",
-        "611752105030534203",
-        "611752105030534205",
-        "611752105024597730",
-        "611752105030534199",
-        "611752105030493703",
-        "611752105030534192",
-        "611752105025878349",
-        "611752105030534197",
-        "611752105022745990",
-        "611752105024688067",
-        "611752105025642340",
-        "611752105030534189",
-        "611752105026053567",
-        "611752105030534190",
-        "611752105030534187",
-        "611752105030534188",
-        "611752105023462684",
-        "611752105029793137",
-        "611752105026206000",
-        "611752105030534182",
-        "611752105030534178",
-        "611752105023306459",
-        "611752105022614183",
-        "611752105025620881",
-        "611752105022779739",
-        "611752105022779678",
-        "611752105030534176",
-        "611752105022779272",
-        "611752105022614731",
-        "611752105022779091",
-        "611752105022779036",
-        "611752105022779173",
-        "611752105020350952",
-        "611752105030534171",
-        "611752105022762243",
-        "611752105022778981",
-        "611752105022617002",
-        "611752105030534174",
-        "611752105022778010",
-        "611752105020312969",
-        "611752105022775523",
-        "611752105022776131",
-        "611752105022782149",
-        "611752105030534166",
-        "611752105030534159",
-        "611752105030534160",
-        "611752105030477455",
-        "611752105030534157",
-        "611752105022616500",
-        "611752105030494868",
-        "611752105030477443",
-        "611752105025561706",
-        "611752105030395019",
-        "611752105022777442",
-        "611752105022777346",
-        "611752105020417690",
-        "611752105022779286",
-        "611752105015223257",
-        "611752105022743925",
-        "611752105022781475",
-        "611752105030477439",
-        "611752105029598755",
-        "611752105030534119",
-        "611752105030534118",
-        "611752105029372495",
-        "611752105030534114",
-        "611752105029089788",
-        "611752105030534116",
-        "611752105029059939",
-        "611752105029014742",
-        "611752105030534110",
-        "611752105030534107",
-        "611752105030517531",
-        "611752105030534109",
-        "611752105028884268",
-        "611752105028077538",
-        "611752105030534104",
-        "611752105030485471",
-        "611752105030534099",
-        "611752105027734180",
-        "611752105027013130",
-        "611752105030534101",
-        "611752105027307636",
-        "611752105030534095",
-        "611752105026536894",
-        "611752105030534092",
-        "611752105030534087",
-        "611752105022734326",
-        "611752105030534089",
-        "611752105030534084",
-        "611752105030534083",
-        "611752105030534086",
-        "611752105030534079",
-        "611752105030534080",
-        "611752105030534076",
-        "611752105030502433",
-        "611752105030534073",
-        "611752105030534070",
-        "611752105030534063",
-        "611752105030534066",
-        "611752105030534058",
-        "611752105030485505",
-        "611752105030485451",
-        "611752105030485496",
-        "611752105030534052",
-        "611752105030549027",
-        "611752105030502948",
-        "611752105030534043",
-        "611752105030534039",
-        "611752105029811022",
-        "611752105030503069",
-        "611752105030503060",
-        "611752105030503061",
-        "611752105030503056",
-        "611752105030503055",
-        "611752105030503058",
-        "611752105029679804",
-        "611752105030503051",
-        "611752105030503052",
-        "611752105022741017",
-        "611752105030534036",
-        "611752105030534032",
-        "611752105022770483",
-        "611752105022767605",
-        "611752105030534038",
-        "611752105022737629",
-        "611752105022684280",
-        "611752105030534029",
-        "611752105022616097",
-        "611752105022733656",
-        "611752105030534030",
-        "611752105022745332",
-        "611752105022757669",
-        "611752105022736582",
-        "611752105022737670",
-        "611752105026284675",
-        "611752105022744842",
-        "611752105030534023",
-        "611752105022748226",
-        "611752105022747063",
-        "611752105022746951",
-        "611752105022746771",
-        "611752105022746396",
-        "611752105022615679",
-        "611752105030534026",
-        "611752105030534020",
-        "611752105030534021",
-        "611752105030534012",
-        "611752105022728751",
-        "611752105022737944",
-        "611752105020312920",
-        "611752105030534014",
-        "611752105030533706",
-        "611752105022728608",
-        "611752105022741354",
-        "611752105030533709",
-        "611752105030533704",
-        "611752105020285052",
-        "611752105022735582",
-        "611752105022736895",
-        "611752105022735335",
-        "611752105022740370",
-        "611752105022735477",
-        "611752105022747092",
-        "611752105022735287",
-        "611752105030517881",
-        "611752105022729042",
-        "611752105029292318",
-        "611752105030534155",
-        "611752105029292373",
-        "611752105030534148",
-        "611752105030534151",
-        "611752105022841952",
-        "611752105030549020",
-        "611752105022841711",
-        "611752105030534140",
-        "611752105030447628",
-        "611752105022841551",
-        "611752105030534137",
-        "611752105030297502",
-        "611752105030534130",
-        "611752105030081524",
-        "611752105030534131",
-        "611752105030534133",
-        "611752105030534129",
-        "611752105029671892",
-        "611752105029829254",
-        "611752105029930253",
-        "611752105029721611",
-        "611752105022838332",
-        "611752105029930254",
-        "611752105029847794",
-        "611752105030534126",
-        "611752105029930252",
-        "611752105025485945",
-        "611752105030534128",
-        "611752105030534121",
-        "611752105030517880",
-        "611752105020244661",
-        "611752105020317620",
-        "611752105022765813",
-        "611752105022748396",
-        "611752105022744917",
-        "611752105022737637",
-        "611752105022729150",
-        "611752105022739001",
-        "611752105022735929",
-        "611752105023350223",
-        "611752105023236677",
-        "611752105023134538",
-        "611752105020315328",
-        "611752105020315311",
-        "611752105022728506",
-        "611752105020315318",
-        "611752105020315291",
-        "611752105022728502",
-        "611752105029793660",
-        "611752105022743194",
-        "611752105022728503",
-        "611752105022728501",
-        "611752105022758791",
-        "611752105020315295",
-        "611752105030533690",
-        "611752105020315315",
-        "611752105022782052",
-        "611752105022781595",
-        "611752105022614627",
-        "611752105022835628",
-        "611752105022774290",
-        "611752105022782808",
-        "611752105022614603",
-        "611752105022776830",
-        "611752105022769568",
-        "611752105022769209",
-        "611752105022762682",
-        "611752105022760430",
-        "611752105022760328",
-        "611752105022758116",
-        "611752105022755798",
-        "611752105022776006",
-        "611752105022751975",
-        "611752105022750320",
-        "611752105030533685",
-        "611752105022748823",
-        "611752105022748606",
-        "611752105022744853",
-        "611752105022744815",
-        "611752105022744547",
-        "611752105022741686",
-        "611752105022741682",
-        "611752105022741507",
-        "611752105030533682",
-        "611752105020343694",
-        "611752105030533683",
-        "611752105022737678",
-        "611752105022739925",
-        "611752105022613495",
-        "611752105022745595",
-        "611752105022773676",
-        "611752105020336086",
-        "611752105030533679",
-        "611752105022739980",
-        "611752105022752074",
-        "611752105022758995",
-        "611752105022736756",
-        "611752105030487053",
-        "611752105022739935",
-        "611752105030533677",
-        "611752105022745578",
-        "611752105022615545",
-        "611752105030487548",
-        "611752105022734583",
-        "611752105022775964",
-        "611752105022767591",
-        "611752105022734681",
-        "611752105022736410",
-        "611752105022737988",
-        "611752105030533670",
-        "611752105022738410",
-        "611752105022737491",
-        "611752105022754375",
-        "611752105022734375",
-        "611752105022758367",
-        "611752105022739564",
-        "611752105022736344",
-        "611752105022741062",
-        "611752105022741066",
-        "611752105022742722",
-        "611752105030487546",
-        "611752105022728554",
-        "611752105022741309",
-        "611752105022743649",
-        "611752105030487537",
-        "611752105030487541",
-        "611752105022612763",
-        "611752105022729137",
-        "611752105030487542",
-        "611752105030487533",
-        "611752105022757002",
-        "611752105022752811",
-        "611752105030487535",
-        "611752105026025983",
-        "611752105030487527",
-        "611752105022741983",
-        "611752105022742724",
-        "611752105022746341",
-        "611752105022738189",
-        "611752105022738184",
-        "611752105022741452",
-        "611752105022738191",
-        "611752105022741969",
-        "611752105022753899",
-        "611752105022738199",
-        "611752105022727924",
-        "611752105022766031",
-        "611752105022764587",
-        "611752105022727888",
-        "611752105022765309",
-        "611752105022741454",
-        "611752105030487530",
-        "611752105026298869",
-        "611752105022728746",
-        "611752105022738287",
-        "611752105022728970",
-        "611752105030534366",
-        "611752105022748295",
-        "611752105030534364",
-        "611752105022736566",
-        "611752105030534369",
-        "611752105030534361",
-        "611752105022728530",
-        "611752105030534363",
-        "611752105030534353",
-        "611752105025578900",
-        "611752105030534357",
-        "611752105030534350",
-        "611752105030534347",
-        "611752105022730853",
-        "611752105030534346",
-        "611752105022737665",
-        "611752105030534336",
-        "611752105015225867",
-        "611752105030534330",
-        "611752105022745131",
-        "611752105030534327",
-        "611752105030534331",
-        "611752105030534328",
-        "611752105030534325",
-        "611752105030534326",
-        "611752105030163339",
-        "611752105029372457",
-        "611752105030534320",
-        "611752105028870529",
-        "611752105028941764",
-        "611752105030534314",
-        "611752105030534317",
-        "611752105023316783",
-        "611752105030534309",
-        "611752105030534312",
-        "611752105030534305",
-        "611752105030534300",
-        "611752105030534299",
-        "611752105030534298",
-        "611752105027460114",
-        "611752105030534295",
-        "611752105030534278",
-        "611752105024938858",
-        "611752105030534273",
-        "611752105030534267",
-        "611752105030534270",
-        "611752105030534268",
-        "611752105030534259",
-        "611752105030534262",
-        "611752105030534255",
-        "611752105022731396",
-        "611752105029674015",
-        "611752105030534254",
-        "611752105028863479",
-        "611752105030534250",
-        "611752105022840491",
-        "611752105022838759",
-        "611752105029780803",
-        "611752105020317743",
-        "611752105022762966",
-        "611752105022775119",
-        "611752105022764453",
-        "611752105022762677",
-        "611752105030534251",
-        "611752105030534240",
-        "611752105026134511",
-        "611752105022762274",
-        "611752105030517900",
-        "611752105030517901",
-        "611752105022762246",
-        "611752105030517895",
-        "611752105022613371",
-        "611752105022759613",
-        "611752105020325590",
-        "611752105022765496",
-        "611752105022837370",
-        "611752105020336088",
-        "611752105022760371",
-        "611752105030517890",
-        "611752105022785592",
-        "611752105022763513",
-        "611752105022616510",
-        "611752105025840619",
-        "611752105030517891",
-        "611752105030517892",
-        "611752105023674622",
-        "611752105023991996",
-        "611752105022745395",
-        "611752105022736204",
-        "611752105022755104",
-        "611752105022728458",
-        "611752105022735445",
-        "611752105022728700",
-        "611752105022774552",
-        "611752105023541369",
-        "611752105022615405",
-        "611752105030517886",
-        "611752105022770831",
-        "611752105022728171",
-        "611752105022728585",
-        "611752105030502180",
-        "611752105030517882",
-        "611752105022736082",
-        "611752105022731307",
-        "611752105022764447",
-        "611752105022772310",
-        "611752105030503037",
-        "611752105030290302",
-        "611752105022766874",
-        "611752105026053371",
-        "611752105022735624",
-        "611752105022735633",
-        "611752105022735417",
-        "611752105030503035",
-        "611752105030503031",
-        "611752105022771159",
-        "611752105022739107",
-        "611752105030503030",
-        "611752105022745594",
-        "611752105022837502",
-        "611752105022741087",
-        "611752105026577966",
-        "611752105022737488",
-        "611752105022745279",
-        "611752105030503027",
-        "611752105022740098",
-        "611752105023422859",
-        "611752105030503026",
-        "611752105022779809",
-        "611752105022765354",
-        "611752105022613925",
-        "611752105022771576",
-        "611752105022775537",
-        "611752105022775538",
-        "611752105022779636",
-        "611752105022780851",
-        "611752105022727865",
-        "611752105022728276",
-        "611752105030534537",
-        "611752105030534508",
-        "611752105030532603",
-        "611752105030534500",
-        "611752105028523416",
-        "611752105030534494",
-        "611752105025490200",
-        "611752105022765050",
-        "611752105022757074",
-        "611752105022759178",
-        "611752105030534486",
-        "611752105022752203",
-        "611752105022616241",
-        "611752105030532880",
-        "611752105022747406",
-        "611752105022745654",
-        "611752105022744814",
-        "611752105022743993",
-        "611752105022741984",
-        "611752105030503068",
-        "611752105030503064",
-        "611752105022612785",
-        "611752105022774159",
-        "611752105030534481",
-        "611752105022876405",
-        "611752105022744435",
-        "611752105022771985",
-        "611752105022734299",
-        "611752105030534478",
-        "611752105022731354",
-        "611752105022738103",
-        "611752105030534476",
-        "611752105030534470",
-        "611752105028966250",
-        "611752105030534473",
-        "611752105030534464",
-        "611752105030534466",
-        "611752105029997489",
-        "611752105030534462",
-        "611752105027204714",
-        "611752105030534458",
-        "611752105030534093",
-        "611752105027118626",
-        "611752105024456404",
-        "611752105030534460",
-        "611752105023079995",
-        "611752105023922406",
-        "611752105030534454",
-        "611752105023697802",
-        "611752105023692975",
-        "611752105023474437",
-        "611752105023453838",
-        "611752105030534450",
-        "611752105023379081",
-        "611752105030534452",
-        "611752105022838893",
-        "611752105022736014",
-        "611752105030534447",
-        "611752105022746475",
-        "611752105022742651",
-        "611752105022742300",
-        "611752105022741506",
-        "611752105022741003",
-        "611752105022740864",
-        "611752105022740419",
-        "611752105030503029",
-        "611752105022739942",
-        "611752105022738502",
-        "611752105022736464",
-        "611752105022769599",
-        "611752105022769474",
-        "611752105022783729",
-        "611752105022767321",
-        "611752105022765698",
-        "611752105022758610",
-        "611752105030534449",
-        "611752105022735138",
-        "611752105022740347",
-        "611752105022735183",
-        "611752105022770475",
-        "611752105022755132",
-        "611752105022739996",
-        "611752105015232231",
-        "611752105022784202",
-        "611752105022776412",
-        "611752105022752740",
-        "611752105022785391",
-        "611752105022735148",
-        "611752105022735168",
-        "611752105022735288",
-        "611752105022735231",
-        "611752105022735218",
-        "611752105022731649",
-        "611752105022735175",
-        "611752105022735430",
-        "611752105022785389",
-        "611752105022735408",
-        "611752105022735419",
-        "611752105022735376",
-        "611752105022735195",
-        "611752105022735219",
-        "611752105030534444",
-        "611752105022736481",
-        "611752105022735434",
-        "611752105030534441",
-        "611752105022729528",
-        "611752105020376524",
-        "611752105022735239",
-        "611752105022735423",
-        "611752105022735170",
-        "611752105022731614",
-        "611752105022731612",
-        "611752105022735338",
-        "611752105022735147",
-        "611752105022615417",
-        "611752105022735223",
-        "611752105022770479",
-        "611752105022735180",
-        "611752105022735184",
-        "611752105022735193",
-        "611752105015224460",
-        "611752105022735189",
-        "611752105022735186",
-        "611752105022759114",
-        "611752105022735197",
-        "611752105030534439",
-        "611752105030534438",
-        "611752105022758942",
-        "611752105022616987",
-        "611752105022735166",
-        "611752105022736247",
-        "611752105015229219",
-        "611752105022735130",
-        "611752105022731371",
-        "611752105022736148",
-        "611752105030534434",
-        "611752105022785609",
-        "611752105022735122",
-        "611752105022744317",
-        "611752105022765320",
-        "611752105022781097",
-        "611752105022767191",
-        "611752105022770279",
-        "611752105022764450",
-        "611752105022762248",
-        "611752105022757024",
-        "611752105022749968",
-        "611752105022750508",
-        "611752105022746807",
-        "611752105022734330",
-        "611752105020315310",
-        "611752105022615691",
-        "611752105030534436",
-        "611752105030534426",
-        "611752105030534428",
-        "611752105030534432",
-        "611752105020388755",
-        "611752105022747659",
-        "611752105022728460",
-        "611752105030534420",
-        "611752105030534424",
-        "611752105022745630",
-        "611752105030534415",
-        "611752105022731406",
-        "611752105030534414",
-        "611752105030534408",
-        "611752105022769974",
-        "611752105022745579",
-        "611752105022757926",
-        "611752105030534406",
-        "611752105022750938",
-        "611752105030534402",
-        "611752105030534400",
-        "611752105030534061",
-        "611752105030534394",
-        "611752105022777167",
-        "611752105022749976",
-        "611752105022734324",
-        "611752105030534396",
-        "611752105022728508",
-        "611752105022731417",
-        "611752105030534391",
-        "611752105030534387",
-        "611752105022731655",
-        "611752105022756545",
-        "611752105022742792",
-        "611752105030534383",
-        "611752105028427015",
-        "611752105024321930",
-        "611752105023470437",
-        "611752105030534376",
-        "611752105030534386",
-        "611752105026561454",
-        "611752105022805439",
-        "611752105022766856",
-        "611752105022736484",
-        "611752105022748229",
-        "611752105022742211",
-        "611752105022735125",
-        "611752105030534378",
-        "611752105030534239",
-        "611752105023359467",
-        "611752105022735634",
-        "611752105015226169",
-        "611752105030534371",
-        "611752105030533687",
-        "611752105030533689",
-        "611752105022613562",
-        "611752105022774179",
-        "611752105022748102",
-        "611752105022745303",
-        "611752105030439122",
-        "611752105020293284",
-        "611752105022758409",
-        "611752105022739568",
-        "611752105030503045",
-        "611752105030503040",
-        "611752105022779830",
-        "611752105022744850",
-        "611752105022757916",
-        "611752105030503041",
-        "611752105030487511",
-        "611752105022728230",
-        "611752105022843505",
-        "611752105030487506",
-        "611752105022647051",
-        "611752105022647089",
-        "611752105030487504",
-        "611752105022841664",
-        "611752105022840122",
-        "611752105022838925",
-        "611752105028884850",
-        "611752105022836945",
-        "611752105022814286",
-        "611752105022781874",
-        "611752105022786310",
-        "611752105022785746",
-        "611752105022785087",
-        "611752105022784868",
-        "611752105022784778",
-        "611752105022784701",
-        "611752105022784640",
-        "611752105022783548",
-        "611752105022783536",
-        "611752105028990763",
-        "611752105026580834",
-        "611752105030533652",
-        "611752105022615242",
-        "611752105030533647",
-        "611752105022756911",
-        "611752105022756136",
-        "611752105020343689",
-        "611752105022757937",
-        "611752105022616890",
-        "611752105022776564",
-        "611752105022770514",
-        "611752105022778149",
-        "611752105029648610",
-        "611752105022729224",
-        "611752105023678576",
-        "611752105022837493",
-        "611752105022754512",
-        "611752105023453795",
-        "611752105022612344",
-        "611752105023400809",
-        "611752105022759127",
-        "611752105026296526",
-        "611752105025957373",
-        "611752105022647105",
-        "611752105030509703",
-        "611752105030509697",
-        "611752105022667231",
-        "611752105022647042",
-        "611752105026615103",
-        "611752105029857828",
-        "611752105022729402",
-        "611752105020336082",
-        "611752105020283863",
-        "611752105022728451",
-        "611752105022766870",
-        "611752105022739716",
-        "611752105022613565",
-        "611752105022742517",
-        "611752105022736162",
-        "611752105022729420",
-        "611752105030509699",
-        "611752105030509689",
-        "611752105022755896",
-        "611752105030503649",
-        "611752105030509688",
-        "611752105017179109",
-        "611752105020279121",
-        "611752105022771003",
-        "611752105022772227",
-        "611752105022767611",
-        "611752105030509692",
-        "611752105028932368",
-        "611752105030534560",
-        "611752105028941797",
-        "611752105029014728",
-        "611752105030534561",
-        "611752105030534558",
-        "611752105028815364",
-        "611752105028778355",
-        "611752105030534551",
-        "611752105027416620",
-        "611752105030534547",
-        "611752105030534544",
-        "611752105027133941",
-        "611752105027109673",
-        "611752105026943591",
-        "611752105030534209",
-        "611752105026465932",
-        "611752105025219758",
-        "611752105030534546",
-        "611752105030487523",
-        "611752105030487525",
-        "611752105024961748",
-        "611752105024743080",
-        "611752105024938857",
-        "611752105030487520",
-        "611752105024481596",
-        "611752105024598733",
-        "611752105024182871",
-        "611752105030487517",
-        "611752105023977090",
-        "611752105030487513",
-        "611752105023751007",
-        "611752105023808553",
-        "611752105023490409",
-        "611752105023465792",
-        "611752105023465780",
-        "611752105029679458",
-        "611752105029684285",
-        "611752105030487515",
-        "611752105023179057",
-        "611752105023171356",
-        "611752105025494394",
-        "611752105030562361",
-        "611752105029381729",
-        "611752105029089797",
-        "611752105030534579",
-        "611752105030533671",
-        "611752105028408817",
-        "611752105030533664",
-        "611752105030503022",
-        "611752105027668947",
-        "611752105030503020",
-        "611752105023249129",
-        "611752105030503019",
-        "611752105030503018",
-        "611752105030503015",
-        "611752105030503016",
-        "611752105022728078",
-        "611752105023465790",
-        "611752105022747048",
-        "611752105022838668",
-        "611752105022782376",
-        "611752105022748258",
-        "611752105030503013",
-        "611752105022785794",
-        "611752105030486093",
-        "611752105030484121",
-        "611752105029461022",
-        "611752105027781493",
-        "611752105030544745",
-        "611752105029432778",
-        "611752105028820619",
-        "611752105028932361",
-        "611752105015232582",
-        "611752105022759033",
-        "611752105022612786",
-        "611752105030487475",
-        "611752105022732215",
-        "611752105022729163",
-        "611752105030534711",
-        "611752105029590453",
-        "611752105030534714",
-        "611752105030534709",
-        "611752105030534708",
-        "611752105030534699",
-        "611752105030534703",
-        "611752105030534697",
-        "611752105030534692",
-        "611752105030534689",
-        "611752105030534686",
-        "611752105030534687",
-        "611752105030534684",
-        "611752105030534680",
-        "611752105030534682",
-        "611752105030534675",
-        "611752105030534674",
-        "611752105030534677",
-        "611752105030534669",
-        "611752105030534671",
-        "611752105029291860",
-        "611752105030534665",
-        "611752105030534667",
-        "611752105027734182",
-        "611752105030532701",
-        "611752105027626957",
-        "611752105030532696",
-        "611752105030517855",
-        "611752105025184103",
-        "611752105030517856",
-        "611752105024164143",
-        "611752105030517852",
-        "611752105026681421",
-        "611752105024571437",
-        "611752105022779865",
-        "611752105030517845",
-        "611752105030493464",
-        "611752105030517843",
-        "611752105030517018",
-        "611752105030517014",
-        "611752105022838003",
-        "611752105024118499",
-        "611752105030517015",
-        "611752105030517012",
-        "611752105025587378",
-        "611752105023644389",
-        "611752105023616289",
-        "611752105025502433",
-        "611752105030517008",
-        "611752105024199100",
-        "611752105030517003",
-        "611752105030547980",
-        "611752105030532598",
-        "611752105030563567",
-        "611752105030534664",
-        "611752105030534655",
-        "611752105030534658",
-        "611752105030516867",
-        "611752105030502003",
-        "611752105030516839",
-        "611752105030486195",
-        "611752105030486199",
-        "611752105030516806",
-        "611752105030501992",
-        "611752105030516843",
-        "611752105030534648",
-        "611752105030502001",
-        "611752105030534650",
-        "611752105030534646",
-        "611752105030534642",
-        "611752105030494834",
-        "611752105030534644",
-        "611752105030494835",
-        "611752105030534635",
-        "611752105030534640",
-        "611752105030502036",
-        "611752105030516809",
-        "611752105030524671",
-        "611752105030516800",
-        "611752105030486074",
-        "611752105030516793",
-        "611752105030502039",
-        "611752105030516797",
-        "611752105030534628",
-        "611752105030534629",
-        "611752105030502012",
-        "611752105030486077",
-        "611752105030534565",
-        "611752105030502010",
-        "611752105030548957",
-        "611752105030502006",
-        "611752105030534567",
-        "611752105030501988",
-        "611752105030534572",
-        "611752105030534621",
-        "611752105030534562",
-        "611752105030534611",
-        "611752105030534616",
-        "611752105030501914",
-        "611752105030534607",
-        "611752105030534609",
-        "611752105030501878",
-        "611752105030501911",
-        "611752105030501933",
-        "611752105030534605",
-        "611752105030534604",
-        "611752105030501924",
-        "611752105030501923",
-        "611752105030501887",
-        "611752105030501908",
-        "611752105030501884",
-        "611752105030534602",
-        "611752105030494828",
-        "611752105030534595",
-        "611752105029443799",
-        "611752105029607102",
-        "611752105030501870",
-        "611752105030534597",
-        "611752105030486048",
-        "611752105030534591",
-        "611752105030534585",
-        "611752105030534580",
-        "611752105029621810",
-        "611752105030534582",
-        "611752105030534758",
-        "611752105030720441",
-        "611752105030674556",
-        "611752105030734815",
-        "611752105030478335",
-        "611752105030617020",
-        "611752105030534757",
-        "611752105030562373",
-        "611752105030484764",
-        "611752105030534752",
-        "611752105030562367",
-        "611752105030548060",
-        "611752105030534746",
-        "611752105030488653",
-        "611752105030486042",
-        "611752105030580658",
-        "611752105030534740",
-        "611752105030534742",
-        "611752105030483278",
-        "611752105030534735",
-        "611752105030534731",
-        "611752105030484754",
-        "611752105030533666",
-        "611752105030534724",
-        "611752105030534728",
-        "611752105030517084",
-        "611752105030483706",
-        "611752105030488560",
-        "611752105030478345",
-        "611752105030534716",
-        "611752105030533645",
-        "611752105030533640",
-        "611752105030533642",
-        "611752105030484779",
-        "611752105030533638",
-        "611752105030532828",
-        "611752105030484685",
-        "611752105030533639",
-        "611752105030487036",
-        "611752105030533636",
-        "611752105030533634",
-        "611752105030486915",
-        "611752105030533631",
-        "611752105030503009",
-        "611752105030485147",
-        "611752105030503008",
-        "611752105029490571",
-        "611752105029621629",
-        "611752105025957412",
-        "611752105029543728",
-        "611752105020343687",
-        "611752105030486032",
-        "611752105026630785",
-        "611752105022736112",
-        "611752105030487479",
-        "611752105022731299",
-        "611752105022753910",
-        "611752105020282612",
-        "611752105030487480",
-        "611752105022743845",
-        "611752105022728711",
-        "611752105022742481",
+        "611752105022735483",
+        "611752105030535129",
+        "611752105025453401",
+        "611752105030747599",
+        "611752105027626963",
+        "611752105030739531",
+        "611752105030535838",
+        "611752105022838265",
+        "611752105024748258",
+        "611752105024608148",
+        "611752105022824550",
+        "611752105022768795",
+        "611752105022784953",
+        "611752105030555729",
+        "611752105025979439",
+        "611752105030485353",
+        "611752105030485358",
+        "611752105030485344",
+        "611752105030485349",
+        "611752105030485351",
+        "611752105030485336",
+        "611752105030485342",
+        "611752105030485329",
+        "611752105030485338",
+        "611752105030485325",
+        "611752105030485331",
+        "611752105030485322",
+        "611752105030485316",
+        "611752105030485319",
+        "611752105030485317",
+        "611752105030485313",
+        "611752105030485309",
+        "611752105030485308",
+        "611752105030485307",
+        "611752105030776031",
+        "611752105030598568",
+        "611752105030485410",
+        "611752105030485397",
+        "611752105030478370",
+        "611752105030485402",
+        "611752105030485404",
+        "611752105030485399",
+        "611752105030485379",
+        "611752105030485383",
+        "611752105030485368",
+        "611752105030485395",
+        "611752105030485387",
+        "611752105030485385",
+        "611752105030776030",
+        "611752105030776028",
+        "611752105030485389",
+        "611752105030485378",
+        "611752105030485392",
+        "611752105030775926",
+        "611752105030775928",
+        "611752105030775920",
+        "611752105030775915",
+        "611752105030590328",
+        "611752105030775906",
+        "611752105030775902",
+        "611752105030775710",
+        "611752105030775707",
+        "611752105030775705",
+        "611752105030775695",
+        "611752105030775692",
+        "611752105030775685",
+        "611752105030775684",
+        "611752105030775683",
+        "611752105030775680",
+        "611752105030775677",
+        "611752105030775984",
+        "611752105030775980",
+        "611752105030775976",
+        "611752105030775969",
+        "611752105030775965",
+        "611752105030775966",
+        "611752105030775962",
+        "611752105030775959",
+        "611752105030775956",
+        "611752105030775951",
+        "611752105030775948",
+        "611752105030775947",
+        "611752105030775938",
+        "611752105030775934",
+        "611752105025482876",
+        "611752105030775932",
+        "611752105030776026",
+        "611752105030776015",
+        "611752105030776012",
+        "611752105030776009",
+        "611752105030776005",
+        "611752105030775998",
+        "611752105030775995",
+        "611752105030775990",
+        "611752105030775900",
+        "611752105022616654",
+        "611752105030775889",
+        "611752105030775884",
+        "611752105029290545",
+        "611752105022615521",
+        "611752105030775881",
+        "611752105029399015",
+        "611752105022613888",
+        "611752105022616835",
+        "611752105029381793",
+        "611752105030775864",
+        "611752105030579638",
+        "611752105030775853",
+        "611752105030775850",
+        "611752105026149436",
+        "611752105030775837",
+        "611752105030775836",
+        "611752105030775817",
+        "611752105030775813",
+        "611752105030775815",
+        "611752105030775809",
+        "611752105030775806",
+        "611752105030775802",
+        "611752105030775795",
+        "611752105030775790",
+        "611752105030775785",
+        "611752105030775782",
+        "611752105030775780",
+        "611752105030775775",
+        "611752105030775766",
+        "611752105030775768",
+        "611752105023363347",
+        "611752105030775764",
+        "611752105030775756",
+        "611752105022615516",
+        "611752105030706110",
+        "611752105030775751",
+        "611752105030775750",
+        "611752105030775746",
+        "611752105030775744",
+        "611752105030775741",
+        "611752105030775736",
+        "611752105022770764",
+        "611752105030775732",
+        "611752105030775734",
+        "611752105030775730",
+        "611752105030560609",
+        "611752105030775725",
+        "611752105030560604",
+        "611752105030775713"
     ]
 
     ban = deepcopy(banned_user_map)
     ban["db"] = "av_db"
 
     for sid in arr:
         url = get_url_by_song_id(sid)
         if url is not None:
             print("out,{},{}".format(url, sid))
             # 只要没有对外输出过，均可以向其中填充
             sql = "select song_id from svc_queue_table where song_id={} and (song_src in (3, 4, 5) and state=2)".format(sid)
             data = get_data_by_mysql(sql, ban)
             if len(data) == 0:
                 tm = int(time.time())
                 sql = "replace INTO svc_queue_table (song_id, url, create_time, update_time, song_src) VALUES ({}, \"{}\",{}, {}, 4)" \
                     .format(sid, url, tm, tm)
                 update_db(sql, ban)
 
 
 def get_data_from_song():
     sql = """
     select tb1.song_id, tb1.recording_count
     from (
         select song_id,recording_count
         from starmaker.song
         where song_src in (108,109) and song_status = 2
         order by recording_count desc
     ) as tb1
     left join 
     (
         select song_id
         from av_db.svc_queue_table
     ) as tb2
     on tb1.song_id = tb2.song_id
     where tb2.song_id is null
     order by tb1.recording_count desc limit 5000
     """
     ban = deepcopy(banned_user_map)
     ban_v1 = deepcopy(banned_user_map)
     ban["db"] = "starmaker_musicbook"
     ban_v1["db"] = "av_db"
     data = get_data_by_mysql(sql, ban)
     for dt in data:
         sid = dt[0]
         url = get_url_by_song_id(sid)
         if url is not None:
             print("out,{},{}".format(url, sid))
             tm = int(time.time())
             sql = "insert INTO svc_queue_table (song_id, url, create_time, update_time, song_src) VALUES ({}, \"{}\", {}, {}, 3)" \
                 .format(sid, url, tm, tm)
             update_db(sql, ban_v1)
 
 
 if __name__ == '__main__':
     # get_diff_song()
     # get_data_from_song()
     process()